stream_encoder.c:safe_calloc_: 116| 61.9k|{ 117| 61.9k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 118| | /* Fail if requested */ 119| 61.9k| if(alloc_check()) ------------------ | Branch (119:5): [True: 0, False: 61.9k] ------------------ 120| 0| return NULL; 121| 61.9k|#endif 122| 61.9k| if(!nmemb || !size) ------------------ | Branch (122:5): [True: 0, False: 61.9k] | Branch (122:15): [True: 0, False: 61.9k] ------------------ 123| 0| return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */ 124| 61.9k| return calloc(nmemb, size); 125| 61.9k|} stream_encoder.c:alloc_check: 70| 61.9k|static inline int alloc_check(void) { 71| 61.9k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 61.9k, False: 0] ------------------ 72| 61.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| 61.9k|} bitwriter.c:safe_realloc_nofree_mul_2op_: 290| 1.69k|{ 291| 1.69k| if(!size1 || !size2) ------------------ | Branch (291:5): [True: 0, False: 1.69k] | Branch (291:15): [True: 0, False: 1.69k] ------------------ 292| 0| return realloc(ptr, 0); /* preserve POSIX realloc(ptr, 0) semantics */ 293| 1.69k| if(size1 > SIZE_MAX / size2) ------------------ | Branch (293:5): [True: 0, False: 1.69k] ------------------ 294| 0| return 0; 295| 1.69k| return realloc_(ptr, size1*size2); 296| 1.69k|} bitwriter.c:realloc_: 219| 1.69k|{ 220| | /* Fail if requested */ 221| 1.69k| if(alloc_check()) ------------------ | Branch (221:5): [True: 0, False: 1.69k] ------------------ 222| 0| return NULL; 223| 1.69k| return realloc(ptr, size); 224| 1.69k|} bitwriter.c:alloc_check: 70| 1.69k|static inline int alloc_check(void) { 71| 1.69k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 1.69k, False: 0] ------------------ 72| 1.69k| 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.69k|} format.c:safe_realloc_: 200| 450k|{ 201| 450k| void *oldptr; 202| 450k| void *newptr; 203| 450k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 204| | /* Fail if requested */ 205| 450k| if(alloc_check() && size > 0) { ------------------ | Branch (205:5): [True: 0, False: 450k] | Branch (205:22): [True: 0, False: 0] ------------------ 206| 0| free(ptr); 207| 0| return NULL; 208| 0| } 209| 450k|#endif 210| 450k| oldptr = ptr; 211| 450k| newptr = realloc(ptr, size); 212| 450k| if(size > 0 && newptr == 0) ------------------ | Branch (212:5): [True: 450k, False: 0] | Branch (212:17): [True: 0, False: 450k] ------------------ 213| 0| free(oldptr); 214| 450k| return newptr; 215| 450k|} format.c:alloc_check: 70| 450k|static inline int alloc_check(void) { 71| 450k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 450k, False: 0] ------------------ 72| 450k| 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| 450k|} md5.c:safe_realloc_: 200| 9.49k|{ 201| 9.49k| void *oldptr; 202| 9.49k| void *newptr; 203| 9.49k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 204| | /* Fail if requested */ 205| 9.49k| if(alloc_check() && size > 0) { ------------------ | Branch (205:5): [True: 0, False: 9.49k] | Branch (205:22): [True: 0, False: 0] ------------------ 206| 0| free(ptr); 207| 0| return NULL; 208| 0| } 209| 9.49k|#endif 210| 9.49k| oldptr = ptr; 211| 9.49k| newptr = realloc(ptr, size); 212| 9.49k| if(size > 0 && newptr == 0) ------------------ | Branch (212:5): [True: 9.49k, False: 0] | Branch (212:17): [True: 0, False: 9.49k] ------------------ 213| 0| free(oldptr); 214| 9.49k| return newptr; 215| 9.49k|} md5.c:alloc_check: 70| 9.49k|static inline int alloc_check(void) { 71| 9.49k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 9.49k, False: 0] ------------------ 72| 9.49k| 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.49k|} memory.c:safe_malloc_add_2op_: 130| 366k|{ 131| 366k| size2 += size1; 132| 366k| if(size2 < size1) ------------------ | Branch (132:5): [True: 0, False: 366k] ------------------ 133| 0| return 0; 134| 366k| return safe_malloc_(size2); 135| 366k|} memory.c:safe_malloc_: 89| 366k|{ 90| 366k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 91| | /* Fail if requested */ 92| 366k| if(alloc_check()) ------------------ | Branch (92:5): [True: 0, False: 366k] ------------------ 93| 0| return NULL; 94| 366k|#endif 95| | /* malloc(0) is undefined; FLAC src convention is to always allocate */ 96| 366k| if(!size) ------------------ | Branch (96:5): [True: 0, False: 366k] ------------------ 97| 0| size++; 98| 366k| return malloc(size); 99| 366k|} memory.c:alloc_check: 70| 366k|static inline int alloc_check(void) { 71| 366k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 366k, False: 0] ------------------ 72| 366k| 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| 366k|} stream_decoder.c:safe_calloc_: 116| 26.2k|{ 117| 26.2k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 118| | /* Fail if requested */ 119| 26.2k| if(alloc_check()) ------------------ | Branch (119:5): [True: 0, False: 26.2k] ------------------ 120| 0| return NULL; 121| 26.2k|#endif 122| 26.2k| if(!nmemb || !size) ------------------ | Branch (122:5): [True: 0, False: 26.2k] | Branch (122:15): [True: 0, False: 26.2k] ------------------ 123| 0| return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */ 124| 26.2k| return calloc(nmemb, size); 125| 26.2k|} stream_decoder.c:alloc_check: 70| 40.2k|static inline int alloc_check(void) { 71| 40.2k| if(alloc_check_threshold == INT32_MAX) ------------------ | Branch (71:5): [True: 40.2k, False: 0] ------------------ 72| 40.2k| 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| 40.2k|} stream_decoder.c:safe_malloc_muladd2_: 188| 14.0k|{ 189| 14.0k| if(!size1 || (!size2 && !size3)) ------------------ | Branch (189:5): [True: 0, False: 14.0k] | Branch (189:16): [True: 0, False: 14.0k] | Branch (189:26): [True: 0, False: 0] ------------------ 190| 0| return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */ 191| 14.0k| size2 += size3; 192| 14.0k| if(size2 < size3) ------------------ | Branch (192:5): [True: 0, False: 14.0k] ------------------ 193| 0| return 0; 194| 14.0k| if(size1 > SIZE_MAX / size2) ------------------ | Branch (194:5): [True: 0, False: 14.0k] ------------------ 195| 0| return 0; 196| 14.0k| return malloc_(size1*size2); 197| 14.0k|} stream_decoder.c:malloc_: 103| 14.0k|{ 104| | /* Fail if requested */ 105| 14.0k| if(alloc_check()) ------------------ | Branch (105:5): [True: 0, False: 14.0k] ------------------ 106| 0| return NULL; 107| 14.0k| return malloc(size); 108| 14.0k|} LLVMFuzzerTestOneInput: 58| 12.1k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 59| 12.1k| fuzzing::datasource::Datasource ds(data, size); 60| 12.1k| FLAC::Encoder::FuzzerStream encoder(ds); 61| | 62| 12.1k| try { 63| 12.1k| const int channels = ds.Get(); 64| 12.1k| const int bps = ds.Get(); 65| 12.1k| encoder.set_channels(channels); 66| 12.1k| encoder.set_bits_per_sample(bps); 67| | 68| 12.1k| { 69| 12.1k| const bool res = encoder.set_streamable_subset(ds.Get()); 70| 12.1k| fuzzing::memory::memory_test(res); 71| 12.1k| } 72| 12.1k| { 73| 12.1k| const bool res = encoder.set_ogg_serial_number(ds.Get()); 74| 12.1k| fuzzing::memory::memory_test(res); 75| 12.1k| } 76| 12.1k| { 77| 12.1k| const bool res = encoder.set_verify(ds.Get()); 78| 12.1k| fuzzing::memory::memory_test(res); 79| 12.1k| } 80| 12.1k| { 81| 12.1k| const bool res = encoder.set_compression_level(ds.Get()); 82| 12.1k| fuzzing::memory::memory_test(res); 83| 12.1k| } 84| 12.1k| { 85| 12.1k| const bool res = encoder.set_do_exhaustive_model_search(ds.Get()); 86| 12.1k| fuzzing::memory::memory_test(res); 87| 12.1k| } 88| 12.1k| { 89| 12.1k| const bool res = encoder.set_do_mid_side_stereo(ds.Get()); 90| 12.1k| fuzzing::memory::memory_test(res); 91| 12.1k| } 92| 12.1k| { 93| 12.1k| const bool res = encoder.set_loose_mid_side_stereo(ds.Get()); 94| 12.1k| fuzzing::memory::memory_test(res); 95| 12.1k| } 96| 12.1k| { 97| 12.1k| const auto s = ds.Get(); 98| 12.1k| const bool res = encoder.set_apodization(s.data()); 99| 12.1k| fuzzing::memory::memory_test(res); 100| 12.1k| } 101| 12.1k| { 102| 12.1k| const bool res = encoder.set_max_lpc_order(ds.Get()); 103| 12.1k| fuzzing::memory::memory_test(res); 104| 12.1k| } 105| 12.1k| { 106| 12.1k| const bool res = encoder.set_qlp_coeff_precision(ds.Get()); 107| 12.1k| fuzzing::memory::memory_test(res); 108| 12.1k| } 109| 12.1k| { 110| 12.1k| const bool res = encoder.set_do_qlp_coeff_prec_search(ds.Get()); 111| 12.1k| fuzzing::memory::memory_test(res); 112| 12.1k| } 113| 12.1k| { 114| 12.1k| const bool res = encoder.set_do_escape_coding(ds.Get()); 115| 12.1k| fuzzing::memory::memory_test(res); 116| 12.1k| } 117| 12.1k| { 118| 12.1k| const bool res = encoder.set_min_residual_partition_order(ds.Get()); 119| 12.1k| fuzzing::memory::memory_test(res); 120| 12.1k| } 121| 12.1k| { 122| 12.1k| const bool res = encoder.set_max_residual_partition_order(ds.Get()); 123| 12.1k| fuzzing::memory::memory_test(res); 124| 12.1k| } 125| 12.1k| { 126| 12.1k| const bool res = encoder.set_rice_parameter_search_dist(ds.Get()); 127| 12.1k| fuzzing::memory::memory_test(res); 128| 12.1k| } 129| 12.1k| { 130| 12.1k| const bool res = encoder.set_total_samples_estimate(ds.Get()); 131| 12.1k| fuzzing::memory::memory_test(res); 132| 12.1k| } 133| 12.1k| { 134| 12.1k| const bool res = encoder.set_blocksize(ds.Get()); 135| 12.1k| fuzzing::memory::memory_test(res); 136| 12.1k| } 137| 12.1k| { 138| 12.1k| const bool res = encoder.set_limit_min_bitrate(ds.Get()); 139| 12.1k| fuzzing::memory::memory_test(res); 140| 12.1k| } 141| 12.1k| { 142| 12.1k| const bool res = encoder.set_sample_rate(ds.Get()); 143| 12.1k| fuzzing::memory::memory_test(res); 144| 12.1k| } 145| 12.1k| { 146| 12.1k| const bool res = encoder.set_num_threads(ds.Get()); 147| 12.1k| fuzzing::memory::memory_test(res); 148| 12.1k| } 149| | 150| 12.1k| if ( size > 2 * 65535 * 4 ) { ------------------ | Branch (150:14): [True: 209, False: 11.9k] ------------------ 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| 209| encoder.set_do_qlp_coeff_prec_search(false); 158| 209| encoder.set_do_exhaustive_model_search(false); 159| 209| } 160| 12.1k| if ( size > 2 * 4096 * 4 + 250 ) { ------------------ | Branch (160:14): [True: 1.43k, False: 10.6k] ------------------ 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.43k| encoder.set_apodization(""); 165| 1.43k| } 166| | 167| 12.1k| { 168| 12.1k| ::FLAC__StreamEncoderInitStatus ret; 169| 12.1k| if ( ds.Get() ) { ------------------ | Branch (169:18): [True: 6.87k, False: 5.25k] ------------------ 170| 6.87k| ret = encoder.init(); 171| 6.87k| } else { 172| 5.25k| ret = encoder.init_ogg(); 173| 5.25k| } 174| | 175| 12.1k| if ( ret != FLAC__STREAM_ENCODER_INIT_STATUS_OK ) { ------------------ | Branch (175:18): [True: 225, False: 11.9k] ------------------ 176| 225| goto end; 177| 225| } 178| 12.1k| } 179| | 180| | /* These sets must fail, because encoder is already initialized */ 181| 11.9k| { 182| 11.9k| bool res = false; 183| 11.9k| res = res || encoder.set_streamable_subset(true); ------------------ | Branch (183:19): [True: 2.07k, False: 9.82k] | Branch (183:26): [True: 0, False: 9.82k] ------------------ 184| 11.9k| res = res || encoder.set_ogg_serial_number(0); ------------------ | Branch (184:19): [True: 2.07k, False: 9.82k] | Branch (184:26): [True: 0, False: 9.82k] ------------------ 185| 11.9k| res = res || encoder.set_verify(true); ------------------ | Branch (185:19): [True: 2.07k, False: 9.82k] | Branch (185:26): [True: 0, False: 9.82k] ------------------ 186| 11.9k| res = res || encoder.set_compression_level(0); ------------------ | Branch (186:19): [True: 2.07k, False: 9.82k] | Branch (186:26): [True: 0, False: 9.82k] ------------------ 187| 11.9k| res = res || encoder.set_do_exhaustive_model_search(true); ------------------ | Branch (187:19): [True: 2.07k, False: 9.82k] | Branch (187:26): [True: 0, False: 9.82k] ------------------ 188| 11.9k| res = res || encoder.set_do_mid_side_stereo(true); ------------------ | Branch (188:19): [True: 2.07k, False: 9.82k] | Branch (188:26): [True: 0, False: 9.82k] ------------------ 189| 11.9k| res = res || encoder.set_loose_mid_side_stereo(true); ------------------ | Branch (189:19): [True: 2.07k, False: 9.82k] | Branch (189:26): [True: 0, False: 9.82k] ------------------ 190| 11.9k| res = res || encoder.set_apodization("test"); ------------------ | Branch (190:19): [True: 2.07k, False: 9.82k] | Branch (190:26): [True: 0, False: 9.82k] ------------------ 191| 11.9k| res = res || encoder.set_max_lpc_order(0); ------------------ | Branch (191:19): [True: 2.07k, False: 9.82k] | Branch (191:26): [True: 0, False: 9.82k] ------------------ 192| 11.9k| res = res || encoder.set_qlp_coeff_precision(0); ------------------ | Branch (192:19): [True: 2.07k, False: 9.82k] | Branch (192:26): [True: 0, False: 9.82k] ------------------ 193| 11.9k| res = res || encoder.set_do_qlp_coeff_prec_search(true); ------------------ | Branch (193:19): [True: 2.07k, False: 9.82k] | Branch (193:26): [True: 0, False: 9.82k] ------------------ 194| 11.9k| res = res || encoder.set_do_escape_coding(true); ------------------ | Branch (194:19): [True: 2.07k, False: 9.82k] | Branch (194:26): [True: 0, False: 9.82k] ------------------ 195| 11.9k| res = res || encoder.set_min_residual_partition_order(0); ------------------ | Branch (195:19): [True: 2.07k, False: 9.82k] | Branch (195:26): [True: 0, False: 9.82k] ------------------ 196| 11.9k| res = res || encoder.set_max_residual_partition_order(0); ------------------ | Branch (196:19): [True: 2.07k, False: 9.82k] | Branch (196:26): [True: 0, False: 9.82k] ------------------ 197| 11.9k| res = res || encoder.set_rice_parameter_search_dist(0); ------------------ | Branch (197:19): [True: 2.07k, False: 9.82k] | Branch (197:26): [True: 0, False: 9.82k] ------------------ 198| 11.9k| res = res || encoder.set_total_samples_estimate(0); ------------------ | Branch (198:19): [True: 2.07k, False: 9.82k] | Branch (198:26): [True: 0, False: 9.82k] ------------------ 199| 11.9k| res = res || encoder.set_channels(channels); ------------------ | Branch (199:19): [True: 2.07k, False: 9.82k] | Branch (199:26): [True: 0, False: 9.82k] ------------------ 200| 11.9k| res = res || encoder.set_bits_per_sample(16); ------------------ | Branch (200:19): [True: 2.07k, False: 9.82k] | Branch (200:26): [True: 0, False: 9.82k] ------------------ 201| 11.9k| res = res || encoder.set_limit_min_bitrate(true); ------------------ | Branch (201:19): [True: 2.07k, False: 9.82k] | Branch (201:26): [True: 0, False: 9.82k] ------------------ 202| 11.9k| res = res || encoder.set_blocksize(3021); ------------------ | Branch (202:19): [True: 2.07k, False: 9.82k] | Branch (202:26): [True: 0, False: 9.82k] ------------------ 203| 11.9k| res = res || encoder.set_sample_rate(44100); ------------------ | Branch (203:19): [True: 2.07k, False: 9.82k] | Branch (203:26): [True: 0, False: 9.82k] ------------------ 204| 11.9k| res = res || (encoder.set_num_threads(4) == FLAC__STREAM_ENCODER_SET_NUM_THREADS_OK); ------------------ | | 291| 9.82k|#define FLAC__STREAM_ENCODER_SET_NUM_THREADS_OK 0 ------------------ | Branch (204:19): [True: 2.07k, False: 9.82k] | Branch (204:26): [True: 0, False: 9.82k] ------------------ 205| 11.9k| fuzzing::memory::memory_test(res); 206| 11.9k| if(res) ------------------ | Branch (206:16): [True: 0, False: 11.9k] ------------------ 207| 0| abort(); 208| 11.9k| } 209| | 210| | 211| 11.9k| { 212| | /* XORing values as otherwise compiler will optimize, apparently */ 213| 11.9k| bool res = false; 214| 11.9k| res = res != encoder.get_streamable_subset(); 215| 11.9k| res = res != encoder.get_verify(); 216| 11.9k| res = res != encoder.get_do_exhaustive_model_search(); 217| 11.9k| res = res != encoder.get_do_mid_side_stereo(); 218| 11.9k| res = res != encoder.get_loose_mid_side_stereo(); 219| 11.9k| res = res != encoder.get_max_lpc_order(); 220| 11.9k| res = res != encoder.get_qlp_coeff_precision(); 221| 11.9k| res = res != encoder.get_do_qlp_coeff_prec_search(); 222| 11.9k| res = res != encoder.get_do_escape_coding(); 223| 11.9k| res = res != encoder.get_min_residual_partition_order(); 224| 11.9k| res = res != encoder.get_max_residual_partition_order(); 225| 11.9k| res = res != encoder.get_rice_parameter_search_dist(); 226| 11.9k| res = res != encoder.get_total_samples_estimate(); 227| 11.9k| res = res != encoder.get_channels(); 228| 11.9k| res = res != encoder.get_bits_per_sample(); 229| 11.9k| res = res != encoder.get_limit_min_bitrate(); 230| 11.9k| res = res != encoder.get_blocksize(); 231| 11.9k| res = res != encoder.get_sample_rate(); 232| 11.9k| res = res != encoder.get_num_threads(); 233| 11.9k| fuzzing::memory::memory_test(res); 234| 11.9k| } 235| | 236| | 237| 191k| while ( ds.Get() ) { ------------------ | Branch (237:17): [True: 180k, False: 11.9k] ------------------ 238| 180k| { 239| 180k| auto dat = ds.GetVector(); 240| | 241| 180k| if( ds.Get() ) ------------------ | Branch (241:21): [True: 162k, False: 17.2k] ------------------ 242| | /* Mask */ 243| 23.6M| for (size_t i = 0; i < dat.size(); i++) ------------------ | Branch (243:40): [True: 23.4M, False: 162k] ------------------ 244| | /* If we get here, bps is 4 or larger, or init will have failed */ 245| 23.4M| dat[i] = (int32_t)(((uint32_t)(dat[i]) << (32-bps)) >> (32-bps)); 246| | 247| 180k| const uint32_t samples = dat.size() / channels; 248| 180k| if ( samples > 0 ) { ------------------ | Branch (248:22): [True: 152k, False: 27.5k] ------------------ 249| 152k| const int32_t* ptr = dat.data(); 250| 152k| const bool res = encoder.process_interleaved(ptr, samples); 251| 152k| fuzzing::memory::memory_test(res); 252| 152k| } 253| 180k| } 254| 180k| } 255| 11.9k| } catch ( ... ) { } 256| | 257| 12.1k|end: 258| 12.1k| { 259| 12.1k| const bool res = encoder.finish(); 260| 12.1k| fuzzing::memory::memory_test(res); 261| 12.1k| } 262| 12.1k| return 0; 263| 12.1k|} _ZN4FLAC7Encoder12FuzzerStreamC2ERN7fuzzing10datasource10DatasourceE: 41| 12.1k| Stream() { } _ZN4FLAC7Encoder12FuzzerStream14write_callbackEPKhmjj: 43| 148k| ::FLAC__StreamEncoderWriteStatus write_callback(const FLAC__byte buffer[], size_t bytes, uint32_t /* samples */, uint32_t /* current_frame */) override { 44| 148k| 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| 148k| return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; 53| 148k| } _ZN7fuzzing10datasource4Base3GetIbEET_m: 72| 30.9M|{ 73| 30.9M| uint8_t ret; 74| 30.9M| const auto v = get(sizeof(ret), sizeof(ret), id); 75| 30.9M| memcpy(&ret, v.data(), sizeof(ret)); 76| 30.9M| return (ret % 2) ? true : false; ------------------ | Branch (76:12): [True: 30.6M, False: 247k] ------------------ 77| 30.9M|} _ZN7fuzzing10datasource4Base3GetINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_m: 80| 12.0k|{ 81| 12.0k| auto data = GetData(id); 82| 12.0k| return std::string(data.data(), data.data() + data.size()); 83| 12.0k|} _ZN7fuzzing10datasource4Base7GetDataEmmm: 104| 12.0k|{ 105| 12.0k| return get(min, max, id); 106| 12.0k|} _ZN7fuzzing10datasource10DatasourceC2EPKhm: 151| 12.1k| Base(), data(_data), size(_size), idx(0), left(size) 152| 12.1k|{ 153| 12.1k|} _ZN7fuzzing10datasource10Datasource3getEmmm: 155| 61.3M|std::vector Datasource::get(const size_t min, const size_t max, const uint64_t id) { 156| 61.3M| (void)id; 157| | 158| 61.3M| uint32_t getSize; 159| 61.3M| if ( left < sizeof(getSize) ) { ------------------ | Branch (159:10): [True: 10.1k, False: 61.3M] ------------------ 160| 10.1k| throw OutOfData(); 161| 10.1k| } 162| 61.3M| memcpy(&getSize, data + idx, sizeof(getSize)); 163| 61.3M| idx += sizeof(getSize); 164| 61.3M| left -= sizeof(getSize); 165| | 166| 61.3M| if ( getSize < min ) { ------------------ | Branch (166:10): [True: 32.8k, False: 61.3M] ------------------ 167| 32.8k| getSize = min; 168| 32.8k| } 169| 61.3M| if ( max && getSize > max ) { ------------------ | Branch (169:10): [True: 61.3M, False: 12.0k] | Branch (169:17): [True: 61.3M, False: 33.4k] ------------------ 170| 61.3M| getSize = max; 171| 61.3M| } 172| | 173| 61.3M| if ( left < getSize ) { ------------------ | Branch (173:10): [True: 799, False: 61.3M] ------------------ 174| 799| throw OutOfData(); 175| 799| } 176| | 177| 61.3M| std::vector ret(getSize); 178| | 179| 61.3M| if ( getSize > 0 ) { ------------------ | Branch (179:10): [True: 61.3M, False: 8.09k] ------------------ 180| 61.3M| memcpy(ret.data(), data + idx, getSize); 181| 61.3M| } 182| 61.3M| idx += getSize; 183| 61.3M| left -= getSize; 184| | 185| 61.3M| return ret; 186| 61.3M|} _ZN7fuzzing10datasource4BaseC2Ev: 43| 12.1k| Base(void) = default; _ZN7fuzzing10datasource4BaseD2Ev: 44| 12.1k| virtual ~Base(void) = default; _ZN7fuzzing10datasource4Base9OutOfDataC2Ev: 53| 10.9k| OutOfData() = default; _ZN7fuzzing10datasource4Base3GetItEET_m: 64| 10.1k|{ 65| 10.1k| T ret; 66| 10.1k| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 10.1k| memcpy(&ret, v.data(), sizeof(ret)); 68| 10.1k| return ret; 69| 10.1k|} _ZN7fuzzing10datasource4Base3GetIhEET_m: 64| 48.3k|{ 65| 48.3k| T ret; 66| 48.3k| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 48.3k| memcpy(&ret, v.data(), sizeof(ret)); 68| 48.3k| return ret; 69| 48.3k|} _ZN7fuzzing10datasource4Base3GetIlEET_m: 64| 12.0k|{ 65| 12.0k| T ret; 66| 12.0k| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 12.0k| memcpy(&ret, v.data(), sizeof(ret)); 68| 12.0k| return ret; 69| 12.0k|} _ZN7fuzzing10datasource4Base3GetIjEET_m: 64| 61.0k|{ 65| 61.0k| T ret; 66| 61.0k| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 61.0k| memcpy(&ret, v.data(), sizeof(ret)); 68| 61.0k| return ret; 69| 61.0k|} _ZN7fuzzing10datasource4Base3GetImEET_m: 64| 10.2k|{ 65| 10.2k| T ret; 66| 10.2k| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 10.2k| memcpy(&ret, v.data(), sizeof(ret)); 68| 10.2k| return ret; 69| 10.2k|} _ZN7fuzzing10datasource4Base9GetVectorIiEENSt3__16vectorIT_NS3_9allocatorIS5_EEEEm: 122| 180k|std::vector Base::GetVector(const uint64_t id) { 123| 180k| std::vector ret; 124| | 125| 30.4M| while ( Get(id) == true ) { ------------------ | Branch (125:13): [True: 30.2M, False: 180k] ------------------ 126| 30.2M| ret.push_back( Get(id) ); 127| 30.2M| } 128| | 129| 180k| return ret; 130| 180k|} _ZN7fuzzing10datasource4Base3GetIiEET_m: 64| 30.2M|{ 65| 30.2M| T ret; 66| 30.2M| const auto v = get(sizeof(ret), sizeof(ret), id); 67| 30.2M| memcpy(&ret, v.data(), sizeof(ret)); 68| 30.2M| return ret; 69| 30.2M|} _ZN7fuzzing9exception13FlowExceptionC2Ev: 41| 10.9k| FlowException(void) : ExceptionBase() { } _ZN7fuzzing9exception13ExceptionBaseC2Ev: 34| 10.9k| ExceptionBase(void) = default; _ZN7fuzzing6memory16memory_test_asanEPKvm: 50| 148k|{ 51| 148k| (void)data; 52| 148k| (void)size; 53| | 54| |#if ASAN == 1 55| | if ( __asan_region_is_poisoned(data, size) != NULL ) { 56| | abort(); 57| | } 58| |#endif 59| 148k|} _ZN7fuzzing6memory16memory_test_msanEPKvm: 62| 148k|{ 63| 148k| (void)data; 64| 148k| (void)size; 65| | 66| |#if MSAN == 1 67| | __msan_check_mem_is_initialized(data, size); 68| |#endif 69| 148k|} _ZN7fuzzing6memory11memory_testEPKvm: 72| 148k|{ 73| 148k| memory_test_asan(data, size); 74| 148k| memory_test_msan(data, size); 75| 148k|} _ZN7fuzzing6memory11memory_testIbEEvRKT_: 79| 402k|{ 80| 402k| (void)t; 81| 402k|} _ZN4FLAC7Encoder6StreamC2Ev: 56| 12.1k| encoder_(::FLAC__stream_encoder_new()) 57| 12.1k| { } _ZN4FLAC7Encoder6StreamD2Ev: 60| 12.1k| { 61| 12.1k| if(0 != encoder_) { ------------------ | Branch (61:7): [True: 12.1k, False: 0] ------------------ 62| 12.1k| (void)::FLAC__stream_encoder_finish(encoder_); 63| 12.1k| ::FLAC__stream_encoder_delete(encoder_); 64| 12.1k| } 65| 12.1k| } _ZNK4FLAC7Encoder6Stream8is_validEv: 68| 822k| { 69| 822k| return 0 != encoder_; 70| 822k| } _ZN4FLAC7Encoder6Stream21set_ogg_serial_numberEl: 73| 21.9k| { 74| 21.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 75| 21.9k| return static_cast(::FLAC__stream_encoder_set_ogg_serial_number(encoder_, value)); 76| 21.9k| } _ZN4FLAC7Encoder6Stream10set_verifyEb: 79| 21.9k| { 80| 21.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 81| 21.9k| return static_cast(::FLAC__stream_encoder_set_verify(encoder_, value)); 82| 21.9k| } _ZN4FLAC7Encoder6Stream21set_streamable_subsetEb: 85| 21.9k| { 86| 21.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 87| 21.9k| return static_cast(::FLAC__stream_encoder_set_streamable_subset(encoder_, value)); 88| 21.9k| } _ZN4FLAC7Encoder6Stream12set_channelsEj: 91| 21.9k| { 92| 21.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 93| 21.9k| return static_cast(::FLAC__stream_encoder_set_channels(encoder_, value)); 94| 21.9k| } _ZN4FLAC7Encoder6Stream19set_bits_per_sampleEj: 97| 21.9k| { 98| 21.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 99| 21.9k| return static_cast(::FLAC__stream_encoder_set_bits_per_sample(encoder_, value)); 100| 21.9k| } _ZN4FLAC7Encoder6Stream15set_sample_rateEj: 103| 19.9k| { 104| 19.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 105| 19.9k| return static_cast(::FLAC__stream_encoder_set_sample_rate(encoder_, value)); 106| 19.9k| } _ZN4FLAC7Encoder6Stream21set_compression_levelEj: 109| 21.8k| { 110| 21.8k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 21.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.8k] | | ------------------ ------------------ 111| 21.8k| return static_cast(::FLAC__stream_encoder_set_compression_level(encoder_, value)); 112| 21.8k| } _ZN4FLAC7Encoder6Stream13set_blocksizeEj: 115| 19.9k| { 116| 19.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 117| 19.9k| return static_cast(::FLAC__stream_encoder_set_blocksize(encoder_, value)); 118| 19.9k| } _ZN4FLAC7Encoder6Stream22set_do_mid_side_stereoEb: 121| 21.8k| { 122| 21.8k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 21.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.8k] | | ------------------ ------------------ 123| 21.8k| return static_cast(::FLAC__stream_encoder_set_do_mid_side_stereo(encoder_, value)); 124| 21.8k| } _ZN4FLAC7Encoder6Stream25set_loose_mid_side_stereoEb: 127| 21.8k| { 128| 21.8k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 21.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.8k] | | ------------------ ------------------ 129| 21.8k| return static_cast(::FLAC__stream_encoder_set_loose_mid_side_stereo(encoder_, value)); 130| 21.8k| } _ZN4FLAC7Encoder6Stream15set_apodizationEPKc: 133| 23.2k| { 134| 23.2k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 23.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.2k] | | ------------------ ------------------ 135| 23.2k| return static_cast(::FLAC__stream_encoder_set_apodization(encoder_, specification)); 136| 23.2k| } _ZN4FLAC7Encoder6Stream17set_max_lpc_orderEj: 139| 20.0k| { 140| 20.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.0k] | | ------------------ ------------------ 141| 20.0k| return static_cast(::FLAC__stream_encoder_set_max_lpc_order(encoder_, value)); 142| 20.0k| } _ZN4FLAC7Encoder6Stream23set_qlp_coeff_precisionEj: 145| 20.0k| { 146| 20.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.0k] | | ------------------ ------------------ 147| 20.0k| return static_cast(::FLAC__stream_encoder_set_qlp_coeff_precision(encoder_, value)); 148| 20.0k| } _ZN4FLAC7Encoder6Stream28set_do_qlp_coeff_prec_searchEb: 151| 20.2k| { 152| 20.2k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.2k] | | ------------------ ------------------ 153| 20.2k| return static_cast(::FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder_, value)); 154| 20.2k| } _ZN4FLAC7Encoder6Stream20set_do_escape_codingEb: 157| 20.0k| { 158| 20.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.0k] | | ------------------ ------------------ 159| 20.0k| return static_cast(::FLAC__stream_encoder_set_do_escape_coding(encoder_, value)); 160| 20.0k| } _ZN4FLAC7Encoder6Stream30set_do_exhaustive_model_searchEb: 163| 22.0k| { 164| 22.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 22.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 22.0k] | | ------------------ ------------------ 165| 22.0k| return static_cast(::FLAC__stream_encoder_set_do_exhaustive_model_search(encoder_, value)); 166| 22.0k| } _ZN4FLAC7Encoder6Stream32set_min_residual_partition_orderEj: 169| 20.0k| { 170| 20.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.0k] | | ------------------ ------------------ 171| 20.0k| return static_cast(::FLAC__stream_encoder_set_min_residual_partition_order(encoder_, value)); 172| 20.0k| } _ZN4FLAC7Encoder6Stream32set_max_residual_partition_orderEj: 175| 20.0k| { 176| 20.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.0k] | | ------------------ ------------------ 177| 20.0k| return static_cast(::FLAC__stream_encoder_set_max_residual_partition_order(encoder_, value)); 178| 20.0k| } _ZN4FLAC7Encoder6Stream30set_rice_parameter_search_distEj: 181| 20.0k| { 182| 20.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.0k] | | ------------------ ------------------ 183| 20.0k| return static_cast(::FLAC__stream_encoder_set_rice_parameter_search_dist(encoder_, value)); 184| 20.0k| } _ZN4FLAC7Encoder6Stream26set_total_samples_estimateEm: 187| 20.0k| { 188| 20.0k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 20.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.0k] | | ------------------ ------------------ 189| 20.0k| return static_cast(::FLAC__stream_encoder_set_total_samples_estimate(encoder_, value)); 190| 20.0k| } _ZN4FLAC7Encoder6Stream21set_limit_min_bitrateEb: 215| 19.9k| { 216| 19.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 217| 19.9k| return static_cast(::FLAC__stream_encoder_set_limit_min_bitrate(encoder_, value)); 218| 19.9k| } _ZN4FLAC7Encoder6Stream15set_num_threadsEj: 221| 19.9k| { 222| 19.9k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 223| 19.9k| return ::FLAC__stream_encoder_set_num_threads(encoder_, value); 224| 19.9k| } _ZNK4FLAC7Encoder6Stream10get_verifyEv: 245| 9.82k| { 246| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 247| 9.82k| return static_cast(::FLAC__stream_encoder_get_verify(encoder_)); 248| 9.82k| } _ZNK4FLAC7Encoder6Stream21get_streamable_subsetEv: 251| 9.82k| { 252| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 253| 9.82k| return static_cast(::FLAC__stream_encoder_get_streamable_subset(encoder_)); 254| 9.82k| } _ZNK4FLAC7Encoder6Stream22get_do_mid_side_stereoEv: 257| 9.82k| { 258| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 259| 9.82k| return static_cast(::FLAC__stream_encoder_get_do_mid_side_stereo(encoder_)); 260| 9.82k| } _ZNK4FLAC7Encoder6Stream25get_loose_mid_side_stereoEv: 263| 9.82k| { 264| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 265| 9.82k| return static_cast(::FLAC__stream_encoder_get_loose_mid_side_stereo(encoder_)); 266| 9.82k| } _ZNK4FLAC7Encoder6Stream12get_channelsEv: 269| 9.82k| { 270| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 271| 9.82k| return ::FLAC__stream_encoder_get_channels(encoder_); 272| 9.82k| } _ZNK4FLAC7Encoder6Stream19get_bits_per_sampleEv: 275| 9.82k| { 276| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 277| 9.82k| return ::FLAC__stream_encoder_get_bits_per_sample(encoder_); 278| 9.82k| } _ZNK4FLAC7Encoder6Stream15get_sample_rateEv: 281| 9.82k| { 282| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 283| 9.82k| return ::FLAC__stream_encoder_get_sample_rate(encoder_); 284| 9.82k| } _ZNK4FLAC7Encoder6Stream13get_blocksizeEv: 287| 9.82k| { 288| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 289| 9.82k| return ::FLAC__stream_encoder_get_blocksize(encoder_); 290| 9.82k| } _ZNK4FLAC7Encoder6Stream17get_max_lpc_orderEv: 293| 9.82k| { 294| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 295| 9.82k| return ::FLAC__stream_encoder_get_max_lpc_order(encoder_); 296| 9.82k| } _ZNK4FLAC7Encoder6Stream23get_qlp_coeff_precisionEv: 299| 9.82k| { 300| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 301| 9.82k| return ::FLAC__stream_encoder_get_qlp_coeff_precision(encoder_); 302| 9.82k| } _ZNK4FLAC7Encoder6Stream28get_do_qlp_coeff_prec_searchEv: 305| 9.82k| { 306| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 307| 9.82k| return static_cast(::FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder_)); 308| 9.82k| } _ZNK4FLAC7Encoder6Stream20get_do_escape_codingEv: 311| 9.82k| { 312| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 313| 9.82k| return static_cast(::FLAC__stream_encoder_get_do_escape_coding(encoder_)); 314| 9.82k| } _ZNK4FLAC7Encoder6Stream30get_do_exhaustive_model_searchEv: 317| 9.82k| { 318| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 319| 9.82k| return static_cast(::FLAC__stream_encoder_get_do_exhaustive_model_search(encoder_)); 320| 9.82k| } _ZNK4FLAC7Encoder6Stream32get_min_residual_partition_orderEv: 323| 9.82k| { 324| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 325| 9.82k| return ::FLAC__stream_encoder_get_min_residual_partition_order(encoder_); 326| 9.82k| } _ZNK4FLAC7Encoder6Stream32get_max_residual_partition_orderEv: 329| 9.82k| { 330| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 331| 9.82k| return ::FLAC__stream_encoder_get_max_residual_partition_order(encoder_); 332| 9.82k| } _ZNK4FLAC7Encoder6Stream30get_rice_parameter_search_distEv: 335| 9.82k| { 336| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 337| 9.82k| return ::FLAC__stream_encoder_get_rice_parameter_search_dist(encoder_); 338| 9.82k| } _ZNK4FLAC7Encoder6Stream26get_total_samples_estimateEv: 341| 9.82k| { 342| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 343| 9.82k| return ::FLAC__stream_encoder_get_total_samples_estimate(encoder_); 344| 9.82k| } _ZNK4FLAC7Encoder6Stream21get_limit_min_bitrateEv: 347| 9.82k| { 348| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 349| 9.82k| return static_cast(::FLAC__stream_encoder_get_limit_min_bitrate(encoder_)); 350| 9.82k| } _ZNK4FLAC7Encoder6Stream15get_num_threadsEv: 353| 9.82k| { 354| 9.82k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 355| 9.82k| return ::FLAC__stream_encoder_get_num_threads(encoder_); 356| 9.82k| } _ZN4FLAC7Encoder6Stream4initEv: 359| 6.87k| { 360| 6.87k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 6.87k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.87k] | | ------------------ ------------------ 361| 6.87k| return ::FLAC__stream_encoder_init_stream(encoder_, write_callback_, seek_callback_, tell_callback_, metadata_callback_, /*client_data=*/(void*)this); 362| 6.87k| } _ZN4FLAC7Encoder6Stream8init_oggEv: 365| 3.17k| { 366| 3.17k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 3.17k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.17k] | | ------------------ ------------------ 367| 3.17k| return ::FLAC__stream_encoder_init_ogg_stream(encoder_, read_callback_, write_callback_, seek_callback_, tell_callback_, metadata_callback_, /*client_data=*/(void*)this); 368| 3.17k| } _ZN4FLAC7Encoder6Stream6finishEv: 371| 12.1k| { 372| 12.1k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 12.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.1k] | | ------------------ ------------------ 373| 12.1k| return static_cast(::FLAC__stream_encoder_finish(encoder_)); 374| 12.1k| } _ZN4FLAC7Encoder6Stream19process_interleavedEPKij: 383| 152k| { 384| 152k| FLAC__ASSERT(is_valid()); ------------------ | | 38| 152k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 152k] | | ------------------ ------------------ 385| 152k| return static_cast(::FLAC__stream_encoder_process_interleaved(encoder_, buffer, samples)); 386| 152k| } _ZN4FLAC7Encoder6Stream13seek_callbackEm: 395| 9.76k| { 396| 9.76k| (void)absolute_byte_offset; 397| 9.76k| return ::FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED; 398| 9.76k| } _ZN4FLAC7Encoder6Stream13tell_callbackEPm: 401| 39.3k| { 402| 39.3k| (void)absolute_byte_offset; 403| 39.3k| return ::FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED; 404| 39.3k| } _ZN4FLAC7Encoder6Stream17metadata_callbackEPK20FLAC__StreamMetadata: 407| 9.76k| { 408| 9.76k| (void)metadata; 409| 9.76k| } _ZN4FLAC7Encoder6Stream15write_callback_EPK19FLAC__StreamEncoderPKhmjjPv: 421| 148k| { 422| 148k| (void)encoder; 423| 148k| FLAC__ASSERT(0 != client_data); ------------------ | | 38| 148k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 148k] | | ------------------ ------------------ 424| 148k| Stream *instance = reinterpret_cast(client_data); 425| 148k| FLAC__ASSERT(0 != instance); ------------------ | | 38| 148k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 148k] | | ------------------ ------------------ 426| 148k| return instance->write_callback(buffer, bytes, samples, current_frame); 427| 148k| } _ZN4FLAC7Encoder6Stream14seek_callback_EPK19FLAC__StreamEncodermPv: 430| 9.76k| { 431| 9.76k| (void)encoder; 432| 9.76k| FLAC__ASSERT(0 != client_data); ------------------ | | 38| 9.76k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.76k] | | ------------------ ------------------ 433| 9.76k| Stream *instance = reinterpret_cast(client_data); 434| 9.76k| FLAC__ASSERT(0 != instance); ------------------ | | 38| 9.76k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.76k] | | ------------------ ------------------ 435| 9.76k| return instance->seek_callback(absolute_byte_offset); 436| 9.76k| } _ZN4FLAC7Encoder6Stream14tell_callback_EPK19FLAC__StreamEncoderPmPv: 439| 39.3k| { 440| 39.3k| (void)encoder; 441| 39.3k| FLAC__ASSERT(0 != client_data); ------------------ | | 38| 39.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 39.3k] | | ------------------ ------------------ 442| 39.3k| Stream *instance = reinterpret_cast(client_data); 443| 39.3k| FLAC__ASSERT(0 != instance); ------------------ | | 38| 39.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 39.3k] | | ------------------ ------------------ 444| 39.3k| return instance->tell_callback(absolute_byte_offset); 445| 39.3k| } _ZN4FLAC7Encoder6Stream18metadata_callback_EPK19FLAC__StreamEncoderPK20FLAC__StreamMetadataPv: 448| 9.76k| { 449| 9.76k| (void)encoder; 450| 9.76k| FLAC__ASSERT(0 != client_data); ------------------ | | 38| 9.76k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.76k] | | ------------------ ------------------ 451| 9.76k| Stream *instance = reinterpret_cast(client_data); 452| 9.76k| FLAC__ASSERT(0 != instance); ------------------ | | 38| 9.76k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.76k] | | ------------------ ------------------ 453| 9.76k| instance->metadata_callback(metadata); 454| 9.76k| } FLAC__bitmath_silog2: 64| 23.3M|{ 65| 23.3M| if(v == 0) ------------------ | Branch (65:5): [True: 183k, False: 23.1M] ------------------ 66| 183k| return 0; 67| | 68| 23.1M| if(v == -1) ------------------ | Branch (68:5): [True: 0, False: 23.1M] ------------------ 69| 0| return 2; 70| | 71| 23.1M| v = (v < 0) ? (-(v+1)) : v; ------------------ | Branch (71:6): [True: 0, False: 23.1M] ------------------ 72| 23.1M| return FLAC__bitmath_ilog2_wide(v)+2; 73| 23.1M|} FLAC__bitreader_new: 257| 8.73k|{ 258| 8.73k| 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.73k| return br; 270| 8.73k|} FLAC__bitreader_delete: 273| 8.73k|{ 274| 8.73k| FLAC__ASSERT(0 != br); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 275| | 276| 8.73k| FLAC__bitreader_free(br); 277| 8.73k| free(br); 278| 8.73k|} FLAC__bitreader_init: 287| 8.73k|{ 288| 8.73k| FLAC__ASSERT(0 != br); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 289| | 290| 8.73k| br->words = br->bytes = 0; 291| 8.73k| br->consumed_words = br->consumed_bits = 0; 292| 8.73k| br->capacity = FLAC__BITREADER_DEFAULT_CAPACITY; 293| 8.73k| br->buffer = malloc(sizeof(brword) * br->capacity); 294| 8.73k| if(br->buffer == 0) ------------------ | Branch (294:5): [True: 0, False: 8.73k] ------------------ 295| 0| return false; 296| 8.73k| br->read_callback = rcb; 297| 8.73k| br->client_data = cd; 298| 8.73k| br->read_limit_set = false; 299| 8.73k| br->read_limit = -1; 300| 8.73k| br->last_seen_framesync = -1; 301| | 302| | return true; 303| 8.73k|} FLAC__bitreader_free: 306| 17.4k|{ 307| 17.4k| FLAC__ASSERT(0 != br); ------------------ | | 38| 17.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.4k] | | ------------------ ------------------ 308| | 309| 17.4k| if(0 != br->buffer) ------------------ | Branch (309:5): [True: 8.73k, False: 8.73k] ------------------ 310| 8.73k| free(br->buffer); 311| 17.4k| br->buffer = 0; 312| 17.4k| br->capacity = 0; 313| 17.4k| br->words = br->bytes = 0; 314| 17.4k| br->consumed_words = br->consumed_bits = 0; 315| 17.4k| br->read_callback = 0; 316| 17.4k| br->client_data = 0; 317| | br->read_limit_set = false; 318| 17.4k| br->read_limit = -1; 319| 17.4k| br->last_seen_framesync = -1; 320| 17.4k|} FLAC__bitreader_clear: 323| 8.73k|{ 324| 8.73k| br->words = br->bytes = 0; 325| 8.73k| br->consumed_words = br->consumed_bits = 0; 326| 8.73k| br->read_limit_set = false; 327| 8.73k| br->read_limit = -1; 328| 8.73k| br->last_seen_framesync = -1; 329| | return true; 330| 8.73k|} FLAC__bitreader_set_framesync_location: 333| 216k|{ 334| 216k| br->last_seen_framesync = br->consumed_words * FLAC__BYTES_PER_WORD + br->consumed_bits / 8; ------------------ | | 72| 216k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 335| 216k|} FLAC__bitreader_reset_read_crc16: 351| 216k|{ 352| 216k| FLAC__ASSERT(0 != br); ------------------ | | 38| 216k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 216k] | | ------------------ ------------------ 353| 216k| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 216k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 216k] | | ------------------ ------------------ 354| 216k| FLAC__ASSERT((br->consumed_bits & 7) == 0); ------------------ | | 38| 216k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 216k] | | ------------------ ------------------ 355| | 356| 216k| br->read_crc16 = (uint32_t)seed; 357| 216k| br->crc16_offset = br->consumed_words; 358| 216k| br->crc16_align = br->consumed_bits; 359| 216k|} FLAC__bitreader_get_read_crc16: 362| 216k|{ 363| 216k| FLAC__ASSERT(0 != br); ------------------ | | 38| 216k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 216k] | | ------------------ ------------------ 364| 216k| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 216k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 216k] | | ------------------ ------------------ 365| | 366| | /* CRC consumed words up to here */ 367| 216k| crc16_update_block_(br); 368| | 369| 216k| FLAC__ASSERT((br->consumed_bits & 7) == 0); ------------------ | | 38| 216k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 216k] | | ------------------ ------------------ 370| 216k| FLAC__ASSERT(br->crc16_align <= br->consumed_bits); ------------------ | | 38| 216k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 216k] | | ------------------ ------------------ 371| | 372| | /* CRC any tail bytes in a partially-consumed word */ 373| 216k| if(br->consumed_bits) { ------------------ | Branch (373:5): [True: 188k, False: 27.5k] ------------------ 374| 188k| const brword tail = br->buffer[br->consumed_words]; 375| 941k| for( ; br->crc16_align < br->consumed_bits; br->crc16_align += 8) ------------------ | Branch (375:10): [True: 752k, False: 188k] ------------------ 376| 752k| br->read_crc16 = FLAC__CRC16_UPDATE((uint32_t)((tail >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), br->read_crc16); ------------------ | | 50| 752k|#define FLAC__CRC16_UPDATE(data, crc) ((((crc)<<8) & 0xffff) ^ FLAC__crc16_table[0][((crc)>>8) ^ (data)]) ------------------ 377| 188k| } 378| 216k| return br->read_crc16; 379| 216k|} FLAC__bitreader_is_consumed_byte_aligned: 382| 709k|{ 383| 709k| return ((br->consumed_bits & 7) == 0); 384| 709k|} FLAC__bitreader_bits_left_for_byte_alignment: 387| 111k|{ 388| 111k| return 8 - (br->consumed_bits & 7); 389| 111k|} FLAC__bitreader_read_raw_uint32: 419| 12.8M|{ 420| 12.8M| FLAC__ASSERT(0 != br); ------------------ | | 38| 12.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.8M] | | ------------------ ------------------ 421| 12.8M| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 12.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.8M] | | ------------------ ------------------ 422| | 423| 12.8M| FLAC__ASSERT(bits <= 32); ------------------ | | 38| 12.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.8M] | | ------------------ ------------------ 424| 12.8M| FLAC__ASSERT((br->capacity*FLAC__BITS_PER_WORD) * 2 >= bits); ------------------ | | 38| 12.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.8M] | | ------------------ ------------------ 425| 12.8M| FLAC__ASSERT(br->consumed_words <= br->words); ------------------ | | 38| 12.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.8M] | | ------------------ ------------------ 426| | 427| | /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */ 428| 12.8M| FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32); ------------------ | | 38| 12.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 12.8M] | | ------------------ ------------------ 429| | 430| 12.8M| if(bits == 0) { /* OPT: investigate if this can ever happen, maybe change to assertion */ ------------------ | Branch (430:5): [True: 0, False: 12.8M] ------------------ 431| 0| *val = 0; 432| 0| return true; 433| 0| } 434| | 435| 12.8M| if(br->read_limit_set && br->read_limit < (uint32_t)-1){ ------------------ | Branch (435:5): [True: 0, False: 12.8M] | 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| 13.0M| while((br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits < bits) { ------------------ | | 73| 13.0M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (444:8): [True: 249k, False: 12.8M] ------------------ 445| 249k| if(!bitreader_read_from_client_(br)) ------------------ | Branch (445:6): [True: 0, False: 249k] ------------------ 446| 0| return false; 447| 249k| } 448| 12.8M| if(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */ ------------------ | Branch (448:5): [True: 12.2M, False: 530k] ------------------ 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| 12.2M| if(br->consumed_bits) { ------------------ | Branch (450:6): [True: 11.4M, False: 796k] ------------------ 451| | /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */ 452| 11.4M| const uint32_t n = FLAC__BITS_PER_WORD - br->consumed_bits; ------------------ | | 73| 11.4M|#define FLAC__BITS_PER_WORD 64 ------------------ 453| 11.4M| const brword word = br->buffer[br->consumed_words]; 454| 11.4M| const brword mask = br->consumed_bits < FLAC__BITS_PER_WORD ? FLAC__WORD_ALL_ONES >> br->consumed_bits : 0; ------------------ | | 73| 11.4M|#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| 11.4M|#define FLAC__WORD_ALL_ONES ((FLAC__uint64)FLAC__U64L(0xffffffffffffffff)) | | ------------------ | | | | 102| 11.4M|#define FLAC__U64L(x) x##ULL | | ------------------ ------------------ | Branch (454:24): [True: 11.4M, False: 0] ------------------ 455| 11.4M| if(bits < n) { ------------------ | Branch (455:7): [True: 8.17M, False: 3.32M] ------------------ 456| 8.17M| uint32_t shift = n - bits; 457| 8.17M| *val = shift < FLAC__BITS_PER_WORD ? (FLAC__uint32)((word & mask) >> shift) : 0; /* The result has <= 32 non-zero bits */ ------------------ | | 73| 8.17M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (457:12): [True: 8.17M, False: 0] ------------------ 458| 8.17M| br->consumed_bits += bits; 459| 8.17M| return true; 460| 8.17M| } 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| 3.32M| *val = (FLAC__uint32)(word & mask); 463| 3.32M| bits -= n; 464| 3.32M| br->consumed_words++; 465| 3.32M| br->consumed_bits = 0; 466| 3.32M| 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.46M, False: 862k] ------------------ 467| 2.46M| uint32_t shift = FLAC__BITS_PER_WORD - bits; ------------------ | | 73| 2.46M|#define FLAC__BITS_PER_WORD 64 ------------------ 468| 2.46M| *val = bits < 32 ? *val << bits : 0; ------------------ | Branch (468:12): [True: 2.46M, False: 0] ------------------ 469| 2.46M| *val |= shift < FLAC__BITS_PER_WORD ? (FLAC__uint32)(br->buffer[br->consumed_words] >> shift) : 0; ------------------ | | 73| 2.46M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (469:13): [True: 2.46M, False: 0] ------------------ 470| 2.46M| br->consumed_bits = bits; 471| 2.46M| } 472| 3.32M| return true; 473| 11.4M| } 474| 796k| else { /* br->consumed_bits == 0 */ 475| 796k| const brword word = br->buffer[br->consumed_words]; 476| 796k| if(bits < FLAC__BITS_PER_WORD) { ------------------ | | 73| 796k|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (476:7): [True: 796k, False: 0] ------------------ 477| 796k| *val = (FLAC__uint32)(word >> (FLAC__BITS_PER_WORD-bits)); ------------------ | | 73| 796k|#define FLAC__BITS_PER_WORD 64 ------------------ 478| 796k| br->consumed_bits = bits; 479| 796k| return true; 480| 796k| } 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| 796k| } 486| 12.2M| } 487| 530k| 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| 530k| if(br->consumed_bits) { ------------------ | Branch (493:6): [True: 421k, False: 109k] ------------------ 494| | /* this also works when consumed_bits==0, it's just a little slower than necessary for that case */ 495| 421k| FLAC__ASSERT(br->consumed_bits + bits <= br->bytes*8); ------------------ | | 38| 421k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 421k] | | ------------------ ------------------ 496| 421k| *val = (FLAC__uint32)((br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (FLAC__BITS_PER_WORD-br->consumed_bits-bits)); ------------------ | | 74| 421k|#define FLAC__WORD_ALL_ONES ((FLAC__uint64)FLAC__U64L(0xffffffffffffffff)) | | ------------------ | | | | 102| 421k|#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| 421k|#define FLAC__BITS_PER_WORD 64 ------------------ 497| 421k| br->consumed_bits += bits; 498| 421k| return true; 499| 421k| } 500| 109k| else { 501| 109k| *val = (FLAC__uint32)(br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits)); ------------------ | | 73| 109k|#define FLAC__BITS_PER_WORD 64 ------------------ 502| 109k| br->consumed_bits += bits; 503| | return true; 504| 109k| } 505| 530k| } 506| 12.8M|} FLAC__bitreader_read_raw_int32: 509| 3.94M|{ 510| 3.94M| FLAC__uint32 uval, mask; 511| | /* OPT: inline raw uint32 code here, or make into a macro if possible in the .h file */ 512| 3.94M| if (bits < 1 || ! FLAC__bitreader_read_raw_uint32(br, &uval, bits)) ------------------ | Branch (512:6): [True: 0, False: 3.94M] | Branch (512:18): [True: 0, False: 3.94M] ------------------ 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.94M| mask = bits >= 33 ? 0 : 1lu << (bits - 1); ------------------ | Branch (516:9): [True: 0, False: 3.94M] ------------------ 517| 3.94M| *val = (uval ^ mask) - mask; 518| | return true; 519| 3.94M|} FLAC__bitreader_read_raw_uint64: 522| 2.09M|{ 523| 2.09M| FLAC__uint32 hi, lo; 524| | 525| 2.09M| if(bits > 32) { ------------------ | Branch (525:5): [True: 1.82M, False: 275k] ------------------ 526| 1.82M| if(!FLAC__bitreader_read_raw_uint32(br, &hi, bits-32)) ------------------ | Branch (526:6): [True: 0, False: 1.82M] ------------------ 527| 0| return false; 528| 1.82M| if(!FLAC__bitreader_read_raw_uint32(br, &lo, 32)) ------------------ | Branch (528:6): [True: 0, False: 1.82M] ------------------ 529| 0| return false; 530| 1.82M| *val = hi; 531| 1.82M| *val <<= 32; 532| 1.82M| *val |= lo; 533| 1.82M| } 534| 275k| else { 535| 275k| if(!FLAC__bitreader_read_raw_uint32(br, &lo, bits)) ------------------ | Branch (535:6): [True: 0, False: 275k] ------------------ 536| 0| return false; 537| 275k| *val = lo; 538| 275k| } 539| 2.09M| return true; 540| 2.09M|} FLAC__bitreader_read_raw_int64: 543| 2.08M|{ 544| 2.08M| FLAC__uint64 uval, mask; 545| | /* OPT: inline raw uint64 code here, or make into a macro if possible in the .h file */ 546| 2.08M| if (bits < 1 || ! FLAC__bitreader_read_raw_uint64(br, &uval, bits)) ------------------ | Branch (546:6): [True: 0, False: 2.08M] | Branch (546:18): [True: 0, False: 2.08M] ------------------ 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| 2.08M| mask = bits >= 65 ? 0 : 1llu << (bits - 1); ------------------ | Branch (550:9): [True: 0, False: 2.08M] ------------------ 551| 2.08M| *val = (uval ^ mask) - mask; 552| | return true; 553| 2.08M|} FLAC__bitreader_skip_byte_block_aligned_no_crc: 616| 17.4k|{ 617| 17.4k| FLAC__uint32 x; 618| | 619| 17.4k| FLAC__ASSERT(0 != br); ------------------ | | 38| 17.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.4k] | | ------------------ ------------------ 620| 17.4k| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 17.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.4k] | | ------------------ ------------------ 621| 17.4k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br)); ------------------ | | 38| 17.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.4k] | | ------------------ ------------------ 622| | 623| 17.4k| if(br->read_limit_set && br->read_limit < (uint32_t)-1){ ------------------ | Branch (623:5): [True: 0, False: 17.4k] | 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| 34.9k| 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: 26.2k, False: 8.73k] | Branch (631:17): [True: 17.4k, False: 8.73k] ------------------ 632| 17.4k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (632:6): [True: 0, False: 17.4k] ------------------ 633| 0| return false; 634| 17.4k| nvals--; 635| 17.4k| } 636| 17.4k| if(0 == nvals) ------------------ | Branch (636:5): [True: 8.73k, False: 8.73k] ------------------ 637| 8.73k| return true; 638| | 639| | /* step 2: skip whole words in chunks */ 640| 52.4k| while(nvals >= FLAC__BYTES_PER_WORD) { ------------------ | | 72| 52.4k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ | Branch (640:8): [True: 43.6k, False: 8.73k] ------------------ 641| 43.6k| if(br->consumed_words < br->words) { ------------------ | Branch (641:6): [True: 43.6k, False: 0] ------------------ 642| 43.6k| br->consumed_words++; 643| 43.6k| nvals -= FLAC__BYTES_PER_WORD; ------------------ | | 72| 43.6k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 644| 43.6k| if(br->read_limit_set) ------------------ | Branch (644:7): [True: 0, False: 43.6k] ------------------ 645| 0| br->read_limit -= FLAC__BITS_PER_WORD; ------------------ | | 73| 0|#define FLAC__BITS_PER_WORD 64 ------------------ 646| 43.6k| } 647| 0| else if(!bitreader_read_from_client_(br)) ------------------ | Branch (647:11): [True: 0, False: 0] ------------------ 648| 0| return false; 649| 43.6k| } 650| | /* step 3: skip any remainder from partial tail bytes */ 651| 52.4k| while(nvals) { ------------------ | Branch (651:8): [True: 43.6k, False: 8.73k] ------------------ 652| 43.6k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (652:6): [True: 0, False: 43.6k] ------------------ 653| 0| return false; 654| 43.6k| nvals--; 655| 43.6k| } 656| | 657| 8.73k| return true; 658| 8.73k|} FLAC__bitreader_read_byte_block_aligned_no_crc: 661| 8.73k|{ 662| 8.73k| FLAC__uint32 x; 663| | 664| 8.73k| FLAC__ASSERT(0 != br); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 665| 8.73k| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 666| 8.73k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br)); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 667| | 668| 8.73k| if(br->read_limit_set && br->read_limit < (uint32_t)-1){ ------------------ | Branch (668:5): [True: 0, False: 8.73k] | 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| 61.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: 61.1k, False: 0] | Branch (676:17): [True: 52.4k, False: 8.73k] ------------------ 677| 52.4k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (677:6): [True: 0, False: 52.4k] ------------------ 678| 0| return false; 679| 52.4k| *val++ = (FLAC__byte)x; 680| 52.4k| nvals--; 681| 52.4k| } 682| 8.73k| if(0 == nvals) ------------------ | Branch (682:5): [True: 0, False: 8.73k] ------------------ 683| 0| return true; 684| | /* step 2: read whole words in chunks */ 685| 17.4k| while(nvals >= FLAC__BYTES_PER_WORD) { ------------------ | | 72| 17.4k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ | Branch (685:8): [True: 8.73k, False: 8.73k] ------------------ 686| 8.73k| if(br->consumed_words < br->words) { ------------------ | Branch (686:6): [True: 8.73k, False: 0] ------------------ 687| 8.73k| 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.73k| val[1] = (FLAC__byte)(word >> 48); 696| 8.73k| val[2] = (FLAC__byte)(word >> 40); 697| 8.73k| val[3] = (FLAC__byte)(word >> 32); 698| 8.73k| val[4] = (FLAC__byte)(word >> 24); 699| 8.73k| val[5] = (FLAC__byte)(word >> 16); 700| 8.73k| val[6] = (FLAC__byte)(word >> 8); 701| 8.73k| 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.73k| val += FLAC__BYTES_PER_WORD; ------------------ | | 72| 8.73k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 707| 8.73k| nvals -= FLAC__BYTES_PER_WORD; ------------------ | | 72| 8.73k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 708| 8.73k| if(br->read_limit_set) ------------------ | Branch (708:7): [True: 0, False: 8.73k] ------------------ 709| 0| br->read_limit -= FLAC__BITS_PER_WORD; ------------------ | | 73| 0|#define FLAC__BITS_PER_WORD 64 ------------------ 710| 8.73k| } 711| 0| else if(!bitreader_read_from_client_(br)) ------------------ | Branch (711:11): [True: 0, False: 0] ------------------ 712| 0| return false; 713| 8.73k| } 714| | /* step 3: read any remainder from partial tail bytes */ 715| 26.2k| while(nvals) { ------------------ | Branch (715:8): [True: 17.4k, False: 8.73k] ------------------ 716| 17.4k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (716:6): [True: 0, False: 17.4k] ------------------ 717| 0| return false; 718| 17.4k| *val++ = (FLAC__byte)x; 719| 17.4k| nvals--; 720| 17.4k| } 721| | 722| 8.73k| return true; 723| 8.73k|} FLAC__bitreader_read_unary_unsigned: 745| 4.16M|{ 746| 4.16M| uint32_t i; 747| | 748| 4.16M| FLAC__ASSERT(0 != br); ------------------ | | 38| 4.16M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 4.16M] | | ------------------ ------------------ 749| 4.16M| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 4.16M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 4.16M] | | ------------------ ------------------ 750| | 751| 4.16M| *val = 0; 752| 4.16M| while(1) { ------------------ | Branch (752:8): [True: 4.16M, Folded] ------------------ 753| 4.17M| while(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */ ------------------ | Branch (753:9): [True: 3.87M, False: 305k] ------------------ 754| 3.87M| brword b = br->consumed_bits < FLAC__BITS_PER_WORD ? br->buffer[br->consumed_words] << br->consumed_bits : 0; ------------------ | | 73| 3.87M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (754:15): [True: 3.87M, False: 0] ------------------ 755| 3.87M| if(b) { ------------------ | Branch (755:7): [True: 3.85M, False: 12.8k] ------------------ 756| 3.85M| i = COUNT_ZERO_MSBS(b); ------------------ | | 82| 3.85M|#define COUNT_ZERO_MSBS(word) FLAC__clz_uint64(word) ------------------ 757| 3.85M| *val += i; 758| 3.85M| i++; 759| 3.85M| br->consumed_bits += i; 760| 3.85M| if(br->consumed_bits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(br->consumed_bits == FLAC__BITS_PER_WORD) */ ------------------ | | 73| 3.85M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (760:8): [True: 67.2k, False: 3.79M] ------------------ 761| 67.2k| br->consumed_words++; 762| 67.2k| br->consumed_bits = 0; 763| 67.2k| } 764| 3.85M| return true; 765| 3.85M| } 766| 12.8k| else { 767| 12.8k| *val += FLAC__BITS_PER_WORD - br->consumed_bits; ------------------ | | 73| 12.8k|#define FLAC__BITS_PER_WORD 64 ------------------ 768| 12.8k| br->consumed_words++; 769| 12.8k| br->consumed_bits = 0; 770| | /* didn't find stop bit yet, have to keep going... */ 771| 12.8k| } 772| 3.87M| } 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| 305k| if(br->bytes*8 > br->consumed_bits) { ------------------ | Branch (780:6): [True: 304k, False: 462] ------------------ 781| 304k| const uint32_t end = br->bytes * 8; 782| 304k| brword b = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << br->consumed_bits; ------------------ | | 74| 304k|#define FLAC__WORD_ALL_ONES ((FLAC__uint64)FLAC__U64L(0xffffffffffffffff)) | | ------------------ | | | | 102| 304k|#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| 304k|#define FLAC__BITS_PER_WORD 64 ------------------ 783| 304k| if(b) { ------------------ | Branch (783:7): [True: 304k, False: 0] ------------------ 784| 304k| i = COUNT_ZERO_MSBS(b); ------------------ | | 82| 304k|#define COUNT_ZERO_MSBS(word) FLAC__clz_uint64(word) ------------------ 785| 304k| *val += i; 786| 304k| i++; 787| 304k| br->consumed_bits += i; 788| 304k| FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD); ------------------ | | 38| 304k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 304k] | | ------------------ ------------------ 789| 304k| return true; 790| 304k| } 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| 304k| } 798| 462| if(!bitreader_read_from_client_(br)) ------------------ | Branch (798:6): [True: 0, False: 462] ------------------ 799| 0| return false; 800| 462| } 801| 4.16M|} FLAC__bitreader_read_utf8_uint32: 929| 216k|{ 930| 216k| FLAC__uint32 v = 0; 931| 216k| FLAC__uint32 x; 932| 216k| uint32_t i; 933| | 934| 216k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (934:5): [True: 0, False: 216k] ------------------ 935| 0| return false; 936| 216k| if(raw) ------------------ | Branch (936:5): [True: 216k, False: 0] ------------------ 937| 216k| raw[(*rawlen)++] = (FLAC__byte)x; 938| 216k| if(!(x & 0x80)) { /* 0xxxxxxx */ ------------------ | Branch (938:5): [True: 78.9k, False: 137k] ------------------ 939| 78.9k| v = x; 940| 78.9k| i = 0; 941| 78.9k| } 942| 137k| else if((x & 0xE0) == 0xC0) { /* 110xxxxx */ ------------------ | Branch (942:10): [True: 115k, False: 22.1k] ------------------ 943| 115k| v = x & 0x1F; 944| 115k| i = 1; 945| 115k| } 946| 22.1k| else if((x & 0xF0) == 0xE0) { /* 1110xxxx */ ------------------ | Branch (946:10): [True: 22.1k, False: 0] ------------------ 947| 22.1k| v = x & 0x0F; 948| 22.1k| i = 2; 949| 22.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| 375k| for( ; i; i--) { ------------------ | Branch (966:9): [True: 159k, False: 216k] ------------------ 967| 159k| if(!FLAC__bitreader_read_raw_uint32(br, &x, 8)) ------------------ | Branch (967:6): [True: 0, False: 159k] ------------------ 968| 0| return false; 969| 159k| if(raw) ------------------ | Branch (969:6): [True: 159k, False: 0] ------------------ 970| 159k| raw[(*rawlen)++] = (FLAC__byte)x; 971| 159k| if(!(x & 0x80) || (x & 0x40)) { /* 10xxxxxx */ ------------------ | Branch (971:6): [True: 0, False: 159k] | Branch (971:21): [True: 0, False: 159k] ------------------ 972| 0| *val = 0xffffffff; 973| 0| return true; 974| 0| } 975| 159k| v <<= 6; 976| 159k| v |= (x & 0x3F); 977| 159k| } 978| 216k| *val = v; 979| | return true; 980| 216k|} bitreader.c:crc16_update_block_: 136| 448k|{ 137| 448k| if(br->consumed_words > br->crc16_offset && br->crc16_align) ------------------ | Branch (137:5): [True: 448k, False: 234] | Branch (137:46): [True: 372k, False: 75.5k] ------------------ 138| 372k| crc16_update_word_(br, br->buffer[br->crc16_offset++]); 139| | 140| | /* Prevent OOB read due to wrap-around. */ 141| 448k| if (br->consumed_words > br->crc16_offset) { ------------------ | Branch (141:6): [True: 412k, False: 36.1k] ------------------ 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| 412k| } 153| | 154| 448k| br->crc16_offset = 0; 155| 448k|} bitreader.c:crc16_update_word_: 123| 372k|{ 124| 372k| register uint32_t crc = br->read_crc16; 125| | 126| 1.83M| for ( ; br->crc16_align < FLAC__BITS_PER_WORD ; br->crc16_align += 8) { ------------------ | | 73| 1.83M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (126:10): [True: 1.46M, False: 372k] ------------------ 127| 1.46M| uint32_t shift = FLAC__BITS_PER_WORD - 8 - br->crc16_align ; ------------------ | | 73| 1.46M|#define FLAC__BITS_PER_WORD 64 ------------------ 128| 1.46M| crc = FLAC__CRC16_UPDATE ((uint32_t) (shift < FLAC__BITS_PER_WORD ? (word >> shift) & 0xff : 0), crc); ------------------ | | 50| 2.93M|#define FLAC__CRC16_UPDATE(data, crc) ((((crc)<<8) & 0xffff) ^ FLAC__crc16_table[0][((crc)>>8) ^ (data)]) | | ------------------ | | | Branch (50:99): [True: 1.46M, False: 0] | | ------------------ ------------------ 129| 1.46M| } 130| | 131| 372k| br->read_crc16 = crc; 132| 372k| br->crc16_align = 0; 133| 372k|} bitreader.c:bitreader_read_from_client_: 158| 250k|{ 159| 250k| uint32_t start, end; 160| 250k| size_t bytes; 161| 250k| FLAC__byte *target; 162| |#if WORDS_BIGENDIAN 163| |#else 164| 250k| brword preswap_backup; 165| 250k|#endif 166| | 167| | /* first shift the unconsumed buffer data toward the front as much as possible */ 168| 250k| if(br->consumed_words > 0) { ------------------ | Branch (168:5): [True: 232k, False: 17.5k] ------------------ 169| | /* invalidate last seen framesync */ 170| 232k| br->last_seen_framesync = -1; 171| | 172| 232k| crc16_update_block_(br); /* CRC consumed words */ 173| | 174| 232k| start = br->consumed_words; 175| 232k| end = br->words + (br->bytes? 1:0); ------------------ | Branch (175:22): [True: 198k, False: 33.6k] ------------------ 176| 232k| memmove(br->buffer, br->buffer+start, FLAC__BYTES_PER_WORD * (end - start)); ------------------ | | 72| 232k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 177| | 178| 232k| br->words -= start; 179| 232k| br->consumed_words = 0; 180| 232k| } 181| | 182| | /* 183| | * set the target for reading, taking into account word alignment and endianness 184| | */ 185| 250k| bytes = (br->capacity - br->words) * FLAC__BYTES_PER_WORD - br->bytes; ------------------ | | 72| 250k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 186| 250k| if(bytes == 0) ------------------ | Branch (186:5): [True: 0, False: 250k] ------------------ 187| 0| return false; /* no space left, buffer is too small; see note for FLAC__BITREADER_DEFAULT_CAPACITY */ 188| 250k| 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| 250k| preswap_backup = br->buffer[br->words]; 201| 250k| if(br->bytes) ------------------ | Branch (201:5): [True: 207k, False: 42.3k] ------------------ 202| 207k| br->buffer[br->words] = SWAP_BE_WORD_TO_HOST(br->buffer[br->words]); ------------------ | | 79| 207k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 207k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 203| 250k|#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| 250k| if(!br->read_callback(target, &bytes, br->client_data)){ ------------------ | Branch (213:5): [True: 0, False: 250k] ------------------ 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| 250k| end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + (uint32_t)bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD; ------------------ | | 72| 250k|#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| 250k|#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| 250k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 233| 10.7M| for(start = br->words; start < end; start++) ------------------ | Branch (233:25): [True: 10.4M, False: 250k] ------------------ 234| 10.4M| br->buffer[start] = SWAP_BE_WORD_TO_HOST(br->buffer[start]); ------------------ | | 79| 10.4M|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 10.7M|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 235| 250k|#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| 250k| end = br->words*FLAC__BYTES_PER_WORD + br->bytes + (uint32_t)bytes; ------------------ | | 72| 250k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 244| 250k| br->words = end / FLAC__BYTES_PER_WORD; ------------------ | | 72| 250k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 245| 250k| br->bytes = end % FLAC__BYTES_PER_WORD; ------------------ | | 72| 250k|#define FLAC__BYTES_PER_WORD 8 /* sizeof brword */ ------------------ 246| | 247| | return true; 248| 250k|} FLAC__bitwriter_new: 161| 25.5k|{ 162| 25.5k| FLAC__BitWriter *bw = calloc(1, sizeof(FLAC__BitWriter)); 163| | /* note that calloc() sets all members to 0 for us */ 164| 25.5k| return bw; 165| 25.5k|} FLAC__bitwriter_delete: 168| 25.5k|{ 169| 25.5k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 25.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 25.5k] | | ------------------ ------------------ 170| | 171| 25.5k| FLAC__bitwriter_free(bw); 172| 25.5k| free(bw); 173| 25.5k|} FLAC__bitwriter_init: 182| 23.2k|{ 183| 23.2k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 23.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.2k] | | ------------------ ------------------ 184| | 185| 23.2k| bw->words = bw->bits = 0; 186| 23.2k| bw->capacity = FLAC__BITWRITER_DEFAULT_CAPACITY; 187| 23.2k| bw->buffer = malloc(sizeof(bwword) * bw->capacity); 188| 23.2k| if(bw->buffer == 0) ------------------ | Branch (188:5): [True: 0, False: 23.2k] ------------------ 189| 0| return false; 190| | 191| 23.2k| return true; 192| 23.2k|} FLAC__bitwriter_free: 195| 25.5k|{ 196| 25.5k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 25.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 25.5k] | | ------------------ ------------------ 197| | 198| 25.5k| if(0 != bw->buffer) ------------------ | Branch (198:5): [True: 23.2k, False: 2.30k] ------------------ 199| 23.2k| free(bw->buffer); 200| 25.5k| bw->buffer = 0; 201| 25.5k| bw->capacity = 0; 202| 25.5k| bw->words = bw->bits = 0; 203| 25.5k|} FLAC__bitwriter_clear: 206| 296k|{ 207| 296k| bw->words = bw->bits = 0; 208| 296k|} FLAC__bitwriter_get_write_crc16: 211| 266k|{ 212| 266k| const FLAC__byte *buffer; 213| 266k| size_t bytes; 214| | 215| 266k| FLAC__ASSERT((bw->bits & 7) == 0); /* assert that we're byte-aligned */ ------------------ | | 38| 266k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 266k] | | ------------------ ------------------ 216| | 217| 266k| if(!FLAC__bitwriter_get_buffer(bw, &buffer, &bytes)) ------------------ | Branch (217:5): [True: 0, False: 266k] ------------------ 218| 0| return false; 219| | 220| 266k| *crc = (FLAC__uint16)FLAC__crc16(buffer, bytes); 221| 266k| FLAC__bitwriter_release_buffer(bw); 222| | return true; 223| 266k|} FLAC__bitwriter_get_write_crc8: 226| 266k|{ 227| 266k| const FLAC__byte *buffer; 228| 266k| size_t bytes; 229| | 230| 266k| FLAC__ASSERT((bw->bits & 7) == 0); /* assert that we're byte-aligned */ ------------------ | | 38| 266k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 266k] | | ------------------ ------------------ 231| | 232| 266k| if(!FLAC__bitwriter_get_buffer(bw, &buffer, &bytes)) ------------------ | Branch (232:5): [True: 0, False: 266k] ------------------ 233| 0| return false; 234| | 235| 266k| *crc = FLAC__crc8(buffer, bytes); 236| 266k| FLAC__bitwriter_release_buffer(bw); 237| | return true; 238| 266k|} FLAC__bitwriter_is_byte_aligned: 241| 869k|{ 242| 869k| return ((bw->bits & 7) == 0); 243| 869k|} FLAC__bitwriter_get_input_bits_unconsumed: 246| 39.3k|{ 247| 39.3k| return FLAC__TOTAL_BITS(bw); ------------------ | | 96| 39.3k|#define FLAC__TOTAL_BITS(bw) (FLAC__WORDS_TO_BITS((bw)->words) + (bw)->bits) | | ------------------ | | | | 95| 39.3k|#define FLAC__WORDS_TO_BITS(words) ((words) * FLAC__BITS_PER_WORD) | | | | ------------------ | | | | | | 73| 39.3k|#define FLAC__BITS_PER_WORD 64 | | | | ------------------ | | ------------------ ------------------ 248| 39.3k|} FLAC__bitwriter_get_buffer: 251| 828k|{ 252| 828k| FLAC__ASSERT((bw->bits & 7) == 0); ------------------ | | 38| 828k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 828k] | | ------------------ ------------------ 253| | /* double protection */ 254| 828k| if(bw->bits & 7) ------------------ | Branch (254:5): [True: 0, False: 828k] ------------------ 255| 0| return false; 256| | /* if we have bits in the accumulator we have to flush those to the buffer first */ 257| 828k| if(bw->bits) { ------------------ | Branch (257:5): [True: 692k, False: 135k] ------------------ 258| 692k| FLAC__ASSERT(bw->words <= bw->capacity); ------------------ | | 38| 692k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 692k] | | ------------------ ------------------ 259| 692k| 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: 692k] | 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| 692k| bw->buffer[bw->words] = SWAP_BE_WORD_TO_HOST(bw->accum << (FLAC__BITS_PER_WORD-bw->bits)); ------------------ | | 80| 692k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 692k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 263| 692k| } 264| | /* now we can just return what we have */ 265| 828k| *buffer = (FLAC__byte*)bw->buffer; 266| 828k| *bytes = (FLAC__BYTES_PER_WORD * bw->words) + (bw->bits >> 3); ------------------ | | 72| 828k|#define FLAC__BYTES_PER_WORD 8 /* sizeof bwword */ ------------------ 267| | return true; 268| 828k|} FLAC__bitwriter_release_buffer: 271| 828k|{ 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| 828k| (void)bw; 276| 828k|} FLAC__bitwriter_write_zeroes: 279| 144k|{ 280| 144k| uint32_t n; 281| | 282| 144k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 144k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 144k] | | ------------------ ------------------ 283| 144k| FLAC__ASSERT(0 != bw->buffer); ------------------ | | 38| 144k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 144k] | | ------------------ ------------------ 284| | 285| 144k| if(bits == 0) ------------------ | Branch (285:5): [True: 0, False: 144k] ------------------ 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| 144k| if(bw->capacity <= bw->words + bits && !bitwriter_grow_(bw, bits)) ------------------ | Branch (288:5): [True: 26, False: 144k] | Branch (288:41): [True: 0, False: 26] ------------------ 289| 0| return false; 290| | /* first part gets to word alignment */ 291| 144k| if(bw->bits) { ------------------ | Branch (291:5): [True: 144k, False: 18.4E] ------------------ 292| 144k| n = flac_min(FLAC__BITS_PER_WORD - bw->bits, bits); ------------------ | | 56| 144k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (292:7): [True: 0, False: 144k] ------------------ 293| 144k| bw->accum <<= n; 294| 144k| bits -= n; 295| 144k| bw->bits += n; 296| 144k| if(bw->bits == FLAC__BITS_PER_WORD) { ------------------ | | 73| 144k|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (296:6): [True: 9.64k, False: 134k] ------------------ 297| 9.64k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); ------------------ | | 80| 9.64k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 9.64k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 298| 9.64k| bw->bits = 0; 299| 9.64k| } 300| 134k| else 301| 134k| return true; 302| 144k| } 303| | /* do whole words */ 304| 9.64k| while(bits >= FLAC__BITS_PER_WORD) { ------------------ | | 73| 9.64k|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (304:8): [True: 0, False: 9.64k] ------------------ 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.64k| if(bits > 0) { ------------------ | Branch (309:5): [True: 0, False: 9.64k] ------------------ 310| 0| bw->accum = 0; 311| 0| bw->bits = bits; 312| 0| } 313| | return true; 314| 144k|} FLAC__bitwriter_write_raw_uint32: 358| 7.85M|{ 359| | /* check that unused bits are unset */ 360| 7.85M| if((bits < 32) && (val>>bits != 0)) ------------------ | Branch (360:5): [True: 7.61M, False: 244k] | Branch (360:20): [True: 0, False: 7.61M] ------------------ 361| 0| return false; 362| | 363| 7.85M| return FLAC__bitwriter_write_raw_uint32_nocheck(bw, val, bits); 364| 7.85M|} FLAC__bitwriter_write_raw_int32: 367| 4.02M|{ 368| | /* zero-out unused bits */ 369| 4.02M| if(bits < 32) ------------------ | Branch (369:5): [True: 847k, False: 3.18M] ------------------ 370| 847k| val &= (~(0xffffffff << bits)); 371| | 372| 4.02M| return FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)val, bits); 373| 4.02M|} FLAC__bitwriter_write_raw_uint64: 376| 2.14M|{ 377| | /* this could be a little faster but it's not used for much */ 378| 2.14M| if(bits > 32) { ------------------ | Branch (378:5): [True: 1.82M, False: 325k] ------------------ 379| 1.82M| return 380| 1.82M| FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)(val>>32), bits-32) && ------------------ | Branch (380:4): [True: 1.82M, False: 18.4E] ------------------ 381| 1.82M| FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)val, 32); ------------------ | Branch (381:4): [True: 1.82M, False: 0] ------------------ 382| 1.82M| } 383| 325k| else 384| 325k| return FLAC__bitwriter_write_raw_uint32(bw, (FLAC__uint32)val, bits); 385| 2.14M|} FLAC__bitwriter_write_raw_int64: 388| 2.13M|{ 389| 2.13M| FLAC__uint64 uval = val; 390| | /* zero-out unused bits */ 391| 2.13M| if(bits < 64) ------------------ | Branch (391:5): [True: 2.13M, False: 18.4E] ------------------ 392| 2.13M| uval &= (~(UINT64_MAX << bits)); 393| 2.13M| return FLAC__bitwriter_write_raw_uint64(bw, uval, bits); 394| 2.13M|} FLAC__bitwriter_write_raw_uint32_little_endian: 397| 19.6k|{ 398| | /* this doesn't need to be that fast as currently it is only used for vorbis comments */ 399| | 400| 19.6k| if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, val & 0xff, 8)) ------------------ | Branch (400:5): [True: 0, False: 19.6k] ------------------ 401| 0| return false; 402| 19.6k| if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, (val>>8) & 0xff, 8)) ------------------ | Branch (402:5): [True: 0, False: 19.6k] ------------------ 403| 0| return false; 404| 19.6k| if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, (val>>16) & 0xff, 8)) ------------------ | Branch (404:5): [True: 0, False: 19.6k] ------------------ 405| 0| return false; 406| 19.6k| if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, val>>24, 8)) ------------------ | Branch (406:5): [True: 0, False: 19.6k] ------------------ 407| 0| return false; 408| | 409| 19.6k| return true; 410| 19.6k|} FLAC__bitwriter_write_byte_block: 413| 19.6k|{ 414| 19.6k| uint32_t i; 415| | 416| | /* grow capacity upfront to prevent constant reallocation during writes */ 417| 19.6k| if(bw->capacity <= bw->words + nvals / (FLAC__BITS_PER_WORD / 8) + 1 && !bitwriter_grow_(bw, nvals * 8)) ------------------ | | 73| 19.6k|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (417:5): [True: 0, False: 19.6k] | 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| 560k| for(i = 0; i < nvals; i++) { ------------------ | Branch (421:13): [True: 540k, False: 19.6k] ------------------ 422| 540k| if(!FLAC__bitwriter_write_raw_uint32_nocheck(bw, (FLAC__uint32)(vals[i]), 8)) ------------------ | Branch (422:6): [True: 0, False: 540k] ------------------ 423| 0| return false; 424| 540k| } 425| | 426| 19.6k| return true; 427| 19.6k|} FLAC__bitwriter_write_unary_unsigned: 430| 26.1k|{ 431| 26.1k| if(val < 32) ------------------ | Branch (431:5): [True: 26.1k, False: 0] ------------------ 432| 26.1k| 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| 26.1k|} FLAC__bitwriter_write_rice_signed_block: 576| 1.71M|{ 577| 1.71M| const FLAC__uint32 mask1 = (FLAC__uint32)0xffffffff << parameter; /* we val|=mask1 to set the stop bit above it... */ 578| 1.71M| const FLAC__uint32 mask2 = (FLAC__uint32)0xffffffff >> (31-parameter); /* ...then mask off the bits above the stop bit with val&=mask2 */ 579| 1.71M| FLAC__uint32 uval; 580| 1.71M| const uint32_t lsbits = 1 + parameter; 581| 1.71M| uint32_t msbits, total_bits; 582| 1.71M| FLAC__bwtemp wide_accum = 0; 583| 1.71M| FLAC__uint32 bitpointer = FLAC__TEMP_BITS; ------------------ | | 74| 1.71M|#define FLAC__TEMP_BITS 64 ------------------ 584| | 585| 1.71M| FLAC__ASSERT(0 != bw); ------------------ | | 38| 1.71M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.71M] | | ------------------ ------------------ 586| 1.71M| FLAC__ASSERT(0 != bw->buffer); ------------------ | | 38| 1.71M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.71M] | | ------------------ ------------------ 587| 1.71M| FLAC__ASSERT(parameter < 31); ------------------ | | 38| 1.71M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.71M] | | ------------------ ------------------ 588| | /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */ 589| 1.71M| FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32); ------------------ | | 38| 1.71M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 1.71M] | | ------------------ ------------------ 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.71M| if(bw->bits > 0 && bw->bits < FLAC__HALF_TEMP_BITS) { ------------------ | | 75| 1.69M|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (597:5): [True: 1.69M, False: 22.0k] | Branch (597:21): [True: 848k, False: 841k] ------------------ 598| 848k| bitpointer -= bw->bits; 599| 848k| wide_accum = bw->accum << bitpointer; 600| 848k| bw->bits = 0; 601| 848k| } 602| 863k| else if(bw->bits > FLAC__HALF_TEMP_BITS) { ------------------ | | 75| 863k|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (602:10): [True: 824k, False: 39.6k] ------------------ 603| 824k| bitpointer -= (bw->bits - FLAC__HALF_TEMP_BITS); ------------------ | | 75| 824k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 604| 824k| wide_accum = bw->accum << bitpointer; 605| 824k| bw->accum >>= (bw->bits - FLAC__HALF_TEMP_BITS); ------------------ | | 75| 824k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 606| 824k| bw->bits = FLAC__HALF_TEMP_BITS; ------------------ | | 75| 824k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 607| 824k| } 608| 1.71M|#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.71M| 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.71M|#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.71M|#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.71M|#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.20k|#define FLAC__TEMP_BITS 64 ------------------ | Branch (612:5): [True: 1.20k, False: 1.71M] | Branch (612:115): [True: 0, False: 1.20k] ------------------ 613| 0| return false; 614| | 615| 23.2M| while(nvals) { ------------------ | Branch (615:8): [True: 21.5M, False: 1.71M] ------------------ 616| | /* fold signed to uint32_t; actual formula is: negative(v)? -2v-1 : 2v */ 617| 21.5M| uval = *vals; 618| 21.5M| uval <<= 1; 619| 21.5M| uval ^= (*vals>>31); 620| | 621| 21.5M| msbits = uval >> parameter; 622| 21.5M| total_bits = lsbits + msbits; 623| | 624| 21.5M| uval |= mask1; /* set stop bit */ 625| 21.5M| uval &= mask2; /* mask off unused top bits */ 626| | 627| | 628| 21.5M| if(total_bits <= bitpointer) { ------------------ | Branch (628:6): [True: 21.4M, False: 106k] ------------------ 629| | /* There is room enough to store the symbol whole at once */ 630| 21.4M| wide_accum |= (FLAC__bwtemp)(uval) << (bitpointer - total_bits); 631| 21.4M| bitpointer -= total_bits; 632| 21.4M| if(bitpointer <= FLAC__HALF_TEMP_BITS) { ------------------ | | 75| 21.4M|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (632:7): [True: 13.6M, False: 7.81M] ------------------ 633| | /* A word is finished, copy the upper 32 bits of the wide_accum */ 634| 13.6M| WIDE_ACCUM_TO_BW ------------------ | | 556| 13.6M|#define WIDE_ACCUM_TO_BW { \ | | 557| 13.6M| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 13.6M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 13.6M] | | | | ------------------ | | ------------------ | | 558| 13.6M| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 6.78M, False: 6.82M] | | ------------------ | | 559| 6.78M| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 6.78M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 6.78M| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 6.78M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 6.78M| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 6.78M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 6.78M| } \ | | 563| 13.6M| else { \ | | 564| 6.82M| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 6.82M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 6.82M| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 6.82M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 6.82M| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 6.82M|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 6.82M|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 6.82M| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 6.82M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 6.82M| bw->bits = 0; \ | | 569| 6.82M| } \ | | 570| 13.6M| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 13.6M|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 13.6M|} ------------------ 635| 13.6M| } 636| 21.4M| } 637| 106k| else { 638| | /* The symbol needs to be split. This code isn't used often */ 639| | /* First check for space in the bitwriter */ 640| 106k| if(total_bits > FLAC__TEMP_BITS) { ------------------ | | 74| 106k|#define FLAC__TEMP_BITS 64 ------------------ | Branch (640:7): [True: 30.6k, False: 75.7k] ------------------ 641| 30.6k| FLAC__uint32 oversize_in_bits = total_bits - FLAC__TEMP_BITS; ------------------ | | 74| 30.6k|#define FLAC__TEMP_BITS 64 ------------------ 642| 30.6k| FLAC__uint32 capacity_needed = bw->words * FLAC__BITS_PER_WORD + bw->bits + nvals * FLAC__TEMP_BITS + oversize_in_bits; ------------------ | | 73| 30.6k|#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| 30.6k|#define FLAC__TEMP_BITS 64 ------------------ 643| 30.6k| if(bw->capacity * FLAC__BITS_PER_WORD <= capacity_needed && !bitwriter_grow_(bw, nvals * FLAC__TEMP_BITS + oversize_in_bits)) ------------------ | | 73| 30.6k|#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| 165|#define FLAC__TEMP_BITS 64 ------------------ | Branch (643:8): [True: 165, False: 30.5k] | Branch (643:65): [True: 0, False: 165] ------------------ 644| 0| return false; 645| 30.6k| } 646| 106k| if(msbits > bitpointer) { ------------------ | Branch (646:7): [True: 28.6k, False: 77.8k] ------------------ 647| | /* We have a lot of 0 bits to write, first align with bitwriter word */ 648| 28.6k| msbits -= bitpointer - FLAC__HALF_TEMP_BITS; ------------------ | | 75| 28.6k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 649| 28.6k| bitpointer = FLAC__HALF_TEMP_BITS; ------------------ | | 75| 28.6k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 650| 28.6k| WIDE_ACCUM_TO_BW ------------------ | | 556| 28.6k|#define WIDE_ACCUM_TO_BW { \ | | 557| 28.6k| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 28.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 28.6k] | | | | ------------------ | | ------------------ | | 558| 28.6k| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 14.1k, False: 14.4k] | | ------------------ | | 559| 14.1k| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.1k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 14.1k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.1k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 14.1k| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.1k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 14.1k| } \ | | 563| 28.6k| else { \ | | 564| 14.4k| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 14.4k| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 14.4k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 14.4k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 14.4k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 14.4k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 14.4k| bw->bits = 0; \ | | 569| 14.4k| } \ | | 570| 28.6k| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 28.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 28.6k|} ------------------ 651| 250k| while(msbits > bitpointer) { ------------------ | Branch (651:11): [True: 221k, False: 28.6k] ------------------ 652| | /* As the accumulator is already zero, we only need to 653| | * assign zeroes to the bitbuffer */ 654| 221k| WIDE_ACCUM_TO_BW ------------------ | | 556| 221k|#define WIDE_ACCUM_TO_BW { \ | | 557| 221k| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 221k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 221k] | | | | ------------------ | | ------------------ | | 558| 221k| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 110k, False: 110k] | | ------------------ | | 559| 110k| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 110k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 110k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 110k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 110k| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 110k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 110k| } \ | | 563| 221k| else { \ | | 564| 110k| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 110k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 110k| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 110k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 110k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 110k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 110k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 110k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 110k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 110k| bw->bits = 0; \ | | 569| 110k| } \ | | 570| 221k| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 221k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 221k|} ------------------ 655| 221k| bitpointer -= FLAC__HALF_TEMP_BITS; ------------------ | | 75| 221k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 656| 221k| msbits -= FLAC__HALF_TEMP_BITS; ------------------ | | 75| 221k|#define FLAC__HALF_TEMP_BITS 32 ------------------ 657| 221k| } 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| 28.6k| bitpointer -= msbits; 662| 28.6k| if(bitpointer <= FLAC__HALF_TEMP_BITS) ------------------ | | 75| 28.6k|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (662:8): [True: 28.6k, False: 0] ------------------ 663| 28.6k| WIDE_ACCUM_TO_BW ------------------ | | 556| 28.6k|#define WIDE_ACCUM_TO_BW { \ | | 557| 28.6k| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 28.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 28.6k] | | | | ------------------ | | ------------------ | | 558| 28.6k| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 14.3k, False: 14.2k] | | ------------------ | | 559| 14.3k| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.3k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 14.3k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.3k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 14.3k| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.3k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 14.3k| } \ | | 563| 28.6k| else { \ | | 564| 14.2k| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.2k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 14.2k| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.2k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 14.2k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 14.2k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 14.2k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 14.2k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 14.2k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 14.2k| bw->bits = 0; \ | | 569| 14.2k| } \ | | 570| 28.6k| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 28.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 28.6k|} ------------------ 664| 28.6k| } 665| 77.8k| else { 666| 77.8k| bitpointer -= msbits; 667| 77.8k| if(bitpointer <= FLAC__HALF_TEMP_BITS) ------------------ | | 75| 77.8k|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (667:8): [True: 78.0k, False: 18.4E] ------------------ 668| 78.0k| WIDE_ACCUM_TO_BW ------------------ | | 556| 78.0k|#define WIDE_ACCUM_TO_BW { \ | | 557| 78.0k| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 78.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 78.0k] | | | | ------------------ | | ------------------ | | 558| 78.0k| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 39.6k, False: 38.4k] | | ------------------ | | 559| 39.6k| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 39.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 39.6k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 39.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 39.6k| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 39.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 39.6k| } \ | | 563| 78.0k| else { \ | | 564| 38.4k| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 38.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 38.4k| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 38.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 38.4k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 38.4k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 38.4k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 38.4k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 38.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 38.4k| bw->bits = 0; \ | | 569| 38.4k| } \ | | 570| 78.0k| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 78.0k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 78.0k|} ------------------ 669| 77.8k| } 670| | /* The lsbs + stop bit always fit 32 bit, so this code mirrors the code above */ 671| 106k| wide_accum |= (FLAC__bwtemp)(uval) << (bitpointer - lsbits); 672| 106k| bitpointer -= lsbits; 673| 106k| if(bitpointer <= FLAC__HALF_TEMP_BITS) { ------------------ | | 75| 106k|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (673:28): [True: 95.6k, False: 10.8k] ------------------ 674| | /* A word is finished, copy the upper 32 bits of the wide_accum */ 675| 95.6k| WIDE_ACCUM_TO_BW ------------------ | | 556| 95.6k|#define WIDE_ACCUM_TO_BW { \ | | 557| 95.6k| FLAC__ASSERT(bw->bits % FLAC__HALF_TEMP_BITS == 0); \ | | ------------------ | | | | 38| 95.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 95.6k] | | | | ------------------ | | ------------------ | | 558| 95.6k| if(bw->bits == 0) { \ | | ------------------ | | | Branch (558:5): [True: 47.2k, False: 48.4k] | | ------------------ | | 559| 47.2k| bw->accum = wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 47.2k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 560| 47.2k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 47.2k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 561| 47.2k| bw->bits = FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 47.2k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 562| 47.2k| } \ | | 563| 95.6k| else { \ | | 564| 48.4k| bw->accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 48.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 565| 48.4k| bw->accum += wide_accum >> FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 48.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 566| 48.4k| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); \ | | ------------------ | | | | 80| 48.4k|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | | | ------------------ | | | | | | 46| 48.4k|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | | | ------------------ | | ------------------ | | 567| 48.4k| wide_accum <<= FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 48.4k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 568| 48.4k| bw->bits = 0; \ | | 569| 48.4k| } \ | | 570| 95.6k| bitpointer += FLAC__HALF_TEMP_BITS; \ | | ------------------ | | | | 75| 95.6k|#define FLAC__HALF_TEMP_BITS 32 | | ------------------ | | 571| 95.6k|} ------------------ 676| 95.6k| } 677| 106k| } 678| 21.5M| vals++; 679| 21.5M| nvals--; 680| 21.5M| } 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.71M| if(bitpointer < FLAC__TEMP_BITS) { ------------------ | | 74| 1.71M|#define FLAC__TEMP_BITS 64 ------------------ | Branch (688:5): [True: 1.68M, False: 31.0k] ------------------ 689| 1.68M| if(bw->bits == 0) { ------------------ | Branch (689:6): [True: 899k, False: 781k] ------------------ 690| 899k| bw->accum = wide_accum >> bitpointer; 691| 899k| bw->bits = FLAC__TEMP_BITS - bitpointer; ------------------ | | 74| 899k|#define FLAC__TEMP_BITS 64 ------------------ 692| 899k| } 693| 782k| else if (bw->bits == FLAC__HALF_TEMP_BITS) { ------------------ | | 75| 781k|#define FLAC__HALF_TEMP_BITS 32 ------------------ | Branch (693:12): [True: 782k, False: 18.4E] ------------------ 694| 782k| bw->accum <<= FLAC__TEMP_BITS - bitpointer; ------------------ | | 74| 782k|#define FLAC__TEMP_BITS 64 ------------------ 695| 782k| bw->accum |= (wide_accum >> bitpointer); 696| 782k| bw->bits = FLAC__HALF_TEMP_BITS + FLAC__TEMP_BITS - bitpointer; ------------------ | | 75| 782k|#define FLAC__HALF_TEMP_BITS 32 ------------------ bw->bits = FLAC__HALF_TEMP_BITS + FLAC__TEMP_BITS - bitpointer; ------------------ | | 74| 782k|#define FLAC__TEMP_BITS 64 ------------------ 697| 782k| } 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.68M| } 702| 1.71M|#endif 703| | 704| | 705| 1.71M| return true; 706| 1.71M|} FLAC__bitwriter_write_utf8_uint32: 833| 267k|{ 834| 267k| FLAC__bool ok = 1; 835| | 836| 267k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 267k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 267k] | | ------------------ ------------------ 837| 267k| FLAC__ASSERT(0 != bw->buffer); ------------------ | | 38| 267k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 267k] | | ------------------ ------------------ 838| | 839| 267k| if((val & 0x80000000) != 0) /* this version only handles 31 bits */ ------------------ | Branch (839:5): [True: 0, False: 267k] ------------------ 840| 0| return false; 841| | 842| 267k| if(val < 0x80) { ------------------ | Branch (842:5): [True: 86.3k, False: 180k] ------------------ 843| 86.3k| return FLAC__bitwriter_write_raw_uint32_nocheck(bw, val, 8); 844| 86.3k| } 845| 180k| else if(val < 0x800) { ------------------ | Branch (845:10): [True: 142k, False: 38.5k] ------------------ 846| 142k| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xC0 | (val>>6), 8); 847| 142k| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8); 848| 142k| } 849| 38.5k| else if(val < 0x10000) { ------------------ | Branch (849:10): [True: 38.4k, False: 112] ------------------ 850| 38.4k| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xE0 | (val>>12), 8); 851| 38.4k| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>6)&0x3F), 8); 852| 38.4k| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8); 853| 38.4k| } 854| 112| else if(val < 0x200000) { ------------------ | Branch (854:10): [True: 0, False: 112] ------------------ 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| 112| else if(val < 0x4000000) { ------------------ | Branch (860:10): [True: 0, False: 112] ------------------ 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| 112| else { 868| 112| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0xFC | (val>>30), 8); 869| 112| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>24)&0x3F), 8); 870| 112| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>18)&0x3F), 8); 871| 112| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>12)&0x3F), 8); 872| 112| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | ((val>>6)&0x3F), 8); 873| 112| ok &= FLAC__bitwriter_write_raw_uint32_nocheck(bw, 0x80 | (val&0x3F), 8); 874| 112| } 875| | 876| 180k| return ok; 877| 267k|} FLAC__bitwriter_zero_pad_to_byte_boundary: 936| 266k|{ 937| | /* 0-pad to byte boundary */ 938| 266k| if(bw->bits & 7u) ------------------ | Branch (938:5): [True: 144k, False: 122k] ------------------ 939| 144k| return FLAC__bitwriter_write_zeroes(bw, 8 - (bw->bits & 7u)); 940| 122k| else 941| 122k| return true; 942| 266k|} bitwriter.c:bitwriter_grow_: 111| 31.8k|{ 112| 31.8k| uint32_t new_capacity; 113| 31.8k| bwword *new_buffer; 114| | 115| | /* Refuse to allocate more words than this amount, based on largest possible metadata chunk size */ 116| 31.8k| 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| 31.8k|#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| 31.8k|#define FLAC__BITS_PER_WORD 64 ------------------ 117| | 118| 31.8k| FLAC__ASSERT(0 != bw); ------------------ | | 38| 31.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 31.8k] | | ------------------ ------------------ 119| 31.8k| FLAC__ASSERT(0 != bw->buffer); ------------------ | | 38| 31.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 31.8k] | | ------------------ ------------------ 120| | 121| | /* calculate total words needed to store 'bits_to_add' additional bits */ 122| 31.8k| new_capacity = bw->words + ((bw->bits + bits_to_add + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD); ------------------ | | 73| 31.8k|#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| 31.8k|#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| 31.8k| if(bw->capacity >= new_capacity) ------------------ | Branch (127:5): [True: 30.1k, False: 1.69k] ------------------ 128| 30.1k| return true; 129| | 130| 1.69k| if(new_capacity > max_capacity) ------------------ | Branch (130:5): [True: 0, False: 1.69k] ------------------ 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.69k| if((new_capacity - bw->capacity) < (bw->capacity >> FLAC__BITWRITER_DEFAULT_GROW_FRACTION)) ------------------ | Branch (138:5): [True: 1.00k, False: 691] ------------------ 139| 1.00k| new_capacity = bw->capacity + (bw->capacity >> FLAC__BITWRITER_DEFAULT_GROW_FRACTION); 140| | 141| | /* make sure we got everything right */ 142| 1.69k| FLAC__ASSERT(new_capacity > bw->capacity); ------------------ | | 38| 1.69k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.69k] | | ------------------ ------------------ 143| 1.69k| FLAC__ASSERT(new_capacity >= bw->words + ((bw->bits + bits_to_add + FLAC__BITS_PER_WORD - 1) / FLAC__BITS_PER_WORD)); ------------------ | | 38| 1.69k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.69k] | | ------------------ ------------------ 144| | 145| 1.69k| new_buffer = safe_realloc_nofree_mul_2op_(bw->buffer, sizeof(bwword), /*times*/new_capacity); 146| 1.69k| if(new_buffer == 0) ------------------ | Branch (146:5): [True: 0, False: 1.69k] ------------------ 147| 0| return false; 148| 1.69k| bw->buffer = new_buffer; 149| 1.69k| bw->capacity = new_capacity; 150| | return true; 151| 1.69k|} bitwriter.c:FLAC__bitwriter_write_raw_uint32_nocheck: 317| 14.8M|{ 318| 14.8M| register uint32_t left; 319| | 320| | /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */ 321| 14.8M| FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32); ------------------ | | 38| 14.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 14.8M] | | ------------------ ------------------ 322| | 323| 14.8M| if(bw == 0 || bw->buffer == 0) ------------------ | Branch (323:5): [True: 24, False: 14.8M] | Branch (323:16): [True: 18.4E, False: 14.8M] ------------------ 324| 0| return false; 325| | 326| 14.8M| if (bits > 32) ------------------ | Branch (326:6): [True: 0, False: 14.8M] ------------------ 327| 0| return false; 328| | 329| 14.8M| if(bits == 0) ------------------ | Branch (329:5): [True: 0, False: 14.8M] ------------------ 330| 0| return true; 331| | 332| 14.8M| FLAC__ASSERT((bits == 32) || (val>>bits == 0)); ------------------ | | 38| 24.3M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 5.23M, False: 9.57M] | | | Branch (38:30): [True: 9.57M, 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| 14.8M| if(bw->capacity <= bw->words + bits && !bitwriter_grow_(bw, bits)) ------------------ | Branch (335:5): [True: 30.4k, False: 14.7M] | Branch (335:41): [True: 0, False: 30.4k] ------------------ 336| 0| return false; 337| | 338| 14.8M| left = FLAC__BITS_PER_WORD - bw->bits; ------------------ | | 73| 14.8M|#define FLAC__BITS_PER_WORD 64 ------------------ 339| 14.8M| if(bits < left) { ------------------ | Branch (339:5): [True: 11.4M, False: 3.34M] ------------------ 340| 11.4M| bw->accum <<= bits; 341| 11.4M| bw->accum |= val; 342| 11.4M| bw->bits += bits; 343| 11.4M| } 344| 3.36M| 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: 3.36M, False: 18.4E] ------------------ 345| 3.36M| bw->accum <<= left; 346| 3.36M| bw->accum |= val >> (bw->bits = bits - left); 347| 3.36M| bw->buffer[bw->words++] = SWAP_BE_WORD_TO_HOST(bw->accum); ------------------ | | 80| 3.36M|#define SWAP_BE_WORD_TO_HOST(x) ENDSWAP_64(x) | | ------------------ | | | | 46| 3.36M|#define ENDSWAP_64(x) (__builtin_bswap64 (x)) | | ------------------ ------------------ 348| 3.36M| bw->accum = val; /* unused top bits can contain garbage */ 349| 3.36M| } 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| 14.8M|} FLAC__cpu_info: 203| 18.5k|{ 204| 18.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| 18.5k| switch (info->type) { 215| 0| case FLAC__CPUINFO_TYPE_IA32: /* fallthrough */ ------------------ | Branch (215:2): [True: 0, False: 18.5k] ------------------ 216| 18.5k| case FLAC__CPUINFO_TYPE_X86_64: ------------------ | Branch (216:2): [True: 18.5k, False: 0] ------------------ 217| 18.5k| x86_cpu_info (info); 218| 18.5k| break; 219| 0| default: ------------------ | Branch (219:2): [True: 0, False: 18.5k] ------------------ 220| | info->use_asm = false; 221| 0| break; 222| 18.5k| } 223| 18.5k|} cpu.c:x86_cpu_info: 153| 18.5k|{ 154| 18.5k|#if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && FLAC__HAS_X86INTRIN && !defined FLAC__NO_ASM 155| 18.5k| FLAC__bool x86_osxsave = false; 156| 18.5k| FLAC__bool os_avx = false; 157| 18.5k| FLAC__uint32 flags_eax, flags_ebx, flags_ecx, flags_edx; 158| | 159| 18.5k| info->use_asm = true; /* we assume a minimum of 80386 */ 160| 18.5k| if (!cpu_have_cpuid()) ------------------ | Branch (160:6): [True: 0, False: 18.5k] ------------------ 161| 0| return; 162| | 163| 18.5k| cpuinfo_x86(0, &flags_eax, &flags_ebx, &flags_ecx, &flags_edx); 164| 18.5k| info->x86.intel = (flags_ebx == 0x756E6547 && flags_edx == 0x49656E69 && flags_ecx == 0x6C65746E) ? true : false; /* GenuineIntel */ ------------------ | Branch (164:21): [True: 0, False: 18.5k] | Branch (164:48): [True: 0, False: 0] | Branch (164:75): [True: 0, False: 0] ------------------ 165| 18.5k| cpuinfo_x86(1, &flags_eax, &flags_ebx, &flags_ecx, &flags_edx); 166| | 167| 18.5k| info->x86.cmov = (flags_edx & FLAC__CPUINFO_X86_CPUID_CMOV ) ? true : false; ------------------ | Branch (167:20): [True: 18.5k, False: 0] ------------------ 168| 18.5k| info->x86.mmx = (flags_edx & FLAC__CPUINFO_X86_CPUID_MMX ) ? true : false; ------------------ | Branch (168:20): [True: 18.5k, False: 0] ------------------ 169| 18.5k| info->x86.sse = (flags_edx & FLAC__CPUINFO_X86_CPUID_SSE ) ? true : false; ------------------ | Branch (169:20): [True: 18.5k, False: 0] ------------------ 170| 18.5k| info->x86.sse2 = (flags_edx & FLAC__CPUINFO_X86_CPUID_SSE2 ) ? true : false; ------------------ | Branch (170:20): [True: 18.5k, False: 0] ------------------ 171| 18.5k| info->x86.sse3 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSE3 ) ? true : false; ------------------ | Branch (171:20): [True: 18.5k, False: 0] ------------------ 172| 18.5k| info->x86.ssse3 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSSE3) ? true : false; ------------------ | Branch (172:20): [True: 18.5k, False: 0] ------------------ 173| 18.5k| info->x86.sse41 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSE41) ? true : false; ------------------ | Branch (173:20): [True: 18.5k, False: 0] ------------------ 174| 18.5k| info->x86.sse42 = (flags_ecx & FLAC__CPUINFO_X86_CPUID_SSE42) ? true : false; ------------------ | Branch (174:20): [True: 18.5k, False: 0] ------------------ 175| | 176| 18.5k| if (FLAC__AVX_SUPPORTED) { ------------------ | | 90| 18.5k| #define FLAC__AVX_SUPPORTED 1 | | ------------------ | | | Branch (90:33): [True: 18.5k, Folded] | | ------------------ ------------------ 177| 18.5k| x86_osxsave = (flags_ecx & FLAC__CPUINFO_X86_CPUID_OSXSAVE) ? true : false; ------------------ | Branch (177:21): [True: 18.5k, False: 0] ------------------ 178| 18.5k| info->x86.avx = (flags_ecx & FLAC__CPUINFO_X86_CPUID_AVX ) ? true : false; ------------------ | Branch (178:21): [True: 18.5k, False: 0] ------------------ 179| 18.5k| info->x86.fma = (flags_ecx & FLAC__CPUINFO_X86_CPUID_FMA ) ? true : false; ------------------ | Branch (179:21): [True: 18.5k, False: 0] ------------------ 180| 18.5k| cpuinfo_x86(7, &flags_eax, &flags_ebx, &flags_ecx, &flags_edx); 181| 18.5k| info->x86.avx2 = (flags_ebx & FLAC__CPUINFO_X86_CPUID_AVX2 ) ? true : false; ------------------ | Branch (181:21): [True: 18.5k, False: 0] ------------------ 182| 18.5k| info->x86.bmi2 = (flags_ebx & FLAC__CPUINFO_X86_CPUID_BMI2 ) ? true : false; ------------------ | Branch (182:21): [True: 18.5k, False: 0] ------------------ 183| 18.5k| } 184| | 185| | /* 186| | * now have to check for OS support of AVX instructions 187| | */ 188| 18.5k| if (FLAC__AVX_SUPPORTED && info->x86.avx && x86_osxsave && (cpu_xgetbv_x86() & 0x6) == 0x6) { ------------------ | | 90| 37.1k| #define FLAC__AVX_SUPPORTED 1 | | ------------------ | | | Branch (90:33): [True: 18.5k, Folded] | | ------------------ ------------------ | Branch (188:29): [True: 18.5k, False: 0] | Branch (188:46): [True: 18.5k, False: 0] | Branch (188:61): [True: 18.5k, False: 0] ------------------ 189| 18.5k| os_avx = true; 190| 18.5k| } 191| 18.5k| if (!os_avx) { ------------------ | Branch (191:6): [True: 0, False: 18.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| 18.5k|} cpu.c:cpu_have_cpuid: 89| 18.5k|{ 90| 18.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| 18.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| 18.5k|} cpu.c:cpuinfo_x86: 124| 55.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| 55.6k| __cpuid(ext, *eax, *ebx, *ecx, *edx); 141| 55.6k| if (*eax >= level) { ------------------ | Branch (141:6): [True: 55.6k, False: 0] ------------------ 142| 55.6k| __cpuid_count(level, 0, *eax, *ebx, *ecx, *edx); 143| 55.6k| return; 144| 55.6k| } 145| 0|#endif 146| 0| *eax = *ebx = *ecx = *edx = 0; 147| 0|} cpu.c:cpu_xgetbv_x86: 75| 18.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| 18.5k| __asm__ volatile (".byte 0x0f, 0x01, 0xd0" : "=a"(lo), "=d"(hi) : "c" (0)); 81| 18.5k| return lo; 82| |#else 83| | return 0; 84| |#endif 85| 18.5k|} FLAC__crc8: 367| 266k|{ 368| 266k| FLAC__uint8 crc = 0; 369| | 370| 2.38M| while(len--) ------------------ | Branch (370:8): [True: 2.12M, False: 266k] ------------------ 371| 2.12M| crc = FLAC__crc8_table[crc ^ *data++]; 372| | 373| 266k| return crc; 374| 266k|} FLAC__crc16: 377| 266k|{ 378| 266k| FLAC__uint16 crc = 0; 379| | 380| 10.5M| while(len >= 8){ ------------------ | Branch (380:8): [True: 10.2M, False: 266k] ------------------ 381| 10.2M| crc ^= data[0] << 8 | data[1]; 382| | 383| 10.2M| crc = FLAC__crc16_table[7][crc >> 8] ^ FLAC__crc16_table[6][crc & 0xFF] ^ 384| 10.2M| FLAC__crc16_table[5][data[2] ] ^ FLAC__crc16_table[4][data[3] ] ^ 385| 10.2M| FLAC__crc16_table[3][data[4] ] ^ FLAC__crc16_table[2][data[5] ] ^ 386| 10.2M| FLAC__crc16_table[1][data[6] ] ^ FLAC__crc16_table[0][data[7] ]; 387| | 388| 10.2M| data += 8; 389| 10.2M| len -= 8; 390| 10.2M| } 391| | 392| 1.30M| while(len--) ------------------ | Branch (392:8): [True: 1.04M, False: 266k] ------------------ 393| 1.04M| crc = (crc<<8) ^ FLAC__crc16_table[0][(crc>>8) ^ *data++]; 394| | 395| 266k| return crc; 396| 266k|} FLAC__crc16_update_words64: 423| 412k|{ 424| 11.8M| while (len--) { ------------------ | Branch (424:9): [True: 11.4M, False: 412k] ------------------ 425| 11.4M| crc ^= words[0] >> 48; 426| | 427| 11.4M| crc = FLAC__crc16_table[7][crc >> 8 ] ^ FLAC__crc16_table[6][crc & 0xFF ] ^ 428| 11.4M| FLAC__crc16_table[5][(words[0] >> 40) & 0xFF] ^ FLAC__crc16_table[4][(words[0] >> 32) & 0xFF] ^ 429| 11.4M| FLAC__crc16_table[3][(words[0] >> 24) & 0xFF] ^ FLAC__crc16_table[2][(words[0] >> 16) & 0xFF] ^ 430| 11.4M| FLAC__crc16_table[1][(words[0] >> 8) & 0xFF] ^ FLAC__crc16_table[0][ words[0] & 0xFF]; 431| | 432| 11.4M| words++; 433| 11.4M| } 434| | 435| 412k| return crc; 436| 412k|} FLAC__bitreader_read_rice_signed_block_bmi2: 1| 1.66M|{ 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.66M| uint32_t cwords, words, lsbs, msbs, x, y, limit; 6| 1.66M| uint32_t ucbits; /* keep track of the number of unconsumed bits in word */ 7| 1.66M| brword b; 8| 1.66M| int *val, *end; 9| | 10| 1.66M| FLAC__ASSERT(0 != br); ------------------ | | 38| 1.66M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.66M] | | ------------------ ------------------ 11| 1.66M| FLAC__ASSERT(0 != br->buffer); ------------------ | | 38| 1.66M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.66M] | | ------------------ ------------------ 12| | /* WATCHOUT: code does not work with <32bit words; we can make things much faster with this assertion */ 13| 1.66M| FLAC__ASSERT(FLAC__BITS_PER_WORD >= 32); ------------------ | | 38| 1.66M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 1.66M] | | ------------------ ------------------ 14| 1.66M| FLAC__ASSERT(parameter < 32); ------------------ | | 38| 1.66M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.66M] | | ------------------ ------------------ 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.66M| limit = UINT32_MAX >> parameter; /* Maximal msbs that can occur with residual bounded to int32_t */ 18| | 19| 1.66M| val = vals; 20| 1.66M| end = vals + nvals; 21| | 22| 1.66M| if(parameter == 0) { ------------------ | Branch (22:5): [True: 757k, False: 903k] ------------------ 23| 4.87M| while(val < end) { ------------------ | Branch (23:9): [True: 4.11M, False: 757k] ------------------ 24| | /* read the unary MSBs and end bit */ 25| 4.11M| if(!FLAC__bitreader_read_unary_unsigned(br, &msbs)) ------------------ | Branch (25:7): [True: 0, False: 4.11M] ------------------ 26| 0| return false; 27| | /* Checking limit here would be overzealous: coding UINT32_MAX 28| | * with parameter == 0 would take 4GiB */ 29| 4.11M| *val++ = (int)(msbs >> 1) ^ -(int)(msbs & 1); 30| 4.11M| } 31| | 32| 757k| return true; 33| 757k| } 34| | 35| 903k| FLAC__ASSERT(parameter > 0); ------------------ | | 38| 903k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 903k] | | ------------------ ------------------ 36| | 37| 903k| cwords = br->consumed_words; 38| 903k| words = br->words; 39| | 40| | /* if we've not consumed up to a partial tail word... */ 41| 903k| if(cwords >= words) { ------------------ | Branch (41:5): [True: 2.67k, False: 900k] ------------------ 42| 2.67k| x = 0; 43| 2.67k| goto process_tail; 44| 2.67k| } 45| | 46| 900k| ucbits = FLAC__BITS_PER_WORD - br->consumed_bits; ------------------ | | 73| 900k|#define FLAC__BITS_PER_WORD 64 ------------------ 47| 900k| b = br->buffer[cwords] << br->consumed_bits; /* keep unconsumed bits aligned to left */ 48| | 49| 17.4M| while(val < end) { ------------------ | Branch (49:8): [True: 16.5M, False: 903k] ------------------ 50| | /* read the unary MSBs and end bit */ 51| 16.5M| x = y = COUNT_ZERO_MSBS2(b); ------------------ | | 83| 16.5M|#define COUNT_ZERO_MSBS2(word) FLAC__clz2_uint64(word) ------------------ 52| 16.5M| if(x == FLAC__BITS_PER_WORD) { ------------------ | | 73| 16.5M|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (52:6): [True: 485k, False: 16.0M] ------------------ 53| 485k| x = ucbits; 54| 591k| do { 55| | /* didn't find stop bit yet, have to keep going... */ 56| 591k| cwords++; 57| 591k| if (cwords >= words) ------------------ | Branch (57:9): [True: 3.89k, False: 587k] ------------------ 58| 3.89k| goto incomplete_msbs; 59| 587k| b = br->buffer[cwords]; 60| 587k| y = COUNT_ZERO_MSBS2(b); ------------------ | | 83| 587k|#define COUNT_ZERO_MSBS2(word) FLAC__clz2_uint64(word) ------------------ 61| 587k| x += y; 62| 587k| } while(y == FLAC__BITS_PER_WORD); ------------------ | | 73| 587k|#define FLAC__BITS_PER_WORD 64 ------------------ | Branch (62:12): [True: 105k, False: 482k] ------------------ 63| 485k| } 64| 16.5M| b <<= y; 65| 16.5M| b <<= 1; /* account for stop bit */ 66| 16.5M| ucbits = (ucbits - x - 1) % FLAC__BITS_PER_WORD; ------------------ | | 73| 16.5M|#define FLAC__BITS_PER_WORD 64 ------------------ 67| 16.5M| msbs = x; 68| | 69| 16.5M| if(x > limit) ------------------ | Branch (69:6): [True: 0, False: 16.5M] ------------------ 70| 0| return false; 71| | 72| | /* read the binary LSBs */ 73| 16.5M| x = (FLAC__uint32)(b >> (FLAC__BITS_PER_WORD - parameter)); /* parameter < 32, so we can cast to 32-bit uint32_t */ ------------------ | | 73| 16.5M|#define FLAC__BITS_PER_WORD 64 ------------------ 74| 16.5M| if(parameter <= ucbits) { ------------------ | Branch (74:6): [True: 10.3M, False: 6.18M] ------------------ 75| 10.3M| ucbits -= parameter; 76| 10.3M| b <<= parameter; 77| 10.3M| } else { 78| | /* there are still bits left to read, they will all be in the next word */ 79| 6.18M| cwords++; 80| 6.18M| if (cwords >= words) ------------------ | Branch (80:8): [True: 36.4k, False: 6.14M] ------------------ 81| 36.4k| goto incomplete_lsbs; 82| 6.14M| b = br->buffer[cwords]; 83| 6.14M| ucbits += FLAC__BITS_PER_WORD - parameter; ------------------ | | 73| 6.14M|#define FLAC__BITS_PER_WORD 64 ------------------ 84| 6.14M| x |= (FLAC__uint32)(b >> ucbits); 85| 6.14M| b <<= FLAC__BITS_PER_WORD - ucbits; ------------------ | | 73| 6.14M|#define FLAC__BITS_PER_WORD 64 ------------------ 86| 6.14M| } 87| 16.5M| lsbs = x; 88| | 89| | /* compose the value */ 90| 16.5M| x = (msbs << parameter) | lsbs; 91| 16.5M| *val++ = (int)(x >> 1) ^ -(int)(x & 1); 92| | 93| 16.5M| continue; 94| | 95| | /* at this point we've eaten up all the whole words */ 96| 2.67k|process_tail: 97| 20.5k| do { 98| 20.5k| if(0) { ------------------ | Branch (98:7): [Folded, False: 20.5k] ------------------ 99| 3.89k|incomplete_msbs: 100| 3.89k| br->consumed_bits = 0; 101| 3.89k| br->consumed_words = cwords; 102| 3.89k| } 103| | 104| | /* read the unary MSBs and end bit */ 105| 24.4k| if(!FLAC__bitreader_read_unary_unsigned(br, &msbs)) ------------------ | Branch (105:7): [True: 0, False: 24.4k] ------------------ 106| 0| return false; 107| 24.4k| msbs += x; 108| 24.4k| x = ucbits = 0; 109| | 110| 24.4k| if(0) { ------------------ | Branch (110:7): [Folded, False: 24.4k] ------------------ 111| 36.4k|incomplete_lsbs: 112| 36.4k| br->consumed_bits = 0; 113| 36.4k| br->consumed_words = cwords; 114| 36.4k| } 115| | 116| | /* read the binary LSBs */ 117| 60.8k| if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter - ucbits)) ------------------ | Branch (117:7): [True: 0, False: 60.8k] ------------------ 118| 0| return false; 119| 60.8k| lsbs = x | lsbs; 120| | 121| | /* compose the value */ 122| 60.8k| x = (msbs << parameter) | lsbs; 123| 60.8k| *val++ = (int)(x >> 1) ^ -(int)(x & 1); 124| 60.8k| x = 0; 125| | 126| 60.8k| cwords = br->consumed_words; 127| 60.8k| words = br->words; 128| 60.8k| ucbits = FLAC__BITS_PER_WORD - br->consumed_bits; ------------------ | | 73| 60.8k|#define FLAC__BITS_PER_WORD 64 ------------------ 129| 60.8k| b = cwords < br->capacity ? br->buffer[cwords] << br->consumed_bits : 0; ------------------ | Branch (129:8): [True: 60.8k, False: 0] ------------------ 130| 60.8k| } while(cwords >= words && val < end); ------------------ | Branch (130:11): [True: 55.4k, False: 5.35k] | Branch (130:30): [True: 17.8k, False: 37.6k] ------------------ 131| 2.67k| } 132| | 133| 903k| if(ucbits == 0 && cwords < words) { ------------------ | Branch (133:5): [True: 13.0k, False: 890k] | Branch (133:20): [True: 13.0k, False: 0] ------------------ 134| | /* don't leave the head word with no unconsumed bits */ 135| 13.0k| cwords++; 136| 13.0k| ucbits = FLAC__BITS_PER_WORD; ------------------ | | 73| 13.0k|#define FLAC__BITS_PER_WORD 64 ------------------ 137| 13.0k| } 138| | 139| 903k| br->consumed_bits = FLAC__BITS_PER_WORD - ucbits; ------------------ | | 73| 903k|#define FLAC__BITS_PER_WORD 64 ------------------ 140| 903k| br->consumed_words = cwords; 141| | 142| | return true; 143| 900k|} FLAC__fixed_compute_best_predictor_limit_residual_33bit: 428| 12.9k|{ 429| 12.9k| 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| 12.9k| FLAC__uint64 error_0, error_1, error_2, error_3, error_4; 431| 12.9k| 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| 12.9k| uint32_t order = 0; 433| 12.9k| int i; 434| | 435| 3.75M| for(i = -4; i < (int)data_len; i++) { ------------------ | Branch (435:14): [True: 3.74M, False: 12.9k] ------------------ 436| 3.74M| error_0 = local_abs64(data[i]); ------------------ | | 53| 3.74M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (53:36): [True: 352k, False: 3.39M] | | ------------------ ------------------ 437| 3.74M| error_1 = (i > -4) ? local_abs64(data[i] - data[i-1]) : 0 ; ------------------ | | 53| 3.73M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (53:36): [True: 505k, False: 3.22M] | | ------------------ ------------------ | Branch (437:13): [True: 3.73M, False: 12.9k] ------------------ 438| 3.74M| error_2 = (i > -3) ? local_abs64(data[i] - 2 * data[i-1] + data[i-2]) : 0; ------------------ | | 53| 3.71M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (53:36): [True: 544k, False: 3.17M] | | ------------------ ------------------ | Branch (438:13): [True: 3.71M, False: 25.8k] ------------------ 439| 3.74M| error_3 = (i > -2) ? local_abs64(data[i] - 3 * data[i-1] + 3 * data[i-2] - data[i-3]) : 0; ------------------ | | 53| 3.70M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (53:36): [True: 535k, False: 3.17M] | | ------------------ ------------------ | Branch (439:13): [True: 3.70M, False: 38.7k] ------------------ 440| 3.74M| 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.69M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (53:36): [True: 516k, False: 3.17M] | | ------------------ ------------------ | Branch (440:13): [True: 3.69M, False: 51.7k] ------------------ 441| | 442| 3.74M| total_error_0 += error_0; 443| 3.74M| total_error_1 += error_1; 444| 3.74M| total_error_2 += error_2; 445| 3.74M| total_error_3 += error_3; 446| 3.74M| total_error_4 += error_4; 447| | 448| | /* residual must not be INT32_MIN because abs(INT32_MIN) is undefined */ 449| 3.74M| if(error_0 > INT32_MAX) ------------------ | Branch (449:6): [True: 72.2k, False: 3.67M] ------------------ 450| 72.2k| order_0_is_valid = false; 451| 3.74M| if(error_1 > INT32_MAX) ------------------ | Branch (451:6): [True: 83.7k, False: 3.66M] ------------------ 452| 83.7k| order_1_is_valid = false; 453| 3.74M| if(error_2 > INT32_MAX) ------------------ | Branch (453:6): [True: 281k, False: 3.46M] ------------------ 454| 281k| order_2_is_valid = false; 455| 3.74M| if(error_3 > INT32_MAX) ------------------ | Branch (455:6): [True: 455k, False: 3.28M] ------------------ 456| 455k| order_3_is_valid = false; 457| 3.74M| if(error_4 > INT32_MAX) ------------------ | Branch (457:6): [True: 613k, False: 3.13M] ------------------ 458| 613k| order_4_is_valid = false; 459| 3.74M| } 460| | 461| 12.9k| CHECK_ORDER_IS_VALID(0); ------------------ | | 356| 12.9k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 357| 25.8k|if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (357:4): [True: 8.61k, False: 4.31k] | | | Branch (357:38): [True: 8.61k, False: 0] | | ------------------ | | 358| 8.61k| order = macro_order; \ | | 359| 8.61k| smallest_error = total_error_##macro_order ; \ | | 360| 8.61k| 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: 8.61k, False: 0] | | ------------------ | | 361| 8.61k|} \ | | 362| 12.9k|else \ | | 363| 12.9k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 462| 12.9k| CHECK_ORDER_IS_VALID(1); ------------------ | | 356| 12.9k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 357| 25.8k|if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (357:4): [True: 8.57k, False: 4.35k] | | | Branch (357:38): [True: 3.45k, False: 5.12k] | | ------------------ | | 358| 3.45k| order = macro_order; \ | | 359| 3.45k| smallest_error = total_error_##macro_order ; \ | | 360| 3.45k| 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.63k, False: 822] | | ------------------ | | 361| 3.45k|} \ | | 362| 12.9k|else \ | | 363| 12.9k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 463| 12.9k| CHECK_ORDER_IS_VALID(2); ------------------ | | 356| 12.9k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 357| 25.8k|if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (357:4): [True: 6.56k, False: 6.36k] | | | Branch (357:38): [True: 1.52k, False: 5.04k] | | ------------------ | | 358| 1.52k| order = macro_order; \ | | 359| 1.52k| smallest_error = total_error_##macro_order ; \ | | 360| 1.52k| 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.52k, False: 0] | | ------------------ | | 361| 1.52k|} \ | | 362| 12.9k|else \ | | 363| 12.9k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 464| 12.9k| CHECK_ORDER_IS_VALID(3); ------------------ | | 356| 12.9k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 357| 25.8k|if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (357:4): [True: 5.45k, False: 7.47k] | | | Branch (357:38): [True: 1.36k, False: 4.09k] | | ------------------ | | 358| 1.36k| order = macro_order; \ | | 359| 1.36k| smallest_error = total_error_##macro_order ; \ | | 360| 1.36k| 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.36k, False: 1] | | ------------------ | | 361| 1.36k|} \ | | 362| 12.9k|else \ | | 363| 12.9k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 465| 12.9k| CHECK_ORDER_IS_VALID(4); ------------------ | | 356| 12.9k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 357| 25.8k|if(order_##macro_order##_is_valid && total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (357:4): [True: 4.61k, False: 8.31k] | | | Branch (357:38): [True: 1.11k, False: 3.50k] | | ------------------ | | 358| 1.11k| order = macro_order; \ | | 359| 1.11k| smallest_error = total_error_##macro_order ; \ | | 360| 1.11k| 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.11k, False: 1] | | ------------------ | | 361| 1.11k|} \ | | 362| 12.9k|else \ | | 363| 12.9k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 466| | 467| 12.9k| return order; 468| 12.9k|} FLAC__fixed_compute_residual: 471| 460k|{ 472| 460k| const int idata_len = (int)data_len; 473| 460k| int i; 474| | 475| 460k| switch(order) { 476| 228k| case 0: ------------------ | Branch (476:3): [True: 228k, False: 231k] ------------------ 477| 228k| FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0])); ------------------ | | 38| 228k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 228k] | | ------------------ ------------------ 478| 228k| memcpy(residual, data, sizeof(residual[0])*data_len); 479| 228k| break; 480| 63.4k| case 1: ------------------ | Branch (480:3): [True: 63.4k, False: 397k] ------------------ 481| 6.42M| for(i = 0; i < idata_len; i++) ------------------ | Branch (481:15): [True: 6.36M, False: 63.4k] ------------------ 482| 6.36M| residual[i] = data[i] - data[i-1]; 483| 63.4k| break; 484| 57.6k| case 2: ------------------ | Branch (484:3): [True: 57.6k, False: 402k] ------------------ 485| 4.80M| for(i = 0; i < idata_len; i++) ------------------ | Branch (485:15): [True: 4.74M, False: 57.6k] ------------------ 486| 4.74M| residual[i] = data[i] - 2*data[i-1] + data[i-2]; 487| 57.6k| break; 488| 56.4k| case 3: ------------------ | Branch (488:3): [True: 56.4k, False: 404k] ------------------ 489| 4.71M| for(i = 0; i < idata_len; i++) ------------------ | Branch (489:15): [True: 4.65M, False: 56.4k] ------------------ 490| 4.65M| residual[i] = data[i] - 3*data[i-1] + 3*data[i-2] - data[i-3]; 491| 56.4k| break; 492| 54.4k| case 4: ------------------ | Branch (492:3): [True: 54.4k, False: 406k] ------------------ 493| 4.62M| for(i = 0; i < idata_len; i++) ------------------ | Branch (493:15): [True: 4.57M, False: 54.4k] ------------------ 494| 4.57M| residual[i] = data[i] - 4*data[i-1] + 6*data[i-2] - 4*data[i-3] + data[i-4]; 495| 54.4k| break; 496| 0| default: ------------------ | Branch (496:3): [True: 0, False: 460k] ------------------ 497| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 498| 460k| } 499| 460k|} FLAC__fixed_compute_residual_wide: 502| 364k|{ 503| 364k| const int idata_len = (int)data_len; 504| 364k| int i; 505| | 506| 364k| switch(order) { 507| 0| case 0: ------------------ | Branch (507:3): [True: 0, False: 364k] ------------------ 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| 147k| case 1: ------------------ | Branch (511:3): [True: 147k, False: 216k] ------------------ 512| 8.86M| for(i = 0; i < idata_len; i++) ------------------ | Branch (512:15): [True: 8.71M, False: 147k] ------------------ 513| 8.71M| residual[i] = (FLAC__int64)data[i] - data[i-1]; 514| 147k| break; 515| 82.6k| case 2: ------------------ | Branch (515:3): [True: 82.6k, False: 281k] ------------------ 516| 2.76M| for(i = 0; i < idata_len; i++) ------------------ | Branch (516:15): [True: 2.67M, False: 82.6k] ------------------ 517| 2.67M| residual[i] = (FLAC__int64)data[i] - 2*(FLAC__int64)data[i-1] + data[i-2]; 518| 82.6k| break; 519| 71.7k| case 3: ------------------ | Branch (519:3): [True: 71.7k, False: 292k] ------------------ 520| 2.14M| for(i = 0; i < idata_len; i++) ------------------ | Branch (520:15): [True: 2.07M, False: 71.7k] ------------------ 521| 2.07M| residual[i] = (FLAC__int64)data[i] - 3*(FLAC__int64)data[i-1] + 3*(FLAC__int64)data[i-2] - data[i-3]; 522| 71.7k| break; 523| 62.8k| case 4: ------------------ | Branch (523:3): [True: 62.8k, False: 301k] ------------------ 524| 1.39M| for(i = 0; i < idata_len; i++) ------------------ | Branch (524:15): [True: 1.32M, False: 62.8k] ------------------ 525| 1.32M| 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| 62.8k| break; 527| 0| default: ------------------ | Branch (527:3): [True: 0, False: 364k] ------------------ 528| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 529| 364k| } 530| 364k|} FLAC__fixed_compute_residual_wide_33bit: 533| 13.1k|{ 534| 13.1k| const int idata_len = (int)data_len; 535| 13.1k| int i; 536| | 537| 13.1k| switch(order) { 538| 6.99k| case 0: ------------------ | Branch (538:3): [True: 6.99k, False: 6.10k] ------------------ 539| 576k| for(i = 0; i < idata_len; i++) ------------------ | Branch (539:15): [True: 569k, False: 6.99k] ------------------ 540| 569k| residual[i] = data[i]; 541| 6.99k| break; 542| 2.33k| case 1: ------------------ | Branch (542:3): [True: 2.33k, False: 10.7k] ------------------ 543| 303k| for(i = 0; i < idata_len; i++) ------------------ | Branch (543:15): [True: 301k, False: 2.33k] ------------------ 544| 301k| residual[i] = data[i] - data[i-1]; 545| 2.33k| break; 546| 1.46k| case 2: ------------------ | Branch (546:3): [True: 1.46k, False: 11.6k] ------------------ 547| 163k| for(i = 0; i < idata_len; i++) ------------------ | Branch (547:15): [True: 162k, False: 1.46k] ------------------ 548| 162k| residual[i] = data[i] - 2*data[i-1] + data[i-2]; 549| 1.46k| break; 550| 1.20k| case 3: ------------------ | Branch (550:3): [True: 1.20k, False: 11.9k] ------------------ 551| 22.6k| for(i = 0; i < idata_len; i++) ------------------ | Branch (551:15): [True: 21.4k, False: 1.20k] ------------------ 552| 21.4k| residual[i] = data[i] - 3*data[i-1] + 3*data[i-2] - data[i-3]; 553| 1.20k| break; 554| 1.11k| case 4: ------------------ | Branch (554:3): [True: 1.11k, False: 11.9k] ------------------ 555| 18.9k| for(i = 0; i < idata_len; i++) ------------------ | Branch (555:15): [True: 17.8k, False: 1.11k] ------------------ 556| 17.8k| residual[i] = data[i] - 4*data[i-1] + 6*data[i-2] - 4*data[i-3] + data[i-4]; 557| 1.11k| break; 558| 0| default: ------------------ | Branch (558:3): [True: 0, False: 13.1k] ------------------ 559| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 560| 13.1k| } 561| 13.1k|} FLAC__fixed_restore_signal: 572| 68.1k|{ 573| 68.1k| int i, idata_len = (int)data_len; 574| | 575| 68.1k| switch(order) { 576| 45.5k| case 0: ------------------ | Branch (576:3): [True: 45.5k, False: 22.5k] ------------------ 577| 45.5k| FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0])); ------------------ | | 38| 45.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 45.5k] | | ------------------ ------------------ 578| 45.5k| memcpy(data, residual, sizeof(residual[0])*data_len); 579| 45.5k| break; 580| 18.5k| case 1: ------------------ | Branch (580:3): [True: 18.5k, False: 49.5k] ------------------ 581| 1.75M| for(i = 0; i < idata_len; i++) ------------------ | Branch (581:15): [True: 1.73M, False: 18.5k] ------------------ 582| 1.73M| data[i] = residual[i] + data[i-1]; 583| 18.5k| break; 584| 1.61k| case 2: ------------------ | Branch (584:3): [True: 1.61k, False: 66.5k] ------------------ 585| 43.1k| for(i = 0; i < idata_len; i++) ------------------ | Branch (585:15): [True: 41.5k, False: 1.61k] ------------------ 586| 41.5k| data[i] = residual[i] + 2*data[i-1] - data[i-2]; 587| 1.61k| break; 588| 309| case 3: ------------------ | Branch (588:3): [True: 309, False: 67.8k] ------------------ 589| 26.2k| for(i = 0; i < idata_len; i++) ------------------ | Branch (589:15): [True: 25.9k, False: 309] ------------------ 590| 25.9k| data[i] = residual[i] + 3*data[i-1] - 3*data[i-2] + data[i-3]; 591| 309| break; 592| 2.07k| case 4: ------------------ | Branch (592:3): [True: 2.07k, False: 66.0k] ------------------ 593| 75.9k| for(i = 0; i < idata_len; i++) ------------------ | Branch (593:15): [True: 73.8k, False: 2.07k] ------------------ 594| 73.8k| data[i] = residual[i] + 4*data[i-1] - 6*data[i-2] + 4*data[i-3] - data[i-4]; 595| 2.07k| break; 596| 0| default: ------------------ | Branch (596:3): [True: 0, False: 68.1k] ------------------ 597| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 598| 68.1k| } 599| 68.1k|} FLAC__fixed_restore_signal_wide: 602| 60.4k|{ 603| 60.4k| int i, idata_len = (int)data_len; 604| | 605| 60.4k| switch(order) { 606| 0| case 0: ------------------ | Branch (606:3): [True: 0, False: 60.4k] ------------------ 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| 58.6k| case 1: ------------------ | Branch (610:3): [True: 58.6k, False: 1.79k] ------------------ 611| 4.13M| for(i = 0; i < idata_len; i++) ------------------ | Branch (611:15): [True: 4.08M, False: 58.6k] ------------------ 612| 4.08M| data[i] = (FLAC__int64)residual[i] + (FLAC__int64)data[i-1]; 613| 58.6k| break; 614| 875| case 2: ------------------ | Branch (614:3): [True: 875, False: 59.5k] ------------------ 615| 174k| for(i = 0; i < idata_len; i++) ------------------ | Branch (615:15): [True: 173k, False: 875] ------------------ 616| 173k| data[i] = (FLAC__int64)residual[i] + 2*(FLAC__int64)data[i-1] - (FLAC__int64)data[i-2]; 617| 875| break; 618| 545| case 3: ------------------ | Branch (618:3): [True: 545, False: 59.9k] ------------------ 619| 424k| for(i = 0; i < idata_len; i++) ------------------ | Branch (619:15): [True: 424k, False: 545] ------------------ 620| 424k| data[i] = (FLAC__int64)residual[i] + 3*(FLAC__int64)data[i-1] - 3*(FLAC__int64)data[i-2] + (FLAC__int64)data[i-3]; 621| 545| break; 622| 373| case 4: ------------------ | Branch (622:3): [True: 373, False: 60.0k] ------------------ 623| 51.9k| for(i = 0; i < idata_len; i++) ------------------ | Branch (623:15): [True: 51.5k, False: 373] ------------------ 624| 51.5k| 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| 373| break; 626| 0| default: ------------------ | Branch (626:3): [True: 0, False: 60.4k] ------------------ 627| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 628| 60.4k| } 629| 60.4k|} FLAC__fixed_restore_signal_wide_33bit: 640| 5.23k|{ 641| 5.23k| int i, idata_len = (int)data_len; 642| | 643| 5.23k| switch(order) { 644| 3.50k| case 0: ------------------ | Branch (644:3): [True: 3.50k, False: 1.73k] ------------------ 645| 227k| for(i = 0; i < idata_len; i++) ------------------ | Branch (645:15): [True: 223k, False: 3.50k] ------------------ 646| 223k| data[i] = residual[i]; 647| 3.50k| break; 648| 931| case 1: ------------------ | Branch (648:3): [True: 931, False: 4.30k] ------------------ 649| 17.3k| for(i = 0; i < idata_len; i++) ------------------ | Branch (649:15): [True: 16.4k, False: 931] ------------------ 650| 16.4k| data[i] = (FLAC__int64)residual[i] + data[i-1]; 651| 931| break; 652| 476| case 2: ------------------ | Branch (652:3): [True: 476, False: 4.76k] ------------------ 653| 57.5k| for(i = 0; i < idata_len; i++) ------------------ | Branch (653:15): [True: 57.0k, False: 476] ------------------ 654| 57.0k| data[i] = (FLAC__int64)residual[i] + 2*data[i-1] - data[i-2]; 655| 476| break; 656| 158| case 3: ------------------ | Branch (656:3): [True: 158, False: 5.07k] ------------------ 657| 3.17k| for(i = 0; i < idata_len; i++) ------------------ | Branch (657:15): [True: 3.01k, False: 158] ------------------ 658| 3.01k| data[i] = (FLAC__int64)residual[i] + 3*data[i-1] - 3*data[i-2] + data[i-3]; 659| 158| break; 660| 166| case 4: ------------------ | Branch (660:3): [True: 166, False: 5.07k] ------------------ 661| 7.01k| for(i = 0; i < idata_len; i++) ------------------ | Branch (661:15): [True: 6.84k, False: 166] ------------------ 662| 6.84k| data[i] = (FLAC__int64)residual[i] + 4*data[i-1] - 6*data[i-2] + 4*data[i-3] - data[i-4]; 663| 166| break; 664| 0| default: ------------------ | Branch (664:3): [True: 0, False: 5.23k] ------------------ 665| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 666| 5.23k| } 667| 5.23k|} FLAC__fixed_compute_best_predictor_wide_intrin_avx2: 58| 26.5k|{ 59| 26.5k| FLAC__uint64 total_error_0, total_error_1, total_error_2, total_error_3, total_error_4; 60| 26.5k| FLAC__int32 i, data_len_int; 61| 26.5k| uint32_t order; 62| 26.5k| __m256i total_err0, total_err1, total_err2, total_err3, total_err4; 63| 26.5k| __m256i prev_err0, prev_err1, prev_err2, prev_err3; 64| 26.5k| __m256i tempA, tempB, bitmask; 65| 26.5k| FLAC__int64 data_scalar[4]; 66| 26.5k| FLAC__int64 prev_err0_scalar[4]; 67| 26.5k| FLAC__int64 prev_err1_scalar[4]; 68| 26.5k| FLAC__int64 prev_err2_scalar[4]; 69| 26.5k| FLAC__int64 prev_err3_scalar[4]; 70| 26.5k| total_err0 = _mm256_setzero_si256(); 71| 26.5k| total_err1 = _mm256_setzero_si256(); 72| 26.5k| total_err2 = _mm256_setzero_si256(); 73| 26.5k| total_err3 = _mm256_setzero_si256(); 74| 26.5k| total_err4 = _mm256_setzero_si256(); 75| 26.5k| data_len_int = data_len; 76| | 77| 132k| for(i = 0; i < 4; i++){ ------------------ | Branch (77:13): [True: 106k, False: 26.5k] ------------------ 78| 106k| prev_err0_scalar[i] = data[-1+i*(data_len_int/4)]; 79| 106k| prev_err1_scalar[i] = data[-1+i*(data_len_int/4)] - data[-2+i*(data_len_int/4)]; 80| 106k| prev_err2_scalar[i] = prev_err1_scalar[i] - (data[-2+i*(data_len_int/4)] - data[-3+i*(data_len_int/4)]); 81| 106k| 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| 106k| } 83| 26.5k| prev_err0 = _mm256_loadu_si256((const __m256i*)(void*)prev_err0_scalar); 84| 26.5k| prev_err1 = _mm256_loadu_si256((const __m256i*)(void*)prev_err1_scalar); 85| 26.5k| prev_err2 = _mm256_loadu_si256((const __m256i*)(void*)prev_err2_scalar); 86| 26.5k| prev_err3 = _mm256_loadu_si256((const __m256i*)(void*)prev_err3_scalar); 87| 981k| for(i = 0; i < data_len_int / 4; i++){ ------------------ | Branch (87:13): [True: 955k, False: 26.5k] ------------------ 88| 955k| data_scalar[0] = data[i]; 89| 955k| data_scalar[1] = data[i+data_len/4]; 90| 955k| data_scalar[2] = data[i+2*data_len/4]; 91| 955k| data_scalar[3] = data[i+3*data_len/4]; 92| 955k| tempA = _mm256_loadu_si256((const __m256i*)(void*)data_scalar); 93| | /* Next three intrinsics calculate tempB as abs of tempA */ 94| 955k| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 95| 955k| tempB = _mm256_xor_si256(tempA, bitmask); 96| 955k| tempB = _mm256_sub_epi64(tempB, bitmask); 97| 955k| total_err0 = _mm256_add_epi64(total_err0,tempB); 98| 955k| tempB = _mm256_sub_epi64(tempA,prev_err0); 99| 955k| prev_err0 = tempA; 100| | /* Next three intrinsics calculate tempA as abs of tempB */ 101| 955k| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempB); 102| 955k| tempA = _mm256_xor_si256(tempB, bitmask); 103| 955k| tempA = _mm256_sub_epi64(tempA, bitmask); 104| 955k| total_err1 = _mm256_add_epi64(total_err1,tempA); 105| 955k| tempA = _mm256_sub_epi64(tempB,prev_err1); 106| 955k| prev_err1 = tempB; 107| | /* Next three intrinsics calculate tempB as abs of tempA */ 108| 955k| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 109| 955k| tempB = _mm256_xor_si256(tempA, bitmask); 110| 955k| tempB = _mm256_sub_epi64(tempB, bitmask); 111| 955k| total_err2 = _mm256_add_epi64(total_err2,tempB); 112| 955k| tempB = _mm256_sub_epi64(tempA,prev_err2); 113| 955k| prev_err2 = tempA; 114| | /* Next three intrinsics calculate tempA as abs of tempB */ 115| 955k| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempB); 116| 955k| tempA = _mm256_xor_si256(tempB, bitmask); 117| 955k| tempA = _mm256_sub_epi64(tempA, bitmask); 118| 955k| total_err3 = _mm256_add_epi64(total_err3,tempA); 119| 955k| tempA = _mm256_sub_epi64(tempB,prev_err3); 120| 955k| prev_err3 = tempB; 121| | /* Next three intrinsics calculate tempB as abs of tempA */ 122| 955k| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 123| 955k| tempB = _mm256_xor_si256(tempA, bitmask); 124| 955k| tempB = _mm256_sub_epi64(tempB, bitmask); 125| 955k| total_err4 = _mm256_add_epi64(total_err4,tempB); 126| 955k| } 127| 26.5k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err0); 128| 26.5k| total_error_0 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 129| 26.5k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err1); 130| 26.5k| total_error_1 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 131| 26.5k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err2); 132| 26.5k| total_error_2 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 133| 26.5k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err3); 134| 26.5k| total_error_3 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 135| 26.5k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err4); 136| 26.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| 26.5k| if(total_error_0 <= flac_min(flac_min(flac_min(total_error_1, total_error_2), total_error_3), total_error_4)) ------------------ | | 56| 26.5k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (141:5): [True: 9.86k, False: 16.6k] | Branch (141:22): [True: 22.1k, False: 4.39k] | Branch (141:22): [True: 22.0k, False: 1.27k] | Branch (141:22): [True: 23.3k, False: 3.21k] | Branch (141:22): [True: 22.0k, False: 1.80k] | Branch (141:22): [True: 21.9k, False: 1.18k] | Branch (141:22): [True: 23.1k, False: 707] | Branch (141:22): [True: 23.8k, False: 2.70k] ------------------ 142| 9.86k| order = 0; 143| 16.6k| else if(total_error_1 <= flac_min(flac_min(total_error_2, total_error_3), total_error_4)) ------------------ | | 56| 16.6k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (143:10): [True: 15.4k, False: 1.18k] | Branch (143:27): [True: 14.0k, False: 2.61k] | Branch (143:27): [True: 13.9k, False: 974] | Branch (143:27): [True: 14.8k, False: 1.80k] ------------------ 144| 15.4k| order = 1; 145| 1.18k| else if(total_error_2 <= flac_min(total_error_3, total_error_4)) ------------------ | | 56| 1.18k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (145:10): [True: 434, False: 755] | Branch (145:27): [True: 897, False: 292] ------------------ 146| 434| order = 2; 147| 755| else if(total_error_3 <= total_error_4) ------------------ | Branch (147:10): [True: 463, False: 292] ------------------ 148| 463| order = 3; 149| 292| else 150| 292| 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| 26.5k| FLAC__ASSERT(data_len > 0 || total_error_0 == 0); ------------------ | | 38| 26.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 26.5k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 156| 26.5k| FLAC__ASSERT(data_len > 0 || total_error_1 == 0); ------------------ | | 38| 26.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 26.5k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 157| 26.5k| FLAC__ASSERT(data_len > 0 || total_error_2 == 0); ------------------ | | 38| 26.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 26.5k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 158| 26.5k| FLAC__ASSERT(data_len > 0 || total_error_3 == 0); ------------------ | | 38| 26.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 26.5k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 159| 26.5k| FLAC__ASSERT(data_len > 0 || total_error_4 == 0); ------------------ | | 38| 26.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 26.5k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 160| | 161| 26.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: 25.4k, False: 1.05k] ------------------ 162| 26.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: 23.8k, False: 2.65k] ------------------ 163| 26.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.0k, False: 2.53k] ------------------ 164| 26.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: 24.3k, False: 2.21k] ------------------ 165| 26.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: 24.5k, False: 1.99k] ------------------ 166| | 167| 26.5k| return order; 168| 26.5k|} FLAC__fixed_compute_best_predictor_limit_residual_intrin_avx2: 188| 321k|{ 189| 321k| 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| 321k| FLAC__uint64 shadow_error_0 = 0, shadow_error_1 = 0, shadow_error_2 = 0, shadow_error_3 = 0, shadow_error_4 = 0; 191| 321k| FLAC__uint64 error_0, error_1, error_2, error_3, error_4; 192| 321k| FLAC__int32 i, data_len_int; 193| 321k| uint32_t order = 0; 194| 321k| __m256i total_err0, total_err1, total_err2, total_err3, total_err4; 195| 321k| __m256i shadow_err0, shadow_err1, shadow_err2, shadow_err3, shadow_err4; 196| 321k| __m256i prev_err0, prev_err1, prev_err2, prev_err3; 197| 321k| __m256i tempA, tempB, bitmask; 198| 321k| FLAC__int64 data_scalar[4]; 199| 321k| FLAC__int64 prev_err0_scalar[4]; 200| 321k| FLAC__int64 prev_err1_scalar[4]; 201| 321k| FLAC__int64 prev_err2_scalar[4]; 202| 321k| FLAC__int64 prev_err3_scalar[4]; 203| 321k| total_err0 = _mm256_setzero_si256(); 204| 321k| total_err1 = _mm256_setzero_si256(); 205| 321k| total_err2 = _mm256_setzero_si256(); 206| 321k| total_err3 = _mm256_setzero_si256(); 207| 321k| total_err4 = _mm256_setzero_si256(); 208| 321k| shadow_err0 = _mm256_setzero_si256(); 209| 321k| shadow_err1 = _mm256_setzero_si256(); 210| 321k| shadow_err2 = _mm256_setzero_si256(); 211| 321k| shadow_err3 = _mm256_setzero_si256(); 212| 321k| shadow_err4 = _mm256_setzero_si256(); 213| 321k| data_len_int = data_len; 214| | 215| | /* First take care of preceding samples */ 216| 1.60M| for(i = -4; i < 0; i++) { ------------------ | Branch (216:14): [True: 1.28M, False: 321k] ------------------ 217| 1.28M| error_0 = local_abs64((FLAC__int64)data[i]); ------------------ | | 173| 1.28M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 639k, False: 645k] | | ------------------ ------------------ 218| 1.28M| error_1 = (i > -4) ? local_abs64((FLAC__int64)data[i] - data[i-1]) : 0 ; ------------------ | | 173| 963k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 157k, False: 805k] | | ------------------ ------------------ | Branch (218:13): [True: 963k, False: 321k] ------------------ 219| 1.28M| error_2 = (i > -3) ? local_abs64((FLAC__int64)data[i] - 2 * (FLAC__int64)data[i-1] + data[i-2]) : 0; ------------------ | | 173| 642k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 116k, False: 526k] | | ------------------ ------------------ | Branch (219:13): [True: 642k, False: 642k] ------------------ 220| 1.28M| 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| 321k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 62.3k, False: 258k] | | ------------------ ------------------ | Branch (220:13): [True: 321k, False: 963k] ------------------ 221| | 222| 1.28M| total_error_0 += error_0; 223| 1.28M| total_error_1 += error_1; 224| 1.28M| total_error_2 += error_2; 225| 1.28M| total_error_3 += error_3; 226| | 227| 1.28M| shadow_error_0 |= error_0; 228| 1.28M| shadow_error_1 |= error_1; 229| 1.28M| shadow_error_2 |= error_2; 230| 1.28M| shadow_error_3 |= error_3; 231| 1.28M| } 232| | 233| 1.60M| for(i = 0; i < 4; i++){ ------------------ | Branch (233:13): [True: 1.28M, False: 321k] ------------------ 234| 1.28M| prev_err0_scalar[i] = data[-1+i*(data_len_int/4)]; 235| 1.28M| prev_err1_scalar[i] = (FLAC__int64)(data[-1+i*(data_len_int/4)]) - data[-2+i*(data_len_int/4)]; 236| 1.28M| 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.28M| 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.28M| } 239| 321k| prev_err0 = _mm256_loadu_si256((const __m256i*)(void*)prev_err0_scalar); 240| 321k| prev_err1 = _mm256_loadu_si256((const __m256i*)(void*)prev_err1_scalar); 241| 321k| prev_err2 = _mm256_loadu_si256((const __m256i*)(void*)prev_err2_scalar); 242| 321k| prev_err3 = _mm256_loadu_si256((const __m256i*)(void*)prev_err3_scalar); 243| 6.27M| for(i = 0; i < data_len_int / 4; i++){ ------------------ | Branch (243:13): [True: 5.95M, False: 321k] ------------------ 244| 5.95M| data_scalar[0] = data[i]; 245| 5.95M| data_scalar[1] = data[i+data_len/4]; 246| 5.95M| data_scalar[2] = data[i+2*data_len/4]; 247| 5.95M| data_scalar[3] = data[i+3*data_len/4]; 248| 5.95M| tempA = _mm256_loadu_si256((const __m256i*)(void*)data_scalar); 249| | /* Next three intrinsics calculate tempB as abs of tempA */ 250| 5.95M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 251| 5.95M| tempB = _mm256_xor_si256(tempA, bitmask); 252| 5.95M| tempB = _mm256_sub_epi64(tempB, bitmask); 253| 5.95M| total_err0 = _mm256_add_epi64(total_err0,tempB); 254| 5.95M| shadow_err0 = _mm256_or_si256(shadow_err0,tempB); 255| 5.95M| tempB = _mm256_sub_epi64(tempA,prev_err0); 256| 5.95M| prev_err0 = tempA; 257| | /* Next three intrinsics calculate tempA as abs of tempB */ 258| 5.95M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempB); 259| 5.95M| tempA = _mm256_xor_si256(tempB, bitmask); 260| 5.95M| tempA = _mm256_sub_epi64(tempA, bitmask); 261| 5.95M| total_err1 = _mm256_add_epi64(total_err1,tempA); 262| 5.95M| shadow_err1 = _mm256_or_si256(shadow_err1,tempA); 263| 5.95M| tempA = _mm256_sub_epi64(tempB,prev_err1); 264| 5.95M| prev_err1 = tempB; 265| | /* Next three intrinsics calculate tempB as abs of tempA */ 266| 5.95M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 267| 5.95M| tempB = _mm256_xor_si256(tempA, bitmask); 268| 5.95M| tempB = _mm256_sub_epi64(tempB, bitmask); 269| 5.95M| total_err2 = _mm256_add_epi64(total_err2,tempB); 270| 5.95M| shadow_err2 = _mm256_or_si256(shadow_err2,tempB); 271| 5.95M| tempB = _mm256_sub_epi64(tempA,prev_err2); 272| 5.95M| prev_err2 = tempA; 273| | /* Next three intrinsics calculate tempA as abs of tempB */ 274| 5.95M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempB); 275| 5.95M| tempA = _mm256_xor_si256(tempB, bitmask); 276| 5.95M| tempA = _mm256_sub_epi64(tempA, bitmask); 277| 5.95M| total_err3 = _mm256_add_epi64(total_err3,tempA); 278| 5.95M| shadow_err3 = _mm256_or_si256(shadow_err3,tempA); 279| 5.95M| tempA = _mm256_sub_epi64(tempB,prev_err3); 280| 5.95M| prev_err3 = tempB; 281| | /* Next three intrinsics calculate tempB as abs of tempA */ 282| 5.95M| bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA); 283| 5.95M| tempB = _mm256_xor_si256(tempA, bitmask); 284| 5.95M| tempB = _mm256_sub_epi64(tempB, bitmask); 285| 5.95M| total_err4 = _mm256_add_epi64(total_err4,tempB); 286| 5.95M| shadow_err4 = _mm256_or_si256(shadow_err4,tempB); 287| 5.95M| } 288| 321k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err0); 289| 321k| total_error_0 += data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 290| 321k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err1); 291| 321k| total_error_1 += data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 292| 321k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err2); 293| 321k| total_error_2 += data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 294| 321k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err3); 295| 321k| total_error_3 += data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 296| 321k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,total_err4); 297| 321k| total_error_4 += data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 298| 321k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,shadow_err0); 299| 321k| shadow_error_0 |= data_scalar[0] | data_scalar[1] | data_scalar[2] | data_scalar[3]; 300| 321k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,shadow_err1); 301| 321k| shadow_error_1 |= data_scalar[0] | data_scalar[1] | data_scalar[2] | data_scalar[3]; 302| 321k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,shadow_err2); 303| 321k| shadow_error_2 |= data_scalar[0] | data_scalar[1] | data_scalar[2] | data_scalar[3]; 304| 321k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,shadow_err3); 305| 321k| shadow_error_3 |= data_scalar[0] | data_scalar[1] | data_scalar[2] | data_scalar[3]; 306| 321k| _mm256_storeu_si256((__m256i*)(void*)data_scalar,shadow_err4); 307| 321k| shadow_error_4 |= data_scalar[0] | data_scalar[1] | data_scalar[2] | data_scalar[3]; 308| | 309| | /* Take care of remaining sample */ 310| 386k| for(i = (data_len/4)*4; i < data_len_int; i++) { ------------------ | Branch (310:26): [True: 65.1k, False: 321k] ------------------ 311| 65.1k| error_0 = local_abs64((FLAC__int64)data[i]); ------------------ | | 173| 65.1k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 24.9k, False: 40.2k] | | ------------------ ------------------ 312| 65.1k| error_1 = local_abs64((FLAC__int64)data[i] - data[i-1]); ------------------ | | 173| 65.1k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 19.8k, False: 45.3k] | | ------------------ ------------------ 313| 65.1k| error_2 = local_abs64((FLAC__int64)data[i] - 2 * (FLAC__int64)data[i-1] + data[i-2]); ------------------ | | 173| 65.1k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 23.0k, False: 42.0k] | | ------------------ ------------------ 314| 65.1k| error_3 = local_abs64((FLAC__int64)data[i] - 3 * (FLAC__int64)data[i-1] + 3 * (FLAC__int64)data[i-2] - data[i-3]); ------------------ | | 173| 65.1k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 25.0k, False: 40.1k] | | ------------------ ------------------ 315| 65.1k| 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| 65.1k|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (173:36): [True: 27.4k, False: 37.7k] | | ------------------ ------------------ 316| | 317| 65.1k| total_error_0 += error_0; 318| 65.1k| total_error_1 += error_1; 319| 65.1k| total_error_2 += error_2; 320| 65.1k| total_error_3 += error_3; 321| 65.1k| total_error_4 += error_4; 322| | 323| 65.1k| shadow_error_0 |= error_0; 324| 65.1k| shadow_error_1 |= error_1; 325| 65.1k| shadow_error_2 |= error_2; 326| 65.1k| shadow_error_3 |= error_3; 327| 65.1k| shadow_error_4 |= error_4; 328| 65.1k| } 329| | 330| | 331| 321k| CHECK_ORDER_IS_VALID(0); ------------------ | | 175| 321k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 176| 321k|if(shadow_error_##macro_order <= INT32_MAX) { \ | | ------------------ | | | Branch (176:4): [True: 319k, False: 1.43k] | | ------------------ | | 177| 319k| if(total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (177:5): [True: 319k, False: 12] | | ------------------ | | 178| 319k| order = macro_order; \ | | 179| 319k| smallest_error = total_error_##macro_order ; \ | | 180| 319k| } \ | | 181| 319k| 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: 314k, False: 5.53k] | | ------------------ | | 182| 319k|} \ | | 183| 321k|else \ | | 184| 321k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 332| 321k| CHECK_ORDER_IS_VALID(1); ------------------ | | 175| 321k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 176| 321k|if(shadow_error_##macro_order <= INT32_MAX) { \ | | ------------------ | | | Branch (176:4): [True: 255k, False: 66.3k] | | ------------------ | | 177| 255k| if(total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (177:5): [True: 219k, False: 35.6k] | | ------------------ | | 178| 219k| order = macro_order; \ | | 179| 219k| smallest_error = total_error_##macro_order ; \ | | 180| 219k| } \ | | 181| 255k| 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: 90.8k, False: 164k] | | ------------------ | | 182| 255k|} \ | | 183| 321k|else \ | | 184| 321k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 333| 321k| CHECK_ORDER_IS_VALID(2); ------------------ | | 175| 321k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 176| 321k|if(shadow_error_##macro_order <= INT32_MAX) { \ | | ------------------ | | | Branch (176:4): [True: 235k, False: 85.9k] | | ------------------ | | 177| 235k| if(total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (177:5): [True: 1.78k, False: 233k] | | ------------------ | | 178| 1.78k| order = macro_order; \ | | 179| 1.78k| smallest_error = total_error_##macro_order ; \ | | 180| 1.78k| } \ | | 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: 71.2k, False: 164k] | | ------------------ | | 182| 235k|} \ | | 183| 321k|else \ | | 184| 321k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 334| 321k| CHECK_ORDER_IS_VALID(3); ------------------ | | 175| 321k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 176| 321k|if(shadow_error_##macro_order <= INT32_MAX) { \ | | ------------------ | | | Branch (176:4): [True: 221k, False: 99.5k] | | ------------------ | | 177| 221k| if(total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (177:5): [True: 1.87k, False: 219k] | | ------------------ | | 178| 1.87k| order = macro_order; \ | | 179| 1.87k| smallest_error = total_error_##macro_order ; \ | | 180| 1.87k| } \ | | 181| 221k| 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: 57.4k, False: 164k] | | ------------------ | | 182| 221k|} \ | | 183| 321k|else \ | | 184| 321k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 335| 321k| CHECK_ORDER_IS_VALID(4); ------------------ | | 175| 321k|#define CHECK_ORDER_IS_VALID(macro_order) \ | | 176| 321k|if(shadow_error_##macro_order <= INT32_MAX) { \ | | ------------------ | | | Branch (176:4): [True: 207k, False: 113k] | | ------------------ | | 177| 207k| if(total_error_##macro_order < smallest_error) { \ | | ------------------ | | | Branch (177:5): [True: 1.26k, False: 206k] | | ------------------ | | 178| 1.26k| order = macro_order; \ | | 179| 1.26k| smallest_error = total_error_##macro_order ; \ | | 180| 1.26k| } \ | | 181| 207k| 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: 43.6k, False: 164k] | | ------------------ | | 182| 207k|} \ | | 183| 321k|else \ | | 184| 321k| residual_bits_per_sample[ macro_order ] = 34.0f; ------------------ 336| | 337| 321k| return order; 338| 321k|} FLAC__fixed_compute_best_predictor_intrin_ssse3: 64| 53.6k|{ 65| 53.6k| FLAC__uint32 total_error_0, total_error_1, total_error_2, total_error_3, total_error_4; 66| 53.6k| FLAC__int32 i, data_len_int; 67| 53.6k| uint32_t order; 68| 53.6k| __m128i total_err0, total_err1, total_err2, total_err3, total_err4; 69| 53.6k| __m128i prev_err0, prev_err1, prev_err2, prev_err3; 70| 53.6k| __m128i tempA, tempB; 71| 53.6k| FLAC__int32 data_scalar[4]; 72| 53.6k| FLAC__int32 prev_err0_scalar[4]; 73| 53.6k| FLAC__int32 prev_err1_scalar[4]; 74| 53.6k| FLAC__int32 prev_err2_scalar[4]; 75| 53.6k| FLAC__int32 prev_err3_scalar[4]; 76| 53.6k| total_err0 = _mm_setzero_si128(); 77| 53.6k| total_err1 = _mm_setzero_si128(); 78| 53.6k| total_err2 = _mm_setzero_si128(); 79| 53.6k| total_err3 = _mm_setzero_si128(); 80| 53.6k| total_err4 = _mm_setzero_si128(); 81| 53.6k| data_len_int = data_len; 82| | 83| 268k| for(i = 0; i < 4; i++){ ------------------ | Branch (83:13): [True: 214k, False: 53.6k] ------------------ 84| 214k| prev_err0_scalar[i] = data[-1+i*(data_len_int/4)]; 85| 214k| prev_err1_scalar[i] = data[-1+i*(data_len_int/4)] - data[-2+i*(data_len_int/4)]; 86| 214k| prev_err2_scalar[i] = prev_err1_scalar[i] - (data[-2+i*(data_len_int/4)] - data[-3+i*(data_len_int/4)]); 87| 214k| 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| 214k| } 89| 53.6k| prev_err0 = _mm_loadu_si128((const __m128i*)prev_err0_scalar); 90| 53.6k| prev_err1 = _mm_loadu_si128((const __m128i*)prev_err1_scalar); 91| 53.6k| prev_err2 = _mm_loadu_si128((const __m128i*)prev_err2_scalar); 92| 53.6k| prev_err3 = _mm_loadu_si128((const __m128i*)prev_err3_scalar); 93| 669k| for(i = 0; i < data_len_int / 4; i++){ ------------------ | Branch (93:13): [True: 615k, False: 53.6k] ------------------ 94| 615k| data_scalar[0] = data[i]; 95| 615k| data_scalar[1] = data[i+data_len/4]; 96| 615k| data_scalar[2] = data[i+2*(data_len/4)]; 97| 615k| data_scalar[3] = data[i+3*(data_len/4)]; 98| 615k| tempA = _mm_loadu_si128((const __m128i*)data_scalar); 99| 615k| tempB = _mm_abs_epi32(tempA); 100| 615k| total_err0 = _mm_add_epi32(total_err0,tempB); 101| 615k| tempB = _mm_sub_epi32(tempA,prev_err0); 102| 615k| prev_err0 = tempA; 103| 615k| tempA = _mm_abs_epi32(tempB); 104| 615k| total_err1 = _mm_add_epi32(total_err1,tempA); 105| 615k| tempA = _mm_sub_epi32(tempB,prev_err1); 106| 615k| prev_err1 = tempB; 107| 615k| tempB = _mm_abs_epi32(tempA); 108| 615k| total_err2 = _mm_add_epi32(total_err2,tempB); 109| 615k| tempB = _mm_sub_epi32(tempA,prev_err2); 110| 615k| prev_err2 = tempA; 111| 615k| tempA = _mm_abs_epi32(tempB); 112| 615k| total_err3 = _mm_add_epi32(total_err3,tempA); 113| 615k| tempA = _mm_sub_epi32(tempB,prev_err3); 114| 615k| prev_err3 = tempB; 115| 615k| tempB = _mm_abs_epi32(tempA); 116| 615k| total_err4 = _mm_add_epi32(total_err4,tempB); 117| 615k| } 118| 53.6k| _mm_storeu_si128((__m128i*)data_scalar,total_err0); 119| 53.6k| total_error_0 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 120| 53.6k| _mm_storeu_si128((__m128i*)data_scalar,total_err1); 121| 53.6k| total_error_1 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 122| 53.6k| _mm_storeu_si128((__m128i*)data_scalar,total_err2); 123| 53.6k| total_error_2 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 124| 53.6k| _mm_storeu_si128((__m128i*)data_scalar,total_err3); 125| 53.6k| total_error_3 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3]; 126| 53.6k| _mm_storeu_si128((__m128i*)data_scalar,total_err4); 127| 53.6k| 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| 53.6k| i *= 4; 131| 53.6k| if(data_len % 4 > 0){ ------------------ | Branch (131:5): [True: 28.4k, False: 25.1k] ------------------ 132| 28.4k| FLAC__int32 last_error_0 = data[i-1]; 133| 28.4k| FLAC__int32 last_error_1 = data[i-1] - data[i-2]; 134| 28.4k| FLAC__int32 last_error_2 = last_error_1 - (data[i-2] - data[i-3]); 135| 28.4k| FLAC__int32 last_error_3 = last_error_2 - (data[i-2] - 2*data[i-3] + data[i-4]); 136| 28.4k| FLAC__int32 error, save; 137| 65.2k| for(; i < data_len_int; i++) { ------------------ | Branch (137:9): [True: 36.7k, False: 28.4k] ------------------ 138| 36.7k| error = data[i] ; total_error_0 += local_abs(error); save = error; ------------------ | | 60| 36.7k|#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (60:34): [True: 5.87k, False: 30.8k] | | ------------------ ------------------ 139| 36.7k| error -= last_error_0; total_error_1 += local_abs(error); last_error_0 = save; save = error; ------------------ | | 60| 36.7k|#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (60:34): [True: 9.20k, False: 27.5k] | | ------------------ ------------------ 140| 36.7k| error -= last_error_1; total_error_2 += local_abs(error); last_error_1 = save; save = error; ------------------ | | 60| 36.7k|#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (60:34): [True: 11.2k, False: 25.4k] | | ------------------ ------------------ 141| 36.7k| error -= last_error_2; total_error_3 += local_abs(error); last_error_2 = save; save = error; ------------------ | | 60| 36.7k|#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (60:34): [True: 11.3k, False: 25.4k] | | ------------------ ------------------ 142| 36.7k| error -= last_error_3; total_error_4 += local_abs(error); last_error_3 = save; ------------------ | | 60| 36.7k|#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (60:34): [True: 13.5k, False: 23.2k] | | ------------------ ------------------ 143| 36.7k| } 144| 28.4k| } 145| | 146| | /* prefer lower order */ 147| 53.6k| if(total_error_0 <= flac_min(flac_min(flac_min(total_error_1, total_error_2), total_error_3), total_error_4)) ------------------ | | 56| 53.6k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (147:5): [True: 11.2k, False: 42.3k] | Branch (147:22): [True: 29.6k, False: 23.9k] | Branch (147:22): [True: 29.2k, False: 2.93k] | Branch (147:22): [True: 32.2k, False: 21.4k] | Branch (147:22): [True: 29.4k, False: 4.28k] | Branch (147:22): [True: 29.0k, False: 2.92k] | Branch (147:22): [True: 32.0k, False: 1.75k] | Branch (147:22): [True: 33.7k, False: 19.8k] ------------------ 148| 11.2k| order = 0; 149| 42.3k| else if(total_error_1 <= flac_min(flac_min(total_error_2, total_error_3), total_error_4)) ------------------ | | 56| 42.3k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (149:10): [True: 40.3k, False: 1.99k] | Branch (149:27): [True: 22.8k, False: 19.5k] | Branch (149:27): [True: 22.6k, False: 2.17k] | Branch (149:27): [True: 24.8k, False: 17.5k] ------------------ 150| 40.3k| order = 1; 151| 1.99k| else if(total_error_2 <= flac_min(total_error_3, total_error_4)) ------------------ | | 56| 1.99k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (151:10): [True: 828, False: 1.17k] | Branch (151:27): [True: 1.67k, False: 328] ------------------ 152| 828| order = 2; 153| 1.17k| else if(total_error_3 <= total_error_4) ------------------ | Branch (153:10): [True: 845, False: 326] ------------------ 154| 845| order = 3; 155| 326| else 156| 326| 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| 53.6k| FLAC__ASSERT(data_len > 0 || total_error_0 == 0); ------------------ | | 38| 53.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 53.6k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 162| 53.6k| FLAC__ASSERT(data_len > 0 || total_error_1 == 0); ------------------ | | 38| 53.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 53.6k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 163| 53.6k| FLAC__ASSERT(data_len > 0 || total_error_2 == 0); ------------------ | | 38| 53.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 53.6k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 164| 53.6k| FLAC__ASSERT(data_len > 0 || total_error_3 == 0); ------------------ | | 38| 53.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 53.6k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 165| 53.6k| FLAC__ASSERT(data_len > 0 || total_error_4 == 0); ------------------ | | 38| 53.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 53.6k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 166| | 167| 53.6k| 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: 50.9k, False: 2.74k] ------------------ 168| 53.6k| 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: 32.7k, False: 20.8k] ------------------ 169| 53.6k| 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: 33.4k, False: 20.2k] ------------------ 170| 53.6k| 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: 34.2k, False: 19.4k] ------------------ 171| 53.6k| 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: 34.8k, False: 18.8k] ------------------ 172| | 173| 53.6k| return order; 174| 53.6k|} FLAC__format_sample_rate_is_valid: 210| 287k|{ 211| 287k| if(sample_rate > FLAC__MAX_SAMPLE_RATE) { ------------------ | | 125| 287k|#define FLAC__MAX_SAMPLE_RATE (1048575u) ------------------ | Branch (211:5): [True: 18, False: 287k] ------------------ 212| 18| return false; 213| 18| } 214| 287k| else 215| 287k| return true; 216| 287k|} FLAC__format_blocksize_is_subset: 219| 649|{ 220| 649| if(blocksize > 16384) ------------------ | Branch (220:5): [True: 9, False: 640] ------------------ 221| 9| return false; 222| 640| else if(sample_rate <= 48000 && blocksize > 4608) ------------------ | Branch (222:10): [True: 266, False: 374] | Branch (222:34): [True: 8, False: 258] ------------------ 223| 8| return false; 224| 632| else 225| 632| return true; 226| 649|} FLAC__format_sample_rate_is_subset: 229| 632|{ 230| 632| if( // sample rate is not subset if 231| 632| !FLAC__format_sample_rate_is_valid(sample_rate) || // sample rate is invalid or ------------------ | Branch (231:3): [True: 0, False: 632] ------------------ 232| 632| sample_rate >= ((1u << 16) * 10) || // sample rate is larger then or equal to 655360 or ------------------ | Branch (232:3): [True: 24, False: 608] ------------------ 233| 608| (sample_rate >= (1u << 16) && sample_rate % 10 != 0) //sample rate is >= 65536 and not divisible by 10 ------------------ | Branch (233:4): [True: 262, False: 346] | Branch (233:33): [True: 21, False: 241] ------------------ 234| 632| ) { 235| 45| return false; 236| 45| } 237| 587| else 238| 587| return true; 239| 632|} FLAC__format_get_max_rice_partition_order_from_blocksize: 541| 267k|{ 542| 267k| uint32_t max_rice_partition_order = 0; 543| 1.21M| while(!(blocksize & 1)) { ------------------ | Branch (543:8): [True: 952k, False: 267k] ------------------ 544| 952k| max_rice_partition_order++; 545| 952k| blocksize >>= 1; 546| 952k| } 547| | return flac_min(FLAC__MAX_RICE_PARTITION_ORDER, max_rice_partition_order); ------------------ | | 56| 267k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (547:9): [True: 0, False: 267k] ------------------ 548| 267k|} FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order: 551| 16.1M|{ 552| 16.1M| uint32_t max_rice_partition_order = limit; 553| | 554| 26.6M| while(max_rice_partition_order > 0 && (blocksize >> max_rice_partition_order) <= predictor_order) ------------------ | Branch (554:8): [True: 13.3M, False: 13.3M] | Branch (554:40): [True: 10.5M, False: 2.85M] ------------------ 555| 10.5M| max_rice_partition_order--; 556| | 557| 16.1M| FLAC__ASSERT( ------------------ | | 38| 54.4M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 13.3M, False: 2.84M] | | | Branch (38:30): [True: 13.3M, False: 18.4E] | | | Branch (38:30): [True: 2.89M, False: 273] | | | Branch (38:30): [True: 2.89M, False: 18.4E] | | ------------------ ------------------ 558| 16.1M| (max_rice_partition_order == 0 && blocksize >= predictor_order) || 559| 16.1M| (max_rice_partition_order > 0 && blocksize >> max_rice_partition_order > predictor_order) 560| 16.1M| ); 561| | 562| 16.1M| return max_rice_partition_order; 563| 16.1M|} FLAC__format_entropy_coding_method_partitioned_rice_contents_init: 566| 1.48M|{ 567| 1.48M| FLAC__ASSERT(0 != object); ------------------ | | 38| 1.48M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.48M] | | ------------------ ------------------ 568| | 569| 1.48M| object->parameters = 0; 570| 1.48M| object->raw_bits = 0; 571| 1.48M| object->capacity_by_order = 0; 572| 1.48M|} FLAC__format_entropy_coding_method_partitioned_rice_contents_clear: 575| 848k|{ 576| 848k| FLAC__ASSERT(0 != object); ------------------ | | 38| 848k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 848k] | | ------------------ ------------------ 577| | 578| 848k| if(0 != object->parameters) ------------------ | Branch (578:5): [True: 225k, False: 622k] ------------------ 579| 225k| free(object->parameters); 580| 848k| if(0 != object->raw_bits) ------------------ | Branch (580:5): [True: 225k, False: 622k] ------------------ 581| 225k| free(object->raw_bits); 582| 848k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(object); 583| 848k|} FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size: 591| 445k|{ 592| 445k| FLAC__ASSERT(0 != object); ------------------ | | 38| 445k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 445k] | | ------------------ ------------------ 593| | 594| 445k| if(object->capacity_by_order < max_partition_order || object->parameters == NULL || object->raw_bits == NULL) { ------------------ | Branch (594:5): [True: 153k, False: 291k] | Branch (594:56): [True: 71.5k, False: 219k] | Branch (594:86): [True: 0, False: 219k] ------------------ 595| 225k| if(0 == (object->parameters = safe_realloc_(object->parameters, sizeof(uint32_t)*(1 << max_partition_order)))) ------------------ | Branch (595:6): [True: 0, False: 225k] ------------------ 596| 0| return false; 597| 225k| if(0 == (object->raw_bits = safe_realloc_(object->raw_bits, sizeof(uint32_t)*(1 << max_partition_order)))) ------------------ | Branch (597:6): [True: 0, False: 225k] ------------------ 598| 0| return false; 599| 225k| memset(object->raw_bits, 0, sizeof(uint32_t)*(1 << max_partition_order)); 600| 225k| object->capacity_by_order = max_partition_order; 601| 225k| } 602| | 603| 445k| return true; 604| 445k|} stream_encoder.c:FLAC__bitmath_ilog2: 157| 25.3M|{ 158| 25.3M| FLAC__ASSERT(v > 0); ------------------ | | 38| 25.3M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 25.3M] | | ------------------ ------------------ 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.3M| return FLAC__clz_uint32(v) ^ 31U; 169| 25.3M|#endif 170| 25.3M|} stream_encoder.c:FLAC__clz_uint32: 74| 25.3M|{ 75| |/* Never used with input 0 */ 76| 25.3M| FLAC__ASSERT(v > 0); ------------------ | | 38| 25.3M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 25.3M] | | ------------------ ------------------ 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.3M| 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.3M|} stream_encoder.c:FLAC__bitmath_ilog2_wide: 173| 30.1M|{ 174| 30.1M| FLAC__ASSERT(v > 0); ------------------ | | 38| 30.1M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 30.1M] | | ------------------ ------------------ 175| 30.1M|#if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 176| 30.1M| 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| 30.1M|} stream_encoder_intrin_avx2.c:FLAC__bitmath_ilog2: 157| 16.2M|{ 158| 16.2M| FLAC__ASSERT(v > 0); ------------------ | | 38| 16.2M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.2M] | | ------------------ ------------------ 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| 16.2M| return FLAC__clz_uint32(v) ^ 31U; 169| 16.2M|#endif 170| 16.2M|} stream_encoder_intrin_avx2.c:FLAC__clz_uint32: 74| 16.2M|{ 75| |/* Never used with input 0 */ 76| 16.2M| FLAC__ASSERT(v > 0); ------------------ | | 38| 16.2M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.2M] | | ------------------ ------------------ 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| 16.2M| 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| 16.2M|} bitmath.c:FLAC__bitmath_ilog2_wide: 173| 23.1M|{ 174| 23.1M| FLAC__ASSERT(v > 0); ------------------ | | 38| 23.1M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.1M] | | ------------------ ------------------ 175| 23.1M|#if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 176| 23.1M| 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| 23.1M|} bitreader.c:FLAC__clz_uint64: 102| 20.7M|{ 103| | /* Never used with input 0 */ 104| 20.7M| FLAC__ASSERT(v > 0); ------------------ | | 38| 20.7M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.7M] | | ------------------ ------------------ 105| 20.7M|#if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 106| 20.7M| 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| 20.7M|} bitreader.c:FLAC__clz2_uint64: 127| 17.1M|{ 128| 17.1M| if (!v) ------------------ | Branch (128:6): [True: 591k, False: 16.5M] ------------------ 129| 591k| return 64; 130| 16.5M| return FLAC__clz_uint64(v); 131| 17.1M|} FLAC__lpc_window_data: 69| 230k|{ 70| 230k| uint32_t i; 71| 27.2M| for(i = 0; i < data_len; i++) ------------------ | Branch (71:13): [True: 26.9M, False: 230k] ------------------ 72| 26.9M| out[i] = in[i] * window[i]; 73| 230k|} FLAC__lpc_window_data_wide: 76| 14.5k|{ 77| 14.5k| uint32_t i; 78| 3.61M| for(i = 0; i < data_len; i++) ------------------ | Branch (78:13): [True: 3.60M, False: 14.5k] ------------------ 79| 3.60M| out[i] = in[i] * window[i]; 80| 14.5k|} FLAC__lpc_window_data_partial: 83| 31.2k|{ 84| 31.2k| uint32_t i, j; 85| 31.2k| if((part_size + data_shift) < data_len){ ------------------ | Branch (85:5): [True: 31.2k, False: 0] ------------------ 86| 944k| for(i = 0; i < part_size; i++) ------------------ | Branch (86:14): [True: 913k, False: 31.2k] ------------------ 87| 913k| out[i] = in[data_shift+i] * window[i]; 88| 31.2k| i = flac_min(i,data_len - part_size - data_shift); ------------------ | | 56| 31.2k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (88:7): [True: 29.0k, False: 2.21k] ------------------ 89| 944k| for(j = data_len - part_size; j < data_len; i++, j++) ------------------ | Branch (89:33): [True: 913k, False: 31.2k] ------------------ 90| 913k| out[i] = in[data_shift+i] * window[j]; 91| 31.2k| if(i < data_len) ------------------ | Branch (91:6): [True: 31.2k, False: 0] ------------------ 92| 31.2k| out[i] = 0.0f; 93| 31.2k| } 94| 31.2k|} FLAC__lpc_window_data_partial_wide: 97| 3.70k|{ 98| 3.70k| uint32_t i, j; 99| 3.70k| if((part_size + data_shift) < data_len){ ------------------ | Branch (99:5): [True: 3.70k, False: 0] ------------------ 100| 105k| for(i = 0; i < part_size; i++) ------------------ | Branch (100:14): [True: 101k, False: 3.70k] ------------------ 101| 101k| out[i] = in[data_shift+i] * window[i]; 102| 3.70k| i = flac_min(i,data_len - part_size - data_shift); ------------------ | | 56| 3.70k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (102:7): [True: 3.18k, False: 523] ------------------ 103| 105k| for(j = data_len - part_size; j < data_len; i++, j++) ------------------ | Branch (103:33): [True: 101k, False: 3.70k] ------------------ 104| 101k| out[i] = in[data_shift+i] * window[j]; 105| 3.70k| if(i < data_len) ------------------ | Branch (105:6): [True: 3.70k, False: 0] ------------------ 106| 3.70k| out[i] = 0.0f; 107| 3.70k| } 108| 3.70k|} FLAC__lpc_compute_autocorrelation: 111| 244k|{ 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| 244k| if (data_len < FLAC__MAX_LPC_ORDER || lag > 16) { ------------------ | | 128| 489k|#define FLAC__MAX_LPC_ORDER (32u) ------------------ | Branch (133:6): [True: 213k, False: 30.7k] | Branch (133:40): [True: 15.5k, False: 15.1k] ------------------ 134| | /* 135| | * this version tends to run faster because of better data locality 136| | * ('data_len' is usually much larger than 'lag') 137| | */ 138| 229k| double d; 139| 229k| uint32_t sample, coeff; 140| 229k| const uint32_t limit = data_len - lag; 141| | 142| 229k| FLAC__ASSERT(lag > 0); ------------------ | | 38| 229k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 229k] | | ------------------ ------------------ 143| 229k| FLAC__ASSERT(lag <= data_len); ------------------ | | 38| 229k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 229k] | | ------------------ ------------------ 144| | 145| 3.22M| for(coeff = 0; coeff < lag; coeff++) ------------------ | Branch (145:18): [True: 3.00M, False: 229k] ------------------ 146| 3.00M| autoc[coeff] = 0.0; 147| 13.2M| for(sample = 0; sample <= limit; sample++) { ------------------ | Branch (147:19): [True: 12.9M, False: 229k] ------------------ 148| 12.9M| d = data[sample]; 149| 401M| for(coeff = 0; coeff < lag; coeff++) ------------------ | Branch (149:19): [True: 388M, False: 12.9M] ------------------ 150| 388M| autoc[coeff] += d * data[sample+coeff]; 151| 12.9M| } 152| 2.99M| for(; sample < data_len; sample++) { ------------------ | Branch (152:9): [True: 2.77M, False: 229k] ------------------ 153| 2.77M| d = data[sample]; 154| 24.9M| for(coeff = 0; coeff < data_len - sample; coeff++) ------------------ | Branch (154:19): [True: 22.1M, False: 2.77M] ------------------ 155| 22.1M| autoc[coeff] += d * data[sample+coeff]; 156| 2.77M| } 157| 229k| } 158| 15.1k| else if(lag <= 8) { ------------------ | Branch (158:10): [True: 934, False: 14.2k] ------------------ 159| 934| #undef MAX_LAG 160| 934| #define MAX_LAG 8 161| 934| #include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 934| int i, j; | | 2| 934| (void) lag; | | 3| 934| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 934|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 934] | | | | ------------------ | | ------------------ | | 4| | | | 5| 8.40k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 160| 8.40k| #define MAX_LAG 8 | | ------------------ | | | Branch (5:20): [True: 7.47k, False: 934] | | ------------------ | | 6| 7.47k| autoc[i] = 0.0; | | 7| | | | 8| 8.40k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 160| 8.40k| #define MAX_LAG 8 | | ------------------ | | | Branch (8:20): [True: 7.47k, False: 934] | | ------------------ | | 9| 41.0k| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 33.6k, False: 7.47k] | | ------------------ | | 10| 33.6k| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 23.3k| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 160| 934| #define MAX_LAG 8 | | ------------------ | | | Branch (12:26): [True: 22.4k, False: 934] | | ------------------ | | 13| 201k| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 160| 201k| #define MAX_LAG 8 | | ------------------ | | | Branch (13:14): [True: 179k, False: 22.4k] | | ------------------ | | 14| 179k| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 162| 934| } 163| 14.2k| else if(lag <= 12) { ------------------ | Branch (163:10): [True: 4.15k, False: 10.1k] ------------------ 164| 4.15k| #undef MAX_LAG 165| 4.15k| #define MAX_LAG 12 166| 4.15k| #include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 4.15k| int i, j; | | 2| 4.15k| (void) lag; | | 3| 4.15k| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 4.15k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 4.15k] | | | | ------------------ | | ------------------ | | 4| | | | 5| 53.9k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 165| 53.9k| #define MAX_LAG 12 | | ------------------ | | | Branch (5:20): [True: 49.7k, False: 4.15k] | | ------------------ | | 6| 49.7k| autoc[i] = 0.0; | | 7| | | | 8| 53.8k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 165| 53.8k| #define MAX_LAG 12 | | ------------------ | | | Branch (8:20): [True: 49.7k, False: 4.15k] | | ------------------ | | 9| 372k| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 322k, False: 49.7k] | | ------------------ | | 10| 322k| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 86.7k| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 165| 4.15k| #define MAX_LAG 12 | | ------------------ | | | Branch (12:26): [True: 82.5k, False: 4.15k] | | ------------------ | | 13| 1.07M| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 165| 1.07M| #define MAX_LAG 12 | | ------------------ | | | Branch (13:14): [True: 988k, False: 82.5k] | | ------------------ | | 14| 988k| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 167| 4.15k| } 168| 10.1k| else if(lag <= 16) { ------------------ | Branch (168:10): [True: 10.1k, False: 18.4E] ------------------ 169| 10.1k| #undef MAX_LAG 170| 10.1k| #define MAX_LAG 16 171| 10.1k| #include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 10.1k| int i, j; | | 2| 10.1k| (void) lag; | | 3| 10.1k| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 10.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 10.1k] | | | | ------------------ | | ------------------ | | 4| | | | 5| 170k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 170| 170k| #define MAX_LAG 16 | | ------------------ | | | Branch (5:20): [True: 160k, False: 10.1k] | | ------------------ | | 6| 160k| autoc[i] = 0.0; | | 7| | | | 8| 167k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 170| 167k| #define MAX_LAG 16 | | ------------------ | | | Branch (8:20): [True: 157k, False: 10.1k] | | ------------------ | | 9| 1.46M| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 1.30M, False: 157k] | | ------------------ | | 10| 1.30M| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 160k| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 170| 10.1k| #define MAX_LAG 16 | | ------------------ | | | Branch (12:26): [True: 150k, False: 10.1k] | | ------------------ | | 13| 2.30M| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 170| 2.30M| #define MAX_LAG 16 | | ------------------ | | | Branch (13:14): [True: 2.14M, False: 150k] | | ------------------ | | 14| 2.14M| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 172| 10.1k| } 173| | 174| 244k|} FLAC__lpc_compute_lp_coefficients: 177| 306k|{ 178| 306k| uint32_t i, j; 179| 306k| double r, err, lpc[FLAC__MAX_LPC_ORDER]; 180| | 181| 306k| FLAC__ASSERT(0 != max_order); ------------------ | | 38| 306k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 306k] | | ------------------ ------------------ 182| 306k| FLAC__ASSERT(0 < *max_order); ------------------ | | 38| 306k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 306k] | | ------------------ ------------------ 183| 306k| FLAC__ASSERT(*max_order <= FLAC__MAX_LPC_ORDER); ------------------ | | 38| 306k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 306k] | | ------------------ ------------------ 184| 306k| FLAC__ASSERT(autoc[0] != 0.0); ------------------ | | 38| 306k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 306k] | | ------------------ ------------------ 185| | 186| 306k| err = autoc[0]; 187| | 188| 3.79M| for(i = 0; i < *max_order; i++) { ------------------ | Branch (188:13): [True: 3.49M, False: 306k] ------------------ 189| | /* Sum up this iteration's reflection coefficient. */ 190| 3.49M| r = -autoc[i+1]; 191| 27.0M| for(j = 0; j < i; j++) ------------------ | Branch (191:14): [True: 23.5M, False: 3.49M] ------------------ 192| 23.5M| r -= lpc[j] * autoc[i-j]; 193| 3.49M| r /= err; 194| | 195| | /* Update LPC coefficients and total error. */ 196| 3.49M| lpc[i]=r; 197| 14.4M| for(j = 0; j < (i>>1); j++) { ------------------ | Branch (197:14): [True: 10.9M, False: 3.49M] ------------------ 198| 10.9M| double tmp = lpc[j]; 199| 10.9M| lpc[j] += r * lpc[i-1-j]; 200| 10.9M| lpc[i-1-j] += r * tmp; 201| 10.9M| } 202| 3.49M| if(i & 1) ------------------ | Branch (202:6): [True: 1.69M, False: 1.79M] ------------------ 203| 1.69M| lpc[j] += lpc[j] * r; 204| | 205| 3.49M| err *= (1.0 - r * r); 206| | 207| | /* save this order */ 208| 30.5M| for(j = 0; j <= i; j++) ------------------ | Branch (208:14): [True: 27.0M, False: 3.49M] ------------------ 209| 27.0M| lp_coeff[i][j] = (FLAC__real)(-lpc[j]); /* negate FIR filter coeff to get predictor coeff */ 210| 3.49M| error[i] = err; 211| | 212| | /* see SF bug https://sourceforge.net/p/flac/bugs/234/ */ 213| 3.49M| if(err == 0.0) { ------------------ | Branch (213:6): [True: 207, False: 3.49M] ------------------ 214| 207| *max_order = i+1; 215| 207| return; 216| 207| } 217| 3.49M| } 218| 306k|} FLAC__lpc_quantize_coefficients: 221| 18.1M|{ 222| 18.1M| uint32_t i; 223| 18.1M| double cmax; 224| 18.1M| FLAC__int32 qmax, qmin; 225| | 226| 18.1M| FLAC__ASSERT(precision > 0); ------------------ | | 38| 18.1M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.1M] | | ------------------ ------------------ 227| 18.1M| FLAC__ASSERT(precision >= FLAC__MIN_QLP_COEFF_PRECISION); ------------------ | | 38| 18.1M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.1M] | | ------------------ ------------------ 228| | 229| | /* drop one bit for the sign; from here on out we consider only |lp_coeff[i]| */ 230| 18.1M| precision--; 231| 18.1M| qmax = 1 << precision; 232| 18.1M| qmin = -qmax; 233| 18.1M| qmax--; 234| | 235| | /* calc cmax = max( |lp_coeff[i]| ) */ 236| 18.1M| cmax = 0.0; 237| 161M| for(i = 0; i < order; i++) { ------------------ | Branch (237:13): [True: 143M, False: 18.1M] ------------------ 238| 143M| const double d = fabs(lp_coeff[i]); 239| 143M| if(d > cmax) ------------------ | Branch (239:6): [True: 27.3M, False: 115M] ------------------ 240| 27.3M| cmax = d; 241| 143M| } 242| | 243| 18.1M| if(cmax <= 0.0) { ------------------ | Branch (243:5): [True: 656k, False: 17.4M] ------------------ 244| | /* => coefficients are all 0, which means our constant-detect didn't work */ 245| 656k| return 2; 246| 656k| } 247| 17.4M| else { 248| 17.4M| const int max_shiftlimit = (1 << (FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN-1)) - 1; 249| 17.4M| const int min_shiftlimit = -max_shiftlimit - 1; 250| 17.4M| int log2cmax; 251| | 252| 17.4M| (void)frexp(cmax, &log2cmax); 253| 17.4M| log2cmax--; 254| 17.4M| *shift = (int)precision - log2cmax - 1; 255| | 256| 17.4M| if(*shift > max_shiftlimit) ------------------ | Branch (256:6): [True: 1.76M, False: 15.7M] ------------------ 257| 1.76M| *shift = max_shiftlimit; 258| 15.7M| else if(*shift < min_shiftlimit) ------------------ | Branch (258:11): [True: 505, False: 15.7M] ------------------ 259| 505| return 1; 260| 17.4M| } 261| | 262| 17.4M| if(*shift >= 0) { ------------------ | Branch (262:5): [True: 17.2M, False: 221k] ------------------ 263| 17.2M| double error = 0.0; 264| 17.2M| FLAC__int32 q; 265| 156M| for(i = 0; i < order; i++) { ------------------ | Branch (265:14): [True: 139M, False: 17.2M] ------------------ 266| 139M| error += lp_coeff[i] * (1 << *shift); 267| 139M| 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: 219k, False: 139M] ------------------ 276| 219k| q = qmax; 277| 139M| else if(q < qmin) ------------------ | Branch (277:12): [True: 0, False: 139M] ------------------ 278| 0| q = qmin; 279| 139M| error -= q; 280| 139M| qlp_coeff[i] = q; 281| 139M| } 282| 17.2M| } 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| 221k| else { 288| 221k| const int nshift = -(*shift); 289| 221k| double error = 0.0; 290| 221k| 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| 333k| for(i = 0; i < order; i++) { ------------------ | Branch (294:14): [True: 112k, False: 221k] ------------------ 295| 112k| error += lp_coeff[i] / (1 << nshift); 296| 112k| 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: 405, False: 111k] ------------------ 304| 405| q = qmax; 305| 111k| else if(q < qmin) ------------------ | Branch (305:12): [True: 0, False: 111k] ------------------ 306| 0| q = qmin; 307| 112k| error -= q; 308| 112k| qlp_coeff[i] = q; 309| 112k| } 310| 221k| *shift = 0; 311| 221k| } 312| | 313| 17.4M| return 0; 314| 18.1M|} FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual: 833| 10.5M|{ 834| 10.5M| int i; 835| 10.5M| FLAC__int64 sum, residual_to_check; 836| | 837| 10.5M| FLAC__ASSERT(order > 0); ------------------ | | 38| 10.5M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 10.5M] | | ------------------ ------------------ 838| 10.5M| FLAC__ASSERT(order <= 32); ------------------ | | 38| 10.5M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 10.5M] | | ------------------ ------------------ 839| | 840| 1.12G| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (840:13): [True: 1.11G, False: 8.90M] ------------------ 841| 1.11G| sum = 0; 842| 1.11G| switch(order) { ------------------ | Branch (842:10): [True: 1.12G, False: 18.4E] ------------------ 843| 21.5M| case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32]; /* Falls through. */ ------------------ | Branch (843:4): [True: 21.5M, False: 1.09G] ------------------ 844| 43.3M| case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31]; /* Falls through. */ ------------------ | Branch (844:4): [True: 21.8M, False: 1.09G] ------------------ 845| 65.7M| case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30]; /* Falls through. */ ------------------ | Branch (845:4): [True: 22.3M, False: 1.09G] ------------------ 846| 87.7M| case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29]; /* Falls through. */ ------------------ | Branch (846:4): [True: 22.0M, False: 1.09G] ------------------ 847| 109M| case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28]; /* Falls through. */ ------------------ | Branch (847:4): [True: 22.0M, False: 1.09G] ------------------ 848| 131M| case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27]; /* Falls through. */ ------------------ | Branch (848:4): [True: 22.1M, False: 1.09G] ------------------ 849| 153M| case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26]; /* Falls through. */ ------------------ | Branch (849:4): [True: 21.9M, False: 1.09G] ------------------ 850| 175M| case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25]; /* Falls through. */ ------------------ | Branch (850:4): [True: 21.9M, False: 1.09G] ------------------ 851| 198M| case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24]; /* Falls through. */ ------------------ | Branch (851:4): [True: 22.2M, False: 1.09G] ------------------ 852| 220M| case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23]; /* Falls through. */ ------------------ | Branch (852:4): [True: 22.0M, False: 1.09G] ------------------ 853| 242M| case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22]; /* Falls through. */ ------------------ | Branch (853:4): [True: 22.0M, False: 1.09G] ------------------ 854| 265M| case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21]; /* Falls through. */ ------------------ | Branch (854:4): [True: 22.8M, False: 1.09G] ------------------ 855| 289M| case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20]; /* Falls through. */ ------------------ | Branch (855:4): [True: 24.3M, False: 1.09G] ------------------ 856| 313M| case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19]; /* Falls through. */ ------------------ | Branch (856:4): [True: 24.3M, False: 1.09G] ------------------ 857| 337M| case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18]; /* Falls through. */ ------------------ | Branch (857:4): [True: 24.2M, False: 1.09G] ------------------ 858| 366M| case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17]; /* Falls through. */ ------------------ | Branch (858:4): [True: 28.0M, False: 1.08G] ------------------ 859| 399M| case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16]; /* Falls through. */ ------------------ | Branch (859:4): [True: 33.1M, False: 1.08G] ------------------ 860| 431M| case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15]; /* Falls through. */ ------------------ | Branch (860:4): [True: 32.7M, False: 1.08G] ------------------ 861| 469M| case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14]; /* Falls through. */ ------------------ | Branch (861:4): [True: 37.7M, False: 1.07G] ------------------ 862| 510M| case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13]; /* Falls through. */ ------------------ | Branch (862:4): [True: 40.8M, False: 1.07G] ------------------ 863| 550M| case 12: sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; /* Falls through. */ ------------------ | Branch (863:4): [True: 40.0M, False: 1.07G] ------------------ 864| 591M| case 11: sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; /* Falls through. */ ------------------ | Branch (864:4): [True: 41.0M, False: 1.07G] ------------------ 865| 633M| case 10: sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10]; /* Falls through. */ ------------------ | Branch (865:4): [True: 41.6M, False: 1.07G] ------------------ 866| 677M| case 9: sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9]; /* Falls through. */ ------------------ | Branch (866:4): [True: 44.1M, False: 1.07G] ------------------ 867| 729M| case 8: sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8]; /* Falls through. */ ------------------ | Branch (867:4): [True: 51.7M, False: 1.06G] ------------------ 868| 781M| case 7: sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7]; /* Falls through. */ ------------------ | Branch (868:4): [True: 51.9M, False: 1.06G] ------------------ 869| 835M| case 6: sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6]; /* Falls through. */ ------------------ | Branch (869:4): [True: 54.6M, False: 1.06G] ------------------ 870| 891M| case 5: sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5]; /* Falls through. */ ------------------ | Branch (870:4): [True: 55.3M, False: 1.06G] ------------------ 871| 945M| case 4: sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4]; /* Falls through. */ ------------------ | Branch (871:4): [True: 54.0M, False: 1.06G] ------------------ 872| 1.00G| case 3: sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3]; /* Falls through. */ ------------------ | Branch (872:4): [True: 55.5M, False: 1.06G] ------------------ 873| 1.05G| case 2: sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2]; /* Falls through. */ ------------------ | Branch (873:4): [True: 57.2M, False: 1.05G] ------------------ 874| 1.12G| case 1: sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1]; ------------------ | Branch (874:4): [True: 66.5M, False: 1.04G] ------------------ 875| 1.11G| } 876| 1.11G| residual_to_check = data[i] - (sum >> lp_quantization); 877| | /* residual must not be INT32_MIN because abs(INT32_MIN) is undefined */ 878| 1.11G| if(residual_to_check <= INT32_MIN || residual_to_check > INT32_MAX) ------------------ | Branch (878:6): [True: 735k, False: 1.11G] | Branch (878:40): [True: 927k, False: 1.11G] ------------------ 879| 1.57M| return false; 880| 1.11G| else 881| 1.11G| residual[i] = residual_to_check; 882| 1.11G| } 883| 8.90M| return true; 884| 10.5M|} FLAC__lpc_compute_residual_from_qlp_coefficients_limit_residual_33bit: 887| 1.08M|{ 888| 1.08M| int i; 889| 1.08M| FLAC__int64 sum, residual_to_check; 890| | 891| 1.08M| FLAC__ASSERT(order > 0); ------------------ | | 38| 1.08M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.08M] | | ------------------ ------------------ 892| 1.08M| FLAC__ASSERT(order <= 32); ------------------ | | 38| 1.08M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.08M] | | ------------------ ------------------ 893| | 894| 81.0M| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (894:13): [True: 80.3M, False: 728k] ------------------ 895| 80.3M| sum = 0; 896| 80.3M| switch(order) { ------------------ | Branch (896:10): [True: 80.5M, False: 18.4E] ------------------ 897| 2.00M| case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */ ------------------ | Branch (897:4): [True: 2.00M, False: 78.3M] ------------------ 898| 4.04M| case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */ ------------------ | Branch (898:4): [True: 2.04M, False: 78.2M] ------------------ 899| 6.11M| case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */ ------------------ | Branch (899:4): [True: 2.07M, False: 78.2M] ------------------ 900| 8.21M| case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */ ------------------ | Branch (900:4): [True: 2.10M, False: 78.2M] ------------------ 901| 10.2M| case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */ ------------------ | Branch (901:4): [True: 2.06M, False: 78.2M] ------------------ 902| 12.3M| case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */ ------------------ | Branch (902:4): [True: 2.05M, False: 78.2M] ------------------ 903| 14.3M| case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */ ------------------ | Branch (903:4): [True: 2.03M, False: 78.2M] ------------------ 904| 16.3M| case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */ ------------------ | Branch (904:4): [True: 1.99M, False: 78.3M] ------------------ 905| 18.4M| case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */ ------------------ | Branch (905:4): [True: 2.04M, False: 78.2M] ------------------ 906| 20.4M| case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */ ------------------ | Branch (906:4): [True: 2.07M, False: 78.2M] ------------------ 907| 22.5M| case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */ ------------------ | Branch (907:4): [True: 2.05M, False: 78.2M] ------------------ 908| 24.6M| case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */ ------------------ | Branch (908:4): [True: 2.11M, False: 78.1M] ------------------ 909| 26.7M| case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */ ------------------ | Branch (909:4): [True: 2.04M, False: 78.2M] ------------------ 910| 28.6M| case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */ ------------------ | Branch (910:4): [True: 1.97M, False: 78.3M] ------------------ 911| 30.6M| case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */ ------------------ | Branch (911:4): [True: 2.00M, False: 78.3M] ------------------ 912| 32.6M| case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */ ------------------ | Branch (912:4): [True: 2.01M, False: 78.2M] ------------------ 913| 34.7M| case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */ ------------------ | Branch (913:4): [True: 2.03M, False: 78.2M] ------------------ 914| 36.7M| case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */ ------------------ | Branch (914:4): [True: 2.04M, False: 78.2M] ------------------ 915| 39.1M| case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */ ------------------ | Branch (915:4): [True: 2.34M, False: 77.9M] ------------------ 916| 42.0M| case 13: sum += qlp_coeff[12] * data[i-13]; /* Falls through. */ ------------------ | Branch (916:4): [True: 2.89M, False: 77.4M] ------------------ 917| 44.7M| case 12: sum += qlp_coeff[11] * data[i-12]; /* Falls through. */ ------------------ | Branch (917:4): [True: 2.73M, False: 77.5M] ------------------ 918| 47.6M| case 11: sum += qlp_coeff[10] * data[i-11]; /* Falls through. */ ------------------ | Branch (918:4): [True: 2.88M, False: 77.4M] ------------------ 919| 50.5M| case 10: sum += qlp_coeff[ 9] * data[i-10]; /* Falls through. */ ------------------ | Branch (919:4): [True: 2.93M, False: 77.3M] ------------------ 920| 53.6M| case 9: sum += qlp_coeff[ 8] * data[i- 9]; /* Falls through. */ ------------------ | Branch (920:4): [True: 3.06M, False: 77.2M] ------------------ 921| 56.7M| case 8: sum += qlp_coeff[ 7] * data[i- 8]; /* Falls through. */ ------------------ | Branch (921:4): [True: 3.07M, False: 77.2M] ------------------ 922| 59.7M| case 7: sum += qlp_coeff[ 6] * data[i- 7]; /* Falls through. */ ------------------ | Branch (922:4): [True: 3.00M, False: 77.3M] ------------------ 923| 62.7M| case 6: sum += qlp_coeff[ 5] * data[i- 6]; /* Falls through. */ ------------------ | Branch (923:4): [True: 3.07M, False: 77.2M] ------------------ 924| 66.2M| case 5: sum += qlp_coeff[ 4] * data[i- 5]; /* Falls through. */ ------------------ | Branch (924:4): [True: 3.41M, False: 76.8M] ------------------ 925| 69.6M| case 4: sum += qlp_coeff[ 3] * data[i- 4]; /* Falls through. */ ------------------ | Branch (925:4): [True: 3.41M, False: 76.8M] ------------------ 926| 73.1M| case 3: sum += qlp_coeff[ 2] * data[i- 3]; /* Falls through. */ ------------------ | Branch (926:4): [True: 3.49M, False: 76.8M] ------------------ 927| 76.5M| case 2: sum += qlp_coeff[ 1] * data[i- 2]; /* Falls through. */ ------------------ | Branch (927:4): [True: 3.40M, False: 76.8M] ------------------ 928| 80.5M| case 1: sum += qlp_coeff[ 0] * data[i- 1]; ------------------ | Branch (928:4): [True: 4.00M, False: 76.3M] ------------------ 929| 80.3M| } 930| 80.3M| residual_to_check = data[i] - (sum >> lp_quantization); 931| | /* residual must not be INT32_MIN because abs(INT32_MIN) is undefined */ 932| 80.3M| if(residual_to_check <= INT32_MIN || residual_to_check > INT32_MAX) ------------------ | Branch (932:6): [True: 227k, False: 80.1M] | Branch (932:40): [True: 166k, False: 79.9M] ------------------ 933| 383k| return false; 934| 79.9M| else 935| 79.9M| residual[i] = residual_to_check; 936| 80.3M| } 937| 728k| return true; 938| 1.08M|} FLAC__lpc_max_prediction_value_before_shift: 943| 23.3M|{ 944| 23.3M| FLAC__uint64 max_abs_sample_value = (FLAC__uint64)(1) << (subframe_bps - 1); 945| 23.3M| FLAC__uint32 abs_sum_of_qlp_coeff = 0; 946| 23.3M| uint32_t i; 947| 213M| for(i = 0; i < order; i++) ------------------ | Branch (947:13): [True: 190M, False: 23.3M] ------------------ 948| 190M| abs_sum_of_qlp_coeff += abs(qlp_coeff[i]); 949| 23.3M| return max_abs_sample_value * abs_sum_of_qlp_coeff; 950| 23.3M|} FLAC__lpc_max_prediction_before_shift_bps: 953| 5.89M|{ 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| 5.89M| return FLAC__bitmath_silog2(FLAC__lpc_max_prediction_value_before_shift(subframe_bps, qlp_coeff, order)); 959| 5.89M|} FLAC__lpc_max_residual_bps: 963| 17.5M|{ 964| 17.5M| FLAC__uint64 max_abs_sample_value = (FLAC__uint64)(1) << (subframe_bps - 1); 965| 17.5M| 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| 17.5M| FLAC__uint64 max_residual_value = max_abs_sample_value + max_prediction_value_after_shift; 967| 17.5M| return FLAC__bitmath_silog2(max_residual_value); 968| 17.5M|} FLAC__lpc_restore_signal: 1019| 6.98k|{ 1020| 6.98k| int i; 1021| 6.98k| FLAC__int32 sum; 1022| | 1023| 6.98k| FLAC__ASSERT(order > 0); ------------------ | | 38| 6.98k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.98k] | | ------------------ ------------------ 1024| 6.98k| FLAC__ASSERT(order <= 32); ------------------ | | 38| 6.98k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.98k] | | ------------------ ------------------ 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.98k| if(order <= 12) { ------------------ | Branch (1031:5): [True: 6.53k, False: 448] ------------------ 1032| 6.53k| if(order > 8) { ------------------ | Branch (1032:6): [True: 967, False: 5.56k] ------------------ 1033| 967| if(order > 10) { ------------------ | Branch (1033:7): [True: 561, False: 406] ------------------ 1034| 561| if(order == 12) { ------------------ | Branch (1034:8): [True: 294, False: 267] ------------------ 1035| 27.8k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1035:17): [True: 27.5k, False: 294] ------------------ 1036| 27.5k| sum = 0; 1037| 27.5k| sum += qlp_coeff[11] * data[i-12]; 1038| 27.5k| sum += qlp_coeff[10] * data[i-11]; 1039| 27.5k| sum += qlp_coeff[9] * data[i-10]; 1040| 27.5k| sum += qlp_coeff[8] * data[i-9]; 1041| 27.5k| sum += qlp_coeff[7] * data[i-8]; 1042| 27.5k| sum += qlp_coeff[6] * data[i-7]; 1043| 27.5k| sum += qlp_coeff[5] * data[i-6]; 1044| 27.5k| sum += qlp_coeff[4] * data[i-5]; 1045| 27.5k| sum += qlp_coeff[3] * data[i-4]; 1046| 27.5k| sum += qlp_coeff[2] * data[i-3]; 1047| 27.5k| sum += qlp_coeff[1] * data[i-2]; 1048| 27.5k| sum += qlp_coeff[0] * data[i-1]; 1049| 27.5k| data[i] = residual[i] + (sum >> lp_quantization); 1050| 27.5k| } 1051| 294| } 1052| 267| else { /* order == 11 */ 1053| 9.15k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1053:17): [True: 8.88k, False: 267] ------------------ 1054| 8.88k| sum = 0; 1055| 8.88k| sum += qlp_coeff[10] * data[i-11]; 1056| 8.88k| sum += qlp_coeff[9] * data[i-10]; 1057| 8.88k| sum += qlp_coeff[8] * data[i-9]; 1058| 8.88k| sum += qlp_coeff[7] * data[i-8]; 1059| 8.88k| sum += qlp_coeff[6] * data[i-7]; 1060| 8.88k| sum += qlp_coeff[5] * data[i-6]; 1061| 8.88k| sum += qlp_coeff[4] * data[i-5]; 1062| 8.88k| sum += qlp_coeff[3] * data[i-4]; 1063| 8.88k| sum += qlp_coeff[2] * data[i-3]; 1064| 8.88k| sum += qlp_coeff[1] * data[i-2]; 1065| 8.88k| sum += qlp_coeff[0] * data[i-1]; 1066| 8.88k| data[i] = residual[i] + (sum >> lp_quantization); 1067| 8.88k| } 1068| 267| } 1069| 561| } 1070| 406| else { 1071| 406| if(order == 10) { ------------------ | Branch (1071:8): [True: 291, False: 115] ------------------ 1072| 103k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1072:17): [True: 103k, False: 291] ------------------ 1073| 103k| sum = 0; 1074| 103k| sum += qlp_coeff[9] * data[i-10]; 1075| 103k| sum += qlp_coeff[8] * data[i-9]; 1076| 103k| sum += qlp_coeff[7] * data[i-8]; 1077| 103k| sum += qlp_coeff[6] * data[i-7]; 1078| 103k| sum += qlp_coeff[5] * data[i-6]; 1079| 103k| sum += qlp_coeff[4] * data[i-5]; 1080| 103k| sum += qlp_coeff[3] * data[i-4]; 1081| 103k| sum += qlp_coeff[2] * data[i-3]; 1082| 103k| sum += qlp_coeff[1] * data[i-2]; 1083| 103k| sum += qlp_coeff[0] * data[i-1]; 1084| 103k| data[i] = residual[i] + (sum >> lp_quantization); 1085| 103k| } 1086| 291| } 1087| 115| else { /* order == 9 */ 1088| 20.0k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1088:17): [True: 19.9k, False: 115] ------------------ 1089| 19.9k| sum = 0; 1090| 19.9k| sum += qlp_coeff[8] * data[i-9]; 1091| 19.9k| sum += qlp_coeff[7] * data[i-8]; 1092| 19.9k| sum += qlp_coeff[6] * data[i-7]; 1093| 19.9k| sum += qlp_coeff[5] * data[i-6]; 1094| 19.9k| sum += qlp_coeff[4] * data[i-5]; 1095| 19.9k| sum += qlp_coeff[3] * data[i-4]; 1096| 19.9k| sum += qlp_coeff[2] * data[i-3]; 1097| 19.9k| sum += qlp_coeff[1] * data[i-2]; 1098| 19.9k| sum += qlp_coeff[0] * data[i-1]; 1099| 19.9k| data[i] = residual[i] + (sum >> lp_quantization); 1100| 19.9k| } 1101| 115| } 1102| 406| } 1103| 967| } 1104| 5.56k| else if(order > 4) { ------------------ | Branch (1104:11): [True: 1.39k, False: 4.17k] ------------------ 1105| 1.39k| if(order > 6) { ------------------ | Branch (1105:7): [True: 787, False: 604] ------------------ 1106| 787| if(order == 8) { ------------------ | Branch (1106:8): [True: 421, False: 366] ------------------ 1107| 76.0k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1107:17): [True: 75.6k, False: 421] ------------------ 1108| 75.6k| sum = 0; 1109| 75.6k| sum += qlp_coeff[7] * data[i-8]; 1110| 75.6k| sum += qlp_coeff[6] * data[i-7]; 1111| 75.6k| sum += qlp_coeff[5] * data[i-6]; 1112| 75.6k| sum += qlp_coeff[4] * data[i-5]; 1113| 75.6k| sum += qlp_coeff[3] * data[i-4]; 1114| 75.6k| sum += qlp_coeff[2] * data[i-3]; 1115| 75.6k| sum += qlp_coeff[1] * data[i-2]; 1116| 75.6k| sum += qlp_coeff[0] * data[i-1]; 1117| 75.6k| data[i] = residual[i] + (sum >> lp_quantization); 1118| 75.6k| } 1119| 421| } 1120| 366| else { /* order == 7 */ 1121| 78.5k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1121:17): [True: 78.2k, False: 366] ------------------ 1122| 78.2k| sum = 0; 1123| 78.2k| sum += qlp_coeff[6] * data[i-7]; 1124| 78.2k| sum += qlp_coeff[5] * data[i-6]; 1125| 78.2k| sum += qlp_coeff[4] * data[i-5]; 1126| 78.2k| sum += qlp_coeff[3] * data[i-4]; 1127| 78.2k| sum += qlp_coeff[2] * data[i-3]; 1128| 78.2k| sum += qlp_coeff[1] * data[i-2]; 1129| 78.2k| sum += qlp_coeff[0] * data[i-1]; 1130| 78.2k| data[i] = residual[i] + (sum >> lp_quantization); 1131| 78.2k| } 1132| 366| } 1133| 787| } 1134| 604| else { 1135| 604| if(order == 6) { ------------------ | Branch (1135:8): [True: 301, False: 303] ------------------ 1136| 35.9k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1136:17): [True: 35.6k, False: 301] ------------------ 1137| 35.6k| sum = 0; 1138| 35.6k| sum += qlp_coeff[5] * data[i-6]; 1139| 35.6k| sum += qlp_coeff[4] * data[i-5]; 1140| 35.6k| sum += qlp_coeff[3] * data[i-4]; 1141| 35.6k| sum += qlp_coeff[2] * data[i-3]; 1142| 35.6k| sum += qlp_coeff[1] * data[i-2]; 1143| 35.6k| sum += qlp_coeff[0] * data[i-1]; 1144| 35.6k| data[i] = residual[i] + (sum >> lp_quantization); 1145| 35.6k| } 1146| 301| } 1147| 303| else { /* order == 5 */ 1148| 195k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1148:17): [True: 195k, False: 303] ------------------ 1149| 195k| sum = 0; 1150| 195k| sum += qlp_coeff[4] * data[i-5]; 1151| 195k| sum += qlp_coeff[3] * data[i-4]; 1152| 195k| sum += qlp_coeff[2] * data[i-3]; 1153| 195k| sum += qlp_coeff[1] * data[i-2]; 1154| 195k| sum += qlp_coeff[0] * data[i-1]; 1155| 195k| data[i] = residual[i] + (sum >> lp_quantization); 1156| 195k| } 1157| 303| } 1158| 604| } 1159| 1.39k| } 1160| 4.17k| else { 1161| 4.17k| if(order > 2) { ------------------ | Branch (1161:7): [True: 1.32k, False: 2.85k] ------------------ 1162| 1.32k| if(order == 4) { ------------------ | Branch (1162:8): [True: 466, False: 858] ------------------ 1163| 32.3k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1163:17): [True: 31.9k, False: 466] ------------------ 1164| 31.9k| sum = 0; 1165| 31.9k| sum += qlp_coeff[3] * data[i-4]; 1166| 31.9k| sum += qlp_coeff[2] * data[i-3]; 1167| 31.9k| sum += qlp_coeff[1] * data[i-2]; 1168| 31.9k| sum += qlp_coeff[0] * data[i-1]; 1169| 31.9k| data[i] = residual[i] + (sum >> lp_quantization); 1170| 31.9k| } 1171| 466| } 1172| 858| else { /* order == 3 */ 1173| 260k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1173:17): [True: 259k, False: 858] ------------------ 1174| 259k| sum = 0; 1175| 259k| sum += qlp_coeff[2] * data[i-3]; 1176| 259k| sum += qlp_coeff[1] * data[i-2]; 1177| 259k| sum += qlp_coeff[0] * data[i-1]; 1178| 259k| data[i] = residual[i] + (sum >> lp_quantization); 1179| 259k| } 1180| 858| } 1181| 1.32k| } 1182| 2.85k| else { 1183| 2.85k| if(order == 2) { ------------------ | Branch (1183:8): [True: 994, False: 1.85k] ------------------ 1184| 236k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1184:17): [True: 235k, False: 994] ------------------ 1185| 235k| sum = 0; 1186| 235k| sum += qlp_coeff[1] * data[i-2]; 1187| 235k| sum += qlp_coeff[0] * data[i-1]; 1188| 235k| data[i] = residual[i] + (sum >> lp_quantization); 1189| 235k| } 1190| 994| } 1191| 1.85k| else { /* order == 1 */ 1192| 56.8k| for(i = 0; i < (int)data_len; i++) ------------------ | Branch (1192:17): [True: 54.9k, False: 1.85k] ------------------ 1193| 54.9k| data[i] = residual[i] + ((qlp_coeff[0] * data[i-1]) >> lp_quantization); 1194| 1.85k| } 1195| 2.85k| } 1196| 4.17k| } 1197| 6.53k| } 1198| 448| else { /* order > 12 */ 1199| 440k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1199:14): [True: 440k, False: 448] ------------------ 1200| 440k| sum = 0; 1201| 440k| switch(order) { ------------------ | Branch (1201:11): [True: 440k, False: 0] ------------------ 1202| 73.0k| case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */ ------------------ | Branch (1202:5): [True: 73.0k, False: 367k] ------------------ 1203| 98.7k| case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */ ------------------ | Branch (1203:5): [True: 25.7k, False: 414k] ------------------ 1204| 104k| case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */ ------------------ | Branch (1204:5): [True: 5.30k, False: 435k] ------------------ 1205| 117k| case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */ ------------------ | Branch (1205:5): [True: 13.3k, False: 426k] ------------------ 1206| 120k| case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */ ------------------ | Branch (1206:5): [True: 3.27k, False: 437k] ------------------ 1207| 129k| case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */ ------------------ | Branch (1207:5): [True: 8.62k, False: 431k] ------------------ 1208| 137k| case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */ ------------------ | Branch (1208:5): [True: 7.74k, False: 432k] ------------------ 1209| 138k| case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */ ------------------ | Branch (1209:5): [True: 1.50k, False: 438k] ------------------ 1210| 185k| case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */ ------------------ | Branch (1210:5): [True: 46.7k, False: 393k] ------------------ 1211| 186k| case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */ ------------------ | Branch (1211:5): [True: 966, False: 439k] ------------------ 1212| 191k| case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */ ------------------ | Branch (1212:5): [True: 5.22k, False: 435k] ------------------ 1213| 196k| case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */ ------------------ | Branch (1213:5): [True: 4.65k, False: 435k] ------------------ 1214| 203k| case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */ ------------------ | Branch (1214:5): [True: 6.99k, False: 433k] ------------------ 1215| 206k| case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */ ------------------ | Branch (1215:5): [True: 3.50k, False: 436k] ------------------ 1216| 238k| case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */ ------------------ | Branch (1216:5): [True: 31.8k, False: 408k] ------------------ 1217| 309k| case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */ ------------------ | Branch (1217:5): [True: 71.0k, False: 369k] ------------------ 1218| 322k| case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */ ------------------ | Branch (1218:5): [True: 13.4k, False: 426k] ------------------ 1219| 333k| case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */ ------------------ | Branch (1219:5): [True: 10.1k, False: 430k] ------------------ 1220| 351k| case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */ ------------------ | Branch (1220:5): [True: 17.9k, False: 422k] ------------------ 1221| 440k| case 13: sum += qlp_coeff[12] * data[i-13]; ------------------ | Branch (1221:5): [True: 89.2k, False: 351k] ------------------ 1222| 440k| sum += qlp_coeff[11] * data[i-12]; 1223| 440k| sum += qlp_coeff[10] * data[i-11]; 1224| 440k| sum += qlp_coeff[ 9] * data[i-10]; 1225| 440k| sum += qlp_coeff[ 8] * data[i- 9]; 1226| 440k| sum += qlp_coeff[ 7] * data[i- 8]; 1227| 440k| sum += qlp_coeff[ 6] * data[i- 7]; 1228| 440k| sum += qlp_coeff[ 5] * data[i- 6]; 1229| 440k| sum += qlp_coeff[ 4] * data[i- 5]; 1230| 440k| sum += qlp_coeff[ 3] * data[i- 4]; 1231| 440k| sum += qlp_coeff[ 2] * data[i- 3]; 1232| 440k| sum += qlp_coeff[ 1] * data[i- 2]; 1233| 440k| sum += qlp_coeff[ 0] * data[i- 1]; 1234| 440k| } 1235| 440k| data[i] = residual[i] + (sum >> lp_quantization); 1236| 440k| } 1237| 448| } 1238| 6.98k|} FLAC__lpc_restore_signal_wide: 1271| 11.2k|{ 1272| 11.2k| int i; 1273| 11.2k| FLAC__int64 sum; 1274| | 1275| 11.2k| FLAC__ASSERT(order > 0); ------------------ | | 38| 11.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.2k] | | ------------------ ------------------ 1276| 11.2k| FLAC__ASSERT(order <= 32); ------------------ | | 38| 11.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 11.2k] | | ------------------ ------------------ 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| 11.2k| if(order <= 12) { ------------------ | Branch (1283:5): [True: 10.5k, False: 646] ------------------ 1284| 10.5k| if(order > 8) { ------------------ | Branch (1284:6): [True: 1.94k, False: 8.65k] ------------------ 1285| 1.94k| if(order > 10) { ------------------ | Branch (1285:7): [True: 616, False: 1.32k] ------------------ 1286| 616| if(order == 12) { ------------------ | Branch (1286:8): [True: 279, False: 337] ------------------ 1287| 163k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1287:17): [True: 163k, False: 279] ------------------ 1288| 163k| sum = 0; 1289| 163k| sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; 1290| 163k| sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; 1291| 163k| sum += qlp_coeff[9] * (FLAC__int64)data[i-10]; 1292| 163k| sum += qlp_coeff[8] * (FLAC__int64)data[i-9]; 1293| 163k| sum += qlp_coeff[7] * (FLAC__int64)data[i-8]; 1294| 163k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1295| 163k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1296| 163k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1297| 163k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1298| 163k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1299| 163k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1300| 163k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1301| 163k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1302| 163k| } 1303| 279| } 1304| 337| else { /* order == 11 */ 1305| 12.8k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1305:17): [True: 12.5k, False: 337] ------------------ 1306| 12.5k| sum = 0; 1307| 12.5k| sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; 1308| 12.5k| sum += qlp_coeff[9] * (FLAC__int64)data[i-10]; 1309| 12.5k| sum += qlp_coeff[8] * (FLAC__int64)data[i-9]; 1310| 12.5k| sum += qlp_coeff[7] * (FLAC__int64)data[i-8]; 1311| 12.5k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1312| 12.5k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1313| 12.5k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1314| 12.5k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1315| 12.5k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1316| 12.5k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1317| 12.5k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1318| 12.5k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1319| 12.5k| } 1320| 337| } 1321| 616| } 1322| 1.32k| else { 1323| 1.32k| if(order == 10) { ------------------ | Branch (1323:8): [True: 408, False: 917] ------------------ 1324| 183k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1324:17): [True: 182k, False: 408] ------------------ 1325| 182k| sum = 0; 1326| 182k| sum += qlp_coeff[9] * (FLAC__int64)data[i-10]; 1327| 182k| sum += qlp_coeff[8] * (FLAC__int64)data[i-9]; 1328| 182k| sum += qlp_coeff[7] * (FLAC__int64)data[i-8]; 1329| 182k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1330| 182k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1331| 182k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1332| 182k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1333| 182k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1334| 182k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1335| 182k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1336| 182k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1337| 182k| } 1338| 408| } 1339| 917| else { /* order == 9 */ 1340| 53.8k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1340:17): [True: 52.9k, False: 917] ------------------ 1341| 52.9k| sum = 0; 1342| 52.9k| sum += qlp_coeff[8] * (FLAC__int64)data[i-9]; 1343| 52.9k| sum += qlp_coeff[7] * (FLAC__int64)data[i-8]; 1344| 52.9k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1345| 52.9k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1346| 52.9k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1347| 52.9k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1348| 52.9k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1349| 52.9k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1350| 52.9k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1351| 52.9k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1352| 52.9k| } 1353| 917| } 1354| 1.32k| } 1355| 1.94k| } 1356| 8.65k| else if(order > 4) { ------------------ | Branch (1356:11): [True: 1.76k, False: 6.88k] ------------------ 1357| 1.76k| if(order > 6) { ------------------ | Branch (1357:7): [True: 943, False: 825] ------------------ 1358| 943| if(order == 8) { ------------------ | Branch (1358:8): [True: 483, False: 460] ------------------ 1359| 292k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1359:17): [True: 291k, False: 483] ------------------ 1360| 291k| sum = 0; 1361| 291k| sum += qlp_coeff[7] * (FLAC__int64)data[i-8]; 1362| 291k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1363| 291k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1364| 291k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1365| 291k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1366| 291k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1367| 291k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1368| 291k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1369| 291k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1370| 291k| } 1371| 483| } 1372| 460| else { /* order == 7 */ 1373| 266k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1373:17): [True: 266k, False: 460] ------------------ 1374| 266k| sum = 0; 1375| 266k| sum += qlp_coeff[6] * (FLAC__int64)data[i-7]; 1376| 266k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1377| 266k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1378| 266k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1379| 266k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1380| 266k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1381| 266k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1382| 266k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1383| 266k| } 1384| 460| } 1385| 943| } 1386| 825| else { 1387| 825| if(order == 6) { ------------------ | Branch (1387:8): [True: 406, False: 419] ------------------ 1388| 190k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1388:17): [True: 189k, False: 406] ------------------ 1389| 189k| sum = 0; 1390| 189k| sum += qlp_coeff[5] * (FLAC__int64)data[i-6]; 1391| 189k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1392| 189k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1393| 189k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1394| 189k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1395| 189k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1396| 189k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1397| 189k| } 1398| 406| } 1399| 419| else { /* order == 5 */ 1400| 241k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1400:17): [True: 241k, False: 419] ------------------ 1401| 241k| sum = 0; 1402| 241k| sum += qlp_coeff[4] * (FLAC__int64)data[i-5]; 1403| 241k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1404| 241k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1405| 241k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1406| 241k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1407| 241k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1408| 241k| } 1409| 419| } 1410| 825| } 1411| 1.76k| } 1412| 6.88k| else { 1413| 6.88k| if(order > 2) { ------------------ | Branch (1413:7): [True: 1.74k, False: 5.14k] ------------------ 1414| 1.74k| if(order == 4) { ------------------ | Branch (1414:8): [True: 938, False: 810] ------------------ 1415| 136k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1415:17): [True: 135k, False: 938] ------------------ 1416| 135k| sum = 0; 1417| 135k| sum += qlp_coeff[3] * (FLAC__int64)data[i-4]; 1418| 135k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1419| 135k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1420| 135k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1421| 135k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1422| 135k| } 1423| 938| } 1424| 810| else { /* order == 3 */ 1425| 141k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1425:17): [True: 141k, False: 810] ------------------ 1426| 141k| sum = 0; 1427| 141k| sum += qlp_coeff[2] * (FLAC__int64)data[i-3]; 1428| 141k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1429| 141k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1430| 141k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1431| 141k| } 1432| 810| } 1433| 1.74k| } 1434| 5.14k| else { 1435| 5.14k| if(order == 2) { ------------------ | Branch (1435:8): [True: 3.33k, False: 1.80k] ------------------ 1436| 333k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1436:17): [True: 330k, False: 3.33k] ------------------ 1437| 330k| sum = 0; 1438| 330k| sum += qlp_coeff[1] * (FLAC__int64)data[i-2]; 1439| 330k| sum += qlp_coeff[0] * (FLAC__int64)data[i-1]; 1440| 330k| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1441| 330k| } 1442| 3.33k| } 1443| 1.80k| else { /* order == 1 */ 1444| 679k| for(i = 0; i < (int)data_len; i++) ------------------ | Branch (1444:17): [True: 677k, False: 1.80k] ------------------ 1445| 677k| data[i] = (FLAC__int32)(residual[i] + ((qlp_coeff[0] * (FLAC__int64)data[i-1]) >> lp_quantization)); 1446| 1.80k| } 1447| 5.14k| } 1448| 6.88k| } 1449| 10.5k| } 1450| 646| else { /* order > 12 */ 1451| 2.57M| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1451:14): [True: 2.57M, False: 646] ------------------ 1452| 2.57M| sum = 0; 1453| 2.57M| switch(order) { ------------------ | Branch (1453:11): [True: 2.57M, False: 0] ------------------ 1454| 185k| case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32]; /* Falls through. */ ------------------ | Branch (1454:5): [True: 185k, False: 2.39M] ------------------ 1455| 207k| case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31]; /* Falls through. */ ------------------ | Branch (1455:5): [True: 22.1k, False: 2.55M] ------------------ 1456| 219k| case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30]; /* Falls through. */ ------------------ | Branch (1456:5): [True: 11.4k, False: 2.56M] ------------------ 1457| 237k| case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29]; /* Falls through. */ ------------------ | Branch (1457:5): [True: 18.3k, False: 2.55M] ------------------ 1458| 288k| case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28]; /* Falls through. */ ------------------ | Branch (1458:5): [True: 51.5k, False: 2.52M] ------------------ 1459| 292k| case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27]; /* Falls through. */ ------------------ | Branch (1459:5): [True: 3.94k, False: 2.57M] ------------------ 1460| 302k| case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26]; /* Falls through. */ ------------------ | Branch (1460:5): [True: 9.86k, False: 2.56M] ------------------ 1461| 312k| case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25]; /* Falls through. */ ------------------ | Branch (1461:5): [True: 9.65k, False: 2.56M] ------------------ 1462| 334k| case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24]; /* Falls through. */ ------------------ | Branch (1462:5): [True: 21.7k, False: 2.55M] ------------------ 1463| 374k| case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23]; /* Falls through. */ ------------------ | Branch (1463:5): [True: 40.7k, False: 2.53M] ------------------ 1464| 376k| case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22]; /* Falls through. */ ------------------ | Branch (1464:5): [True: 1.45k, False: 2.57M] ------------------ 1465| 386k| case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21]; /* Falls through. */ ------------------ | Branch (1465:5): [True: 9.91k, False: 2.56M] ------------------ 1466| 414k| case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20]; /* Falls through. */ ------------------ | Branch (1466:5): [True: 28.6k, False: 2.54M] ------------------ 1467| 422k| case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19]; /* Falls through. */ ------------------ | Branch (1467:5): [True: 7.06k, False: 2.57M] ------------------ 1468| 423k| case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18]; /* Falls through. */ ------------------ | Branch (1468:5): [True: 1.83k, False: 2.57M] ------------------ 1469| 432k| case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17]; /* Falls through. */ ------------------ | Branch (1469:5): [True: 8.36k, False: 2.56M] ------------------ 1470| 546k| case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16]; /* Falls through. */ ------------------ | Branch (1470:5): [True: 113k, False: 2.46M] ------------------ 1471| 551k| case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15]; /* Falls through. */ ------------------ | Branch (1471:5): [True: 5.40k, False: 2.57M] ------------------ 1472| 2.27M| case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14]; /* Falls through. */ ------------------ | Branch (1472:5): [True: 1.72M, False: 854k] ------------------ 1473| 2.57M| case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13]; ------------------ | Branch (1473:5): [True: 302k, False: 2.27M] ------------------ 1474| 2.57M| sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; 1475| 2.57M| sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; 1476| 2.57M| sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10]; 1477| 2.57M| sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9]; 1478| 2.57M| sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8]; 1479| 2.57M| sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7]; 1480| 2.57M| sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6]; 1481| 2.57M| sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5]; 1482| 2.57M| sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4]; 1483| 2.57M| sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3]; 1484| 2.57M| sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2]; 1485| 2.57M| sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1]; 1486| 2.57M| } 1487| 2.57M| data[i] = (FLAC__int32) (residual[i] + (sum >> lp_quantization)); 1488| 2.57M| } 1489| 646| } 1490| 11.2k|} FLAC__lpc_restore_signal_wide_33bit: 1526| 1.90k|{ 1527| 1.90k| int i; 1528| 1.90k| FLAC__int64 sum; 1529| | 1530| 1.90k| FLAC__ASSERT(order > 0); ------------------ | | 38| 1.90k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.90k] | | ------------------ ------------------ 1531| 1.90k| FLAC__ASSERT(order <= 32); ------------------ | | 38| 1.90k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.90k] | | ------------------ ------------------ 1532| | 1533| 198k| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1533:13): [True: 196k, False: 1.90k] ------------------ 1534| 196k| sum = 0; 1535| 196k| switch(order) { ------------------ | Branch (1535:10): [True: 196k, False: 0] ------------------ 1536| 965| case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */ ------------------ | Branch (1536:4): [True: 965, False: 195k] ------------------ 1537| 2.09k| case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */ ------------------ | Branch (1537:4): [True: 1.12k, False: 195k] ------------------ 1538| 3.05k| case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */ ------------------ | Branch (1538:4): [True: 964, False: 195k] ------------------ 1539| 5.24k| case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */ ------------------ | Branch (1539:4): [True: 2.18k, False: 194k] ------------------ 1540| 6.76k| case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */ ------------------ | Branch (1540:4): [True: 1.52k, False: 194k] ------------------ 1541| 32.0k| case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */ ------------------ | Branch (1541:4): [True: 25.2k, False: 171k] ------------------ 1542| 32.9k| case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */ ------------------ | Branch (1542:4): [True: 963, False: 195k] ------------------ 1543| 33.9k| case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */ ------------------ | Branch (1543:4): [True: 963, False: 195k] ------------------ 1544| 34.9k| case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */ ------------------ | Branch (1544:4): [True: 971, False: 195k] ------------------ 1545| 35.8k| case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */ ------------------ | Branch (1545:4): [True: 971, False: 195k] ------------------ 1546| 37.3k| case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */ ------------------ | Branch (1546:4): [True: 1.47k, False: 194k] ------------------ 1547| 38.6k| case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */ ------------------ | Branch (1547:4): [True: 1.25k, False: 195k] ------------------ 1548| 39.5k| case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */ ------------------ | Branch (1548:4): [True: 963, False: 195k] ------------------ 1549| 40.5k| case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */ ------------------ | Branch (1549:4): [True: 976, False: 195k] ------------------ 1550| 41.5k| case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */ ------------------ | Branch (1550:4): [True: 963, False: 195k] ------------------ 1551| 42.4k| case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */ ------------------ | Branch (1551:4): [True: 966, False: 195k] ------------------ 1552| 43.5k| case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */ ------------------ | Branch (1552:4): [True: 1.01k, False: 195k] ------------------ 1553| 44.2k| case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */ ------------------ | Branch (1553:4): [True: 707, False: 195k] ------------------ 1554| 45.3k| case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */ ------------------ | Branch (1554:4): [True: 1.13k, False: 195k] ------------------ 1555| 57.7k| case 13: sum += qlp_coeff[12] * data[i-13]; /* Falls through. */ ------------------ | Branch (1555:4): [True: 12.3k, False: 184k] ------------------ 1556| 59.0k| case 12: sum += qlp_coeff[11] * data[i-12]; /* Falls through. */ ------------------ | Branch (1556:4): [True: 1.32k, False: 195k] ------------------ 1557| 74.4k| case 11: sum += qlp_coeff[10] * data[i-11]; /* Falls through. */ ------------------ | Branch (1557:4): [True: 15.3k, False: 181k] ------------------ 1558| 75.2k| case 10: sum += qlp_coeff[ 9] * data[i-10]; /* Falls through. */ ------------------ | Branch (1558:4): [True: 843, False: 195k] ------------------ 1559| 83.6k| case 9: sum += qlp_coeff[ 8] * data[i- 9]; /* Falls through. */ ------------------ | Branch (1559:4): [True: 8.35k, False: 188k] ------------------ 1560| 91.6k| case 8: sum += qlp_coeff[ 7] * data[i- 8]; /* Falls through. */ ------------------ | Branch (1560:4): [True: 8.07k, False: 188k] ------------------ 1561| 96.0k| case 7: sum += qlp_coeff[ 6] * data[i- 7]; /* Falls through. */ ------------------ | Branch (1561:4): [True: 4.34k, False: 192k] ------------------ 1562| 102k| case 6: sum += qlp_coeff[ 5] * data[i- 6]; /* Falls through. */ ------------------ | Branch (1562:4): [True: 5.99k, False: 190k] ------------------ 1563| 109k| case 5: sum += qlp_coeff[ 4] * data[i- 5]; /* Falls through. */ ------------------ | Branch (1563:4): [True: 7.48k, False: 188k] ------------------ 1564| 114k| case 4: sum += qlp_coeff[ 3] * data[i- 4]; /* Falls through. */ ------------------ | Branch (1564:4): [True: 5.22k, False: 191k] ------------------ 1565| 116k| case 3: sum += qlp_coeff[ 2] * data[i- 3]; /* Falls through. */ ------------------ | Branch (1565:4): [True: 1.68k, False: 194k] ------------------ 1566| 128k| case 2: sum += qlp_coeff[ 1] * data[i- 2]; /* Falls through. */ ------------------ | Branch (1566:4): [True: 11.6k, False: 184k] ------------------ 1567| 196k| case 1: sum += qlp_coeff[ 0] * data[i- 1]; ------------------ | Branch (1567:4): [True: 68.3k, False: 128k] ------------------ 1568| 196k| } 1569| 196k| data[i] = residual[i] + (sum >> lp_quantization); 1570| 196k| } 1571| 1.90k|} FLAC__lpc_compute_expected_bits_per_residual_sample: 1581| 2.73M|{ 1582| 2.73M| double error_scale; 1583| | 1584| 2.73M| FLAC__ASSERT(total_samples > 0); ------------------ | | 38| 2.73M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 2.73M] | | ------------------ ------------------ 1585| | 1586| 2.73M| error_scale = 0.5 / (double)total_samples; 1587| | 1588| 2.73M| return FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale(lpc_error, error_scale); 1589| 2.73M|} FLAC__lpc_compute_expected_bits_per_residual_sample_with_error_scale: 1592| 6.22M|{ 1593| 6.22M| if(lpc_error > 0.0) { ------------------ | Branch (1593:5): [True: 6.18M, False: 39.2k] ------------------ 1594| 6.18M| double bps = (double)0.5 * log(error_scale * lpc_error) / M_LN2; 1595| 6.18M| if(bps >= 0.0) ------------------ | Branch (1595:6): [True: 5.90M, False: 288k] ------------------ 1596| 5.90M| return bps; 1597| 288k| else 1598| 288k| return 0.0; 1599| 6.18M| } 1600| 39.2k| else if(lpc_error < 0.0) { /* error should not be negative but can happen due to inadequate floating-point resolution */ ------------------ | Branch (1600:10): [True: 38.9k, False: 336] ------------------ 1601| 38.9k| return 1e32; 1602| 38.9k| } 1603| 336| else { 1604| 336| return 0.0; 1605| 336| } 1606| 6.22M|} FLAC__lpc_compute_best_order: 1609| 306k|{ 1610| 306k| 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| 306k| double bits, best_bits, error_scale; 1612| | 1613| 306k| FLAC__ASSERT(max_order > 0); ------------------ | | 38| 306k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 306k] | | ------------------ ------------------ 1614| 306k| FLAC__ASSERT(total_samples > 0); ------------------ | | 38| 306k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 306k] | | ------------------ ------------------ 1615| | 1616| 306k| error_scale = 0.5 / (double)total_samples; 1617| | 1618| 306k| best_index = 0; 1619| 306k| best_bits = (uint32_t)(-1); 1620| | 1621| 3.80M| for(indx = 0, order = 1; indx < max_order; indx++, order++) { ------------------ | Branch (1621:27): [True: 3.50M, False: 306k] ------------------ 1622| 3.50M| 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| 3.50M| if(bits < best_bits) { ------------------ | Branch (1623:6): [True: 440k, False: 3.06M] ------------------ 1624| 440k| best_index = indx; 1625| 440k| best_bits = bits; 1626| 440k| } 1627| 3.50M| } 1628| | 1629| 306k| return best_index+1; /* +1 since indx of lpc_error[] is order-1 */ 1630| 306k|} FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2: 52| 1.68M|{ 53| 1.68M| int i; 54| 1.68M| FLAC__int32 sum; 55| 1.68M| const __m128i cnt = _mm_cvtsi32_si128(lp_quantization); 56| | 57| 1.68M| FLAC__ASSERT(order > 0); ------------------ | | 38| 1.68M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.68M] | | ------------------ ------------------ 58| 1.68M| FLAC__ASSERT(order <= 32); ------------------ | | 38| 1.68M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.68M] | | ------------------ ------------------ 59| | 60| 1.68M| if(order <= 12) { ------------------ | Branch (60:5): [True: 1.30M, False: 382k] ------------------ 61| 1.30M| if(order > 8) { ------------------ | Branch (61:6): [True: 403k, False: 898k] ------------------ 62| 403k| if(order > 10) { ------------------ | Branch (62:7): [True: 201k, False: 202k] ------------------ 63| 201k| if(order == 12) { ------------------ | Branch (63:8): [True: 100k, False: 100k] ------------------ 64| 100k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11; 65| 100k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 66| 100k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 67| 100k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 68| 100k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 69| 100k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 70| 100k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 71| 100k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 72| 100k| q7 = _mm256_set1_epi32(0xffff & qlp_coeff[7 ]); 73| 100k| q8 = _mm256_set1_epi32(0xffff & qlp_coeff[8 ]); 74| 100k| q9 = _mm256_set1_epi32(0xffff & qlp_coeff[9 ]); 75| 100k| q10 = _mm256_set1_epi32(0xffff & qlp_coeff[10]); 76| 100k| q11 = _mm256_set1_epi32(0xffff & qlp_coeff[11]); 77| | 78| 1.78M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (78:17): [True: 1.68M, False: 100k] ------------------ 79| 1.68M| __m256i summ, mull; 80| 1.68M| summ = _mm256_madd_epi16(q11, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-12))); 81| 1.68M| mull = _mm256_madd_epi16(q10, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-11))); summ = _mm256_add_epi32(summ, mull); 82| 1.68M| mull = _mm256_madd_epi16(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); summ = _mm256_add_epi32(summ, mull); 83| 1.68M| mull = _mm256_madd_epi16(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9 ))); summ = _mm256_add_epi32(summ, mull); 84| 1.68M| mull = _mm256_madd_epi16(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8 ))); summ = _mm256_add_epi32(summ, mull); 85| 1.68M| mull = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); summ = _mm256_add_epi32(summ, mull); 86| 1.68M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 87| 1.68M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 88| 1.68M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 89| 1.68M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 90| 1.68M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 91| 1.68M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 92| 1.68M| summ = _mm256_sra_epi32(summ, cnt); 93| 1.68M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 94| 1.68M| } 95| 100k| } 96| 100k| else { /* order == 11 */ 97| 100k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10; 98| 100k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 99| 100k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 100| 100k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 101| 100k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 102| 100k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 103| 100k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 104| 100k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 105| 100k| q7 = _mm256_set1_epi32(0xffff & qlp_coeff[7 ]); 106| 100k| q8 = _mm256_set1_epi32(0xffff & qlp_coeff[8 ]); 107| 100k| q9 = _mm256_set1_epi32(0xffff & qlp_coeff[9 ]); 108| 100k| q10 = _mm256_set1_epi32(0xffff & qlp_coeff[10]); 109| | 110| 1.78M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (110:17): [True: 1.68M, False: 100k] ------------------ 111| 1.68M| __m256i summ, mull; 112| 1.68M| summ = _mm256_madd_epi16(q10, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-11))); 113| 1.68M| mull = _mm256_madd_epi16(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); summ = _mm256_add_epi32(summ, mull); 114| 1.68M| mull = _mm256_madd_epi16(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9 ))); summ = _mm256_add_epi32(summ, mull); 115| 1.68M| mull = _mm256_madd_epi16(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8 ))); summ = _mm256_add_epi32(summ, mull); 116| 1.68M| mull = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); summ = _mm256_add_epi32(summ, mull); 117| 1.68M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 118| 1.68M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 119| 1.68M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 120| 1.68M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 121| 1.68M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 122| 1.68M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 123| 1.68M| summ = _mm256_sra_epi32(summ, cnt); 124| 1.68M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 125| 1.68M| } 126| 100k| } 127| 201k| } 128| 202k| else { 129| 202k| if(order == 10) { ------------------ | Branch (129:8): [True: 101k, False: 101k] ------------------ 130| 101k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9; 131| 101k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 132| 101k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 133| 101k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 134| 101k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 135| 101k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 136| 101k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 137| 101k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 138| 101k| q7 = _mm256_set1_epi32(0xffff & qlp_coeff[7 ]); 139| 101k| q8 = _mm256_set1_epi32(0xffff & qlp_coeff[8 ]); 140| 101k| q9 = _mm256_set1_epi32(0xffff & qlp_coeff[9 ]); 141| | 142| 1.78M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (142:17): [True: 1.68M, False: 101k] ------------------ 143| 1.68M| __m256i summ, mull; 144| 1.68M| summ = _mm256_madd_epi16(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); 145| 1.68M| mull = _mm256_madd_epi16(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9 ))); summ = _mm256_add_epi32(summ, mull); 146| 1.68M| mull = _mm256_madd_epi16(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8 ))); summ = _mm256_add_epi32(summ, mull); 147| 1.68M| mull = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); summ = _mm256_add_epi32(summ, mull); 148| 1.68M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 149| 1.68M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 150| 1.68M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 151| 1.68M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 152| 1.68M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 153| 1.68M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 154| 1.68M| summ = _mm256_sra_epi32(summ, cnt); 155| 1.68M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 156| 1.68M| } 157| 101k| } 158| 101k| else { /* order == 9 */ 159| 101k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8; 160| 101k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 161| 101k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 162| 101k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 163| 101k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 164| 101k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 165| 101k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 166| 101k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 167| 101k| q7 = _mm256_set1_epi32(0xffff & qlp_coeff[7 ]); 168| 101k| q8 = _mm256_set1_epi32(0xffff & qlp_coeff[8 ]); 169| | 170| 1.82M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (170:17): [True: 1.72M, False: 101k] ------------------ 171| 1.72M| __m256i summ, mull; 172| 1.72M| summ = _mm256_madd_epi16(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9 ))); 173| 1.72M| mull = _mm256_madd_epi16(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8 ))); summ = _mm256_add_epi32(summ, mull); 174| 1.72M| mull = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); summ = _mm256_add_epi32(summ, mull); 175| 1.72M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 176| 1.72M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 177| 1.72M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 178| 1.72M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 179| 1.72M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 180| 1.72M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 181| 1.72M| summ = _mm256_sra_epi32(summ, cnt); 182| 1.72M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 183| 1.72M| } 184| 101k| } 185| 202k| } 186| 403k| } 187| 898k| else if(order > 4) { ------------------ | Branch (187:11): [True: 425k, False: 472k] ------------------ 188| 425k| if(order > 6) { ------------------ | Branch (188:7): [True: 209k, False: 215k] ------------------ 189| 209k| if(order == 8) { ------------------ | Branch (189:8): [True: 101k, False: 107k] ------------------ 190| 101k| __m256i q0, q1, q2, q3, q4, q5, q6, q7; 191| 101k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 192| 101k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 193| 101k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 194| 101k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 195| 101k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 196| 101k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 197| 101k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 198| 101k| q7 = _mm256_set1_epi32(0xffff & qlp_coeff[7 ]); 199| | 200| 1.86M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (200:17): [True: 1.76M, False: 101k] ------------------ 201| 1.76M| __m256i summ, mull; 202| 1.76M| summ = _mm256_madd_epi16(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8 ))); 203| 1.76M| mull = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); summ = _mm256_add_epi32(summ, mull); 204| 1.76M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 205| 1.76M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 206| 1.76M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 207| 1.76M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 208| 1.76M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 209| 1.76M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 210| 1.76M| summ = _mm256_sra_epi32(summ, cnt); 211| 1.76M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 212| 1.76M| } 213| 101k| } 214| 107k| else { /* order == 7 */ 215| 107k| __m256i q0, q1, q2, q3, q4, q5, q6; 216| 107k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 217| 107k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 218| 107k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 219| 107k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 220| 107k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 221| 107k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 222| 107k| q6 = _mm256_set1_epi32(0xffff & qlp_coeff[6 ]); 223| | 224| 1.91M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (224:17): [True: 1.80M, False: 107k] ------------------ 225| 1.80M| __m256i summ, mull; 226| 1.80M| summ = _mm256_madd_epi16(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7 ))); 227| 1.80M| mull = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); summ = _mm256_add_epi32(summ, mull); 228| 1.80M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 229| 1.80M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 230| 1.80M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 231| 1.80M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 232| 1.80M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 233| 1.80M| summ = _mm256_sra_epi32(summ, cnt); 234| 1.80M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 235| 1.80M| } 236| 107k| } 237| 209k| } 238| 215k| else { 239| 215k| if(order == 6) { ------------------ | Branch (239:8): [True: 107k, False: 108k] ------------------ 240| 107k| __m256i q0, q1, q2, q3, q4, q5; 241| 107k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 242| 107k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 243| 107k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 244| 107k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 245| 107k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 246| 107k| q5 = _mm256_set1_epi32(0xffff & qlp_coeff[5 ]); 247| | 248| 1.90M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (248:17): [True: 1.79M, False: 107k] ------------------ 249| 1.79M| __m256i summ, mull; 250| 1.79M| summ = _mm256_madd_epi16(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6 ))); 251| 1.79M| mull = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); summ = _mm256_add_epi32(summ, mull); 252| 1.79M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 253| 1.79M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 254| 1.79M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 255| 1.79M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 256| 1.79M| summ = _mm256_sra_epi32(summ, cnt); 257| 1.79M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 258| 1.79M| } 259| 107k| } 260| 108k| else { /* order == 5 */ 261| 108k| __m256i q0, q1, q2, q3, q4; 262| 108k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 263| 108k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 264| 108k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 265| 108k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 266| 108k| q4 = _mm256_set1_epi32(0xffff & qlp_coeff[4 ]); 267| | 268| 1.91M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (268:17): [True: 1.80M, False: 108k] ------------------ 269| 1.80M| __m256i summ, mull; 270| 1.80M| summ = _mm256_madd_epi16(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5 ))); 271| 1.80M| mull = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); summ = _mm256_add_epi32(summ, mull); 272| 1.80M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 273| 1.80M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 274| 1.80M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 275| 1.80M| summ = _mm256_sra_epi32(summ, cnt); 276| 1.80M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 277| 1.80M| } 278| 108k| } 279| 215k| } 280| 425k| } 281| 472k| else { 282| 472k| if(order > 2) { ------------------ | Branch (282:7): [True: 228k, False: 244k] ------------------ 283| 228k| if(order == 4) { ------------------ | Branch (283:8): [True: 111k, False: 116k] ------------------ 284| 111k| __m256i q0, q1, q2, q3; 285| 111k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 286| 111k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 287| 111k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 288| 111k| q3 = _mm256_set1_epi32(0xffff & qlp_coeff[3 ]); 289| | 290| 1.91M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (290:17): [True: 1.80M, False: 111k] ------------------ 291| 1.80M| __m256i summ, mull; 292| 1.80M| summ = _mm256_madd_epi16(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4 ))); 293| 1.80M| mull = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); summ = _mm256_add_epi32(summ, mull); 294| 1.80M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 295| 1.80M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 296| 1.80M| summ = _mm256_sra_epi32(summ, cnt); 297| 1.80M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 298| 1.80M| } 299| 111k| } 300| 116k| else { /* order == 3 */ 301| 116k| __m256i q0, q1, q2; 302| 116k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 303| 116k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 304| 116k| q2 = _mm256_set1_epi32(0xffff & qlp_coeff[2 ]); 305| | 306| 1.94M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (306:17): [True: 1.82M, False: 116k] ------------------ 307| 1.82M| __m256i summ, mull; 308| 1.82M| summ = _mm256_madd_epi16(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3 ))); 309| 1.82M| mull = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); summ = _mm256_add_epi32(summ, mull); 310| 1.82M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 311| 1.82M| summ = _mm256_sra_epi32(summ, cnt); 312| 1.82M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 313| 1.82M| } 314| 116k| } 315| 228k| } 316| 244k| else { 317| 244k| if(order == 2) { ------------------ | Branch (317:8): [True: 117k, False: 126k] ------------------ 318| 117k| __m256i q0, q1; 319| 117k| q0 = _mm256_set1_epi32(0xffff & qlp_coeff[0 ]); 320| 117k| q1 = _mm256_set1_epi32(0xffff & qlp_coeff[1 ]); 321| | 322| 1.94M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (322:17): [True: 1.82M, False: 117k] ------------------ 323| 1.82M| __m256i summ, mull; 324| 1.82M| summ = _mm256_madd_epi16(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2 ))); 325| 1.82M| mull = _mm256_madd_epi16(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1 ))); summ = _mm256_add_epi32(summ, mull); 326| 1.82M| summ = _mm256_sra_epi32(summ, cnt); 327| 1.82M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 328| 1.82M| } 329| 117k| } 330| 126k| else { /* order == 1 */ 331| 126k| __m256i q0; 332| 126k| 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: 126k] ------------------ 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| 126k| } 341| 244k| } 342| 472k| } 343| 6.37M| for(; i < (int)data_len; i++) { ------------------ | Branch (343:9): [True: 5.07M, False: 1.30M] ------------------ 344| 5.07M| sum = 0; 345| 5.07M| switch(order) { ------------------ | Branch (345:11): [True: 5.07M, False: 0] ------------------ 346| 429k| case 12: sum += qlp_coeff[11] * data[i-12]; /* Falls through. */ ------------------ | Branch (346:5): [True: 429k, False: 4.64M] ------------------ 347| 924k| case 11: sum += qlp_coeff[10] * data[i-11]; /* Falls through. */ ------------------ | Branch (347:5): [True: 495k, False: 4.57M] ------------------ 348| 1.51M| case 10: sum += qlp_coeff[ 9] * data[i-10]; /* Falls through. */ ------------------ | Branch (348:5): [True: 587k, False: 4.48M] ------------------ 349| 1.90M| case 9: sum += qlp_coeff[ 8] * data[i- 9]; /* Falls through. */ ------------------ | Branch (349:5): [True: 391k, False: 4.68M] ------------------ 350| 2.05M| case 8: sum += qlp_coeff[ 7] * data[i- 8]; /* Falls through. */ ------------------ | Branch (350:5): [True: 154k, False: 4.91M] ------------------ 351| 2.23M| case 7: sum += qlp_coeff[ 6] * data[i- 7]; /* Falls through. */ ------------------ | Branch (351:5): [True: 178k, False: 4.89M] ------------------ 352| 2.51M| case 6: sum += qlp_coeff[ 5] * data[i- 6]; /* Falls through. */ ------------------ | Branch (352:5): [True: 274k, False: 4.79M] ------------------ 353| 2.88M| case 5: sum += qlp_coeff[ 4] * data[i- 5]; /* Falls through. */ ------------------ | Branch (353:5): [True: 370k, False: 4.70M] ------------------ 354| 3.35M| case 4: sum += qlp_coeff[ 3] * data[i- 4]; /* Falls through. */ ------------------ | Branch (354:5): [True: 474k, False: 4.59M] ------------------ 355| 3.92M| case 3: sum += qlp_coeff[ 2] * data[i- 3]; /* Falls through. */ ------------------ | Branch (355:5): [True: 571k, False: 4.50M] ------------------ 356| 4.60M| case 2: sum += qlp_coeff[ 1] * data[i- 2]; /* Falls through. */ ------------------ | Branch (356:5): [True: 678k, False: 4.39M] ------------------ 357| 5.07M| case 1: sum += qlp_coeff[ 0] * data[i- 1]; ------------------ | Branch (357:5): [True: 467k, False: 4.60M] ------------------ 358| 5.07M| } 359| 5.07M| residual[i] = data[i] - (sum >> lp_quantization); 360| 5.07M| } 361| 1.30M| } 362| 382k| else { /* order > 12 */ 363| 261M| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (363:14): [True: 261M, False: 382k] ------------------ 364| 261M| sum = 0; 365| 261M| switch(order) { ------------------ | Branch (365:11): [True: 261M, False: 0] ------------------ 366| 13.0M| case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */ ------------------ | Branch (366:5): [True: 13.0M, False: 248M] ------------------ 367| 25.9M| case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */ ------------------ | Branch (367:5): [True: 12.8M, False: 248M] ------------------ 368| 38.8M| case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */ ------------------ | Branch (368:5): [True: 12.9M, False: 248M] ------------------ 369| 51.7M| case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */ ------------------ | Branch (369:5): [True: 12.9M, False: 248M] ------------------ 370| 64.7M| case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */ ------------------ | Branch (370:5): [True: 12.9M, False: 248M] ------------------ 371| 77.6M| case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */ ------------------ | Branch (371:5): [True: 12.9M, False: 248M] ------------------ 372| 90.5M| case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */ ------------------ | Branch (372:5): [True: 12.9M, False: 248M] ------------------ 373| 103M| case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */ ------------------ | Branch (373:5): [True: 12.9M, False: 248M] ------------------ 374| 116M| case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */ ------------------ | Branch (374:5): [True: 12.9M, False: 248M] ------------------ 375| 129M| case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */ ------------------ | Branch (375:5): [True: 12.9M, False: 248M] ------------------ 376| 142M| case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */ ------------------ | Branch (376:5): [True: 12.9M, False: 248M] ------------------ 377| 155M| case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */ ------------------ | Branch (377:5): [True: 12.9M, False: 248M] ------------------ 378| 168M| case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */ ------------------ | Branch (378:5): [True: 12.9M, False: 248M] ------------------ 379| 181M| case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */ ------------------ | Branch (379:5): [True: 12.9M, False: 248M] ------------------ 380| 194M| case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */ ------------------ | Branch (380:5): [True: 12.9M, False: 248M] ------------------ 381| 207M| case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */ ------------------ | Branch (381:5): [True: 13.0M, False: 248M] ------------------ 382| 220M| case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */ ------------------ | Branch (382:5): [True: 13.1M, False: 248M] ------------------ 383| 233M| case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */ ------------------ | Branch (383:5): [True: 13.4M, False: 248M] ------------------ 384| 247M| case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */ ------------------ | Branch (384:5): [True: 13.6M, False: 247M] ------------------ 385| 261M| case 13: sum += qlp_coeff[12] * data[i-13]; ------------------ | Branch (385:5): [True: 13.8M, False: 247M] ------------------ 386| 261M| sum += qlp_coeff[11] * data[i-12]; 387| 261M| sum += qlp_coeff[10] * data[i-11]; 388| 261M| sum += qlp_coeff[ 9] * data[i-10]; 389| 261M| sum += qlp_coeff[ 8] * data[i- 9]; 390| 261M| sum += qlp_coeff[ 7] * data[i- 8]; 391| 261M| sum += qlp_coeff[ 6] * data[i- 7]; 392| 261M| sum += qlp_coeff[ 5] * data[i- 6]; 393| 261M| sum += qlp_coeff[ 4] * data[i- 5]; 394| 261M| sum += qlp_coeff[ 3] * data[i- 4]; 395| 261M| sum += qlp_coeff[ 2] * data[i- 3]; 396| 261M| sum += qlp_coeff[ 1] * data[i- 2]; 397| 261M| sum += qlp_coeff[ 0] * data[i- 1]; 398| 261M| } 399| 261M| residual[i] = data[i] - (sum >> lp_quantization); 400| 261M| } 401| 382k| } 402| 1.68M| _mm256_zeroupper(); 403| 1.68M|} FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2: 407| 1.64M|{ 408| 1.64M| int i; 409| 1.64M| FLAC__int32 sum; 410| 1.64M| const __m128i cnt = _mm_cvtsi32_si128(lp_quantization); 411| | 412| 1.64M| FLAC__ASSERT(order > 0); ------------------ | | 38| 1.64M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.64M] | | ------------------ ------------------ 413| 1.64M| FLAC__ASSERT(order <= 32); ------------------ | | 38| 1.64M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.64M] | | ------------------ ------------------ 414| | 415| 1.64M| if(order <= 12) { ------------------ | Branch (415:5): [True: 1.36M, False: 285k] ------------------ 416| 1.36M| if(order > 8) { ------------------ | Branch (416:6): [True: 363k, False: 998k] ------------------ 417| 363k| if(order > 10) { ------------------ | Branch (417:7): [True: 178k, False: 184k] ------------------ 418| 178k| if(order == 12) { ------------------ | Branch (418:8): [True: 88.4k, False: 90.2k] ------------------ 419| 88.4k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11; 420| 88.4k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 421| 88.4k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 422| 88.4k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 423| 88.4k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 424| 88.4k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 425| 88.4k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 426| 88.4k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 427| 88.4k| q7 = _mm256_set1_epi32(qlp_coeff[7 ]); 428| 88.4k| q8 = _mm256_set1_epi32(qlp_coeff[8 ]); 429| 88.4k| q9 = _mm256_set1_epi32(qlp_coeff[9 ]); 430| 88.4k| q10 = _mm256_set1_epi32(qlp_coeff[10]); 431| 88.4k| q11 = _mm256_set1_epi32(qlp_coeff[11]); 432| | 433| 747k| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (433:17): [True: 658k, False: 88.4k] ------------------ 434| 658k| __m256i summ, mull; 435| 658k| summ = _mm256_mullo_epi32(q11, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-12))); 436| 658k| mull = _mm256_mullo_epi32(q10, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-11))); summ = _mm256_add_epi32(summ, mull); 437| 658k| mull = _mm256_mullo_epi32(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); summ = _mm256_add_epi32(summ, mull); 438| 658k| mull = _mm256_mullo_epi32(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9))); summ = _mm256_add_epi32(summ, mull); 439| 658k| mull = _mm256_mullo_epi32(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8))); summ = _mm256_add_epi32(summ, mull); 440| 658k| mull = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); summ = _mm256_add_epi32(summ, mull); 441| 658k| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 442| 658k| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 443| 658k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 444| 658k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 445| 658k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 446| 658k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 447| 658k| summ = _mm256_sra_epi32(summ, cnt); 448| 658k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 449| 658k| } 450| 88.4k| } 451| 90.2k| else { /* order == 11 */ 452| 90.2k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10; 453| 90.2k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 454| 90.2k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 455| 90.2k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 456| 90.2k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 457| 90.2k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 458| 90.2k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 459| 90.2k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 460| 90.2k| q7 = _mm256_set1_epi32(qlp_coeff[7 ]); 461| 90.2k| q8 = _mm256_set1_epi32(qlp_coeff[8 ]); 462| 90.2k| q9 = _mm256_set1_epi32(qlp_coeff[9 ]); 463| 90.2k| q10 = _mm256_set1_epi32(qlp_coeff[10]); 464| | 465| 774k| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (465:17): [True: 684k, False: 90.2k] ------------------ 466| 684k| __m256i summ, mull; 467| 684k| summ = _mm256_mullo_epi32(q10, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-11))); 468| 684k| mull = _mm256_mullo_epi32(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); summ = _mm256_add_epi32(summ, mull); 469| 684k| mull = _mm256_mullo_epi32(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9))); summ = _mm256_add_epi32(summ, mull); 470| 684k| mull = _mm256_mullo_epi32(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8))); summ = _mm256_add_epi32(summ, mull); 471| 684k| mull = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); summ = _mm256_add_epi32(summ, mull); 472| 684k| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 473| 684k| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 474| 684k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 475| 684k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 476| 684k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 477| 684k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 478| 684k| summ = _mm256_sra_epi32(summ, cnt); 479| 684k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 480| 684k| } 481| 90.2k| } 482| 178k| } 483| 184k| else { 484| 184k| if(order == 10) { ------------------ | Branch (484:8): [True: 91.4k, False: 92.8k] ------------------ 485| 91.4k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9; 486| 91.4k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 487| 91.4k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 488| 91.4k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 489| 91.4k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 490| 91.4k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 491| 91.4k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 492| 91.4k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 493| 91.4k| q7 = _mm256_set1_epi32(qlp_coeff[7 ]); 494| 91.4k| q8 = _mm256_set1_epi32(qlp_coeff[8 ]); 495| 91.4k| q9 = _mm256_set1_epi32(qlp_coeff[9 ]); 496| | 497| 787k| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (497:17): [True: 696k, False: 91.4k] ------------------ 498| 696k| __m256i summ, mull; 499| 696k| summ = _mm256_mullo_epi32(q9, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-10))); 500| 696k| mull = _mm256_mullo_epi32(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9))); summ = _mm256_add_epi32(summ, mull); 501| 696k| mull = _mm256_mullo_epi32(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8))); summ = _mm256_add_epi32(summ, mull); 502| 696k| mull = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); summ = _mm256_add_epi32(summ, mull); 503| 696k| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 504| 696k| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 505| 696k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 506| 696k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 507| 696k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 508| 696k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 509| 696k| summ = _mm256_sra_epi32(summ, cnt); 510| 696k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 511| 696k| } 512| 91.4k| } 513| 92.8k| else { /* order == 9 */ 514| 92.8k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8; 515| 92.8k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 516| 92.8k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 517| 92.8k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 518| 92.8k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 519| 92.8k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 520| 92.8k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 521| 92.8k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 522| 92.8k| q7 = _mm256_set1_epi32(qlp_coeff[7 ]); 523| 92.8k| q8 = _mm256_set1_epi32(qlp_coeff[8 ]); 524| | 525| 848k| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (525:17): [True: 755k, False: 92.8k] ------------------ 526| 755k| __m256i summ, mull; 527| 755k| summ = _mm256_mullo_epi32(q8, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-9))); 528| 755k| mull = _mm256_mullo_epi32(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8))); summ = _mm256_add_epi32(summ, mull); 529| 755k| mull = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); summ = _mm256_add_epi32(summ, mull); 530| 755k| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 531| 755k| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 532| 755k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 533| 755k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 534| 755k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 535| 755k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 536| 755k| summ = _mm256_sra_epi32(summ, cnt); 537| 755k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 538| 755k| } 539| 92.8k| } 540| 184k| } 541| 363k| } 542| 998k| else if(order > 4) { ------------------ | Branch (542:11): [True: 405k, False: 592k] ------------------ 543| 405k| if(order > 6) { ------------------ | Branch (543:7): [True: 193k, False: 212k] ------------------ 544| 193k| if(order == 8) { ------------------ | Branch (544:8): [True: 94.1k, False: 98.8k] ------------------ 545| 94.1k| __m256i q0, q1, q2, q3, q4, q5, q6, q7; 546| 94.1k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 547| 94.1k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 548| 94.1k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 549| 94.1k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 550| 94.1k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 551| 94.1k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 552| 94.1k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 553| 94.1k| q7 = _mm256_set1_epi32(qlp_coeff[7 ]); 554| | 555| 888k| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (555:17): [True: 794k, False: 94.1k] ------------------ 556| 794k| __m256i summ, mull; 557| 794k| summ = _mm256_mullo_epi32(q7, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-8))); 558| 794k| mull = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); summ = _mm256_add_epi32(summ, mull); 559| 794k| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 560| 794k| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 561| 794k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 562| 794k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 563| 794k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 564| 794k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 565| 794k| summ = _mm256_sra_epi32(summ, cnt); 566| 794k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 567| 794k| } 568| 94.1k| } 569| 98.8k| else { /* order == 7 */ 570| 98.8k| __m256i q0, q1, q2, q3, q4, q5, q6; 571| 98.8k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 572| 98.8k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 573| 98.8k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 574| 98.8k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 575| 98.8k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 576| 98.8k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 577| 98.8k| q6 = _mm256_set1_epi32(qlp_coeff[6 ]); 578| | 579| 1.02M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (579:17): [True: 930k, False: 98.8k] ------------------ 580| 930k| __m256i summ, mull; 581| 930k| summ = _mm256_mullo_epi32(q6, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-7))); 582| 930k| mull = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); summ = _mm256_add_epi32(summ, mull); 583| 930k| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 584| 930k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 585| 930k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 586| 930k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 587| 930k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 588| 930k| summ = _mm256_sra_epi32(summ, cnt); 589| 930k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 590| 930k| } 591| 98.8k| } 592| 193k| } 593| 212k| else { 594| 212k| if(order == 6) { ------------------ | Branch (594:8): [True: 101k, False: 110k] ------------------ 595| 101k| __m256i q0, q1, q2, q3, q4, q5; 596| 101k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 597| 101k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 598| 101k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 599| 101k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 600| 101k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 601| 101k| q5 = _mm256_set1_epi32(qlp_coeff[5 ]); 602| | 603| 1.04M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (603:17): [True: 943k, False: 101k] ------------------ 604| 943k| __m256i summ, mull; 605| 943k| summ = _mm256_mullo_epi32(q5, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-6))); 606| 943k| mull = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); summ = _mm256_add_epi32(summ, mull); 607| 943k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 608| 943k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 609| 943k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 610| 943k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 611| 943k| summ = _mm256_sra_epi32(summ, cnt); 612| 943k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 613| 943k| } 614| 101k| } 615| 110k| else { /* order == 5 */ 616| 110k| __m256i q0, q1, q2, q3, q4; 617| 110k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 618| 110k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 619| 110k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 620| 110k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 621| 110k| q4 = _mm256_set1_epi32(qlp_coeff[4 ]); 622| | 623| 1.08M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (623:17): [True: 971k, False: 110k] ------------------ 624| 971k| __m256i summ, mull; 625| 971k| summ = _mm256_mullo_epi32(q4, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-5))); 626| 971k| mull = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); summ = _mm256_add_epi32(summ, mull); 627| 971k| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 628| 971k| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 629| 971k| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 630| 971k| summ = _mm256_sra_epi32(summ, cnt); 631| 971k| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 632| 971k| } 633| 110k| } 634| 212k| } 635| 405k| } 636| 592k| else { 637| 592k| if(order > 2) { ------------------ | Branch (637:7): [True: 243k, False: 349k] ------------------ 638| 243k| if(order == 4) { ------------------ | Branch (638:8): [True: 117k, False: 126k] ------------------ 639| 117k| __m256i q0, q1, q2, q3; 640| 117k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 641| 117k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 642| 117k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 643| 117k| q3 = _mm256_set1_epi32(qlp_coeff[3 ]); 644| | 645| 1.16M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (645:17): [True: 1.04M, False: 117k] ------------------ 646| 1.04M| __m256i summ, mull; 647| 1.04M| summ = _mm256_mullo_epi32(q3, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-4))); 648| 1.04M| mull = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); summ = _mm256_add_epi32(summ, mull); 649| 1.04M| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 650| 1.04M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 651| 1.04M| summ = _mm256_sra_epi32(summ, cnt); 652| 1.04M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 653| 1.04M| } 654| 117k| } 655| 126k| else { /* order == 3 */ 656| 126k| __m256i q0, q1, q2; 657| 126k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 658| 126k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 659| 126k| q2 = _mm256_set1_epi32(qlp_coeff[2 ]); 660| | 661| 1.42M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (661:17): [True: 1.30M, False: 126k] ------------------ 662| 1.30M| __m256i summ, mull; 663| 1.30M| summ = _mm256_mullo_epi32(q2, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-3))); 664| 1.30M| mull = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); summ = _mm256_add_epi32(summ, mull); 665| 1.30M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 666| 1.30M| summ = _mm256_sra_epi32(summ, cnt); 667| 1.30M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 668| 1.30M| } 669| 126k| } 670| 243k| } 671| 349k| else { 672| 349k| if(order == 2) { ------------------ | Branch (672:8): [True: 131k, False: 217k] ------------------ 673| 131k| __m256i q0, q1; 674| 131k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 675| 131k| q1 = _mm256_set1_epi32(qlp_coeff[1 ]); 676| | 677| 1.66M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (677:17): [True: 1.53M, False: 131k] ------------------ 678| 1.53M| __m256i summ, mull; 679| 1.53M| summ = _mm256_mullo_epi32(q1, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-2))); 680| 1.53M| mull = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); summ = _mm256_add_epi32(summ, mull); 681| 1.53M| summ = _mm256_sra_epi32(summ, cnt); 682| 1.53M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 683| 1.53M| } 684| 131k| } 685| 217k| else { /* order == 1 */ 686| 217k| __m256i q0; 687| 217k| q0 = _mm256_set1_epi32(qlp_coeff[0 ]); 688| | 689| 2.07M| for(i = 0; i < (int)data_len-7; i+=8) { ------------------ | Branch (689:17): [True: 1.85M, False: 217k] ------------------ 690| 1.85M| __m256i summ; 691| 1.85M| summ = _mm256_mullo_epi32(q0, _mm256_loadu_si256((const __m256i*)(const void*)(data+i-1))); 692| 1.85M| summ = _mm256_sra_epi32(summ, cnt); 693| 1.85M| _mm256_storeu_si256((__m256i*)(void*)(residual+i), _mm256_sub_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(data+i)), summ)); 694| 1.85M| } 695| 217k| } 696| 349k| } 697| 592k| } 698| 6.41M| for(; i < (int)data_len; i++) { ------------------ | Branch (698:9): [True: 5.05M, False: 1.36M] ------------------ 699| 5.05M| sum = 0; 700| 5.05M| switch(order) { ------------------ | Branch (700:11): [True: 5.06M, False: 18.4E] ------------------ 701| 356k| case 12: sum += qlp_coeff[11] * data[i-12]; /* Falls through. */ ------------------ | Branch (701:5): [True: 356k, False: 4.69M] ------------------ 702| 760k| case 11: sum += qlp_coeff[10] * data[i-11]; /* Falls through. */ ------------------ | Branch (702:5): [True: 404k, False: 4.64M] ------------------ 703| 1.25M| case 10: sum += qlp_coeff[ 9] * data[i-10]; /* Falls through. */ ------------------ | Branch (703:5): [True: 490k, False: 4.56M] ------------------ 704| 1.47M| case 9: sum += qlp_coeff[ 8] * data[i- 9]; /* Falls through. */ ------------------ | Branch (704:5): [True: 221k, False: 4.83M] ------------------ 705| 1.62M| case 8: sum += qlp_coeff[ 7] * data[i- 8]; /* Falls through. */ ------------------ | Branch (705:5): [True: 155k, False: 4.89M] ------------------ 706| 1.87M| case 7: sum += qlp_coeff[ 6] * data[i- 7]; /* Falls through. */ ------------------ | Branch (706:5): [True: 245k, False: 4.80M] ------------------ 707| 2.21M| case 6: sum += qlp_coeff[ 5] * data[i- 6]; /* Falls through. */ ------------------ | Branch (707:5): [True: 341k, False: 4.71M] ------------------ 708| 2.67M| case 5: sum += qlp_coeff[ 4] * data[i- 5]; /* Falls through. */ ------------------ | Branch (708:5): [True: 460k, False: 4.59M] ------------------ 709| 3.13M| case 4: sum += qlp_coeff[ 3] * data[i- 4]; /* Falls through. */ ------------------ | Branch (709:5): [True: 459k, False: 4.59M] ------------------ 710| 3.69M| case 3: sum += qlp_coeff[ 2] * data[i- 3]; /* Falls through. */ ------------------ | Branch (710:5): [True: 556k, False: 4.49M] ------------------ 711| 4.38M| case 2: sum += qlp_coeff[ 1] * data[i- 2]; /* Falls through. */ ------------------ | Branch (711:5): [True: 690k, False: 4.36M] ------------------ 712| 5.06M| case 1: sum += qlp_coeff[ 0] * data[i- 1]; ------------------ | Branch (712:5): [True: 679k, False: 4.37M] ------------------ 713| 5.05M| } 714| 5.05M| residual[i] = data[i] - (sum >> lp_quantization); 715| 5.05M| } 716| 1.36M| } 717| 285k| else { /* order > 12 */ 718| 75.1M| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (718:14): [True: 74.8M, False: 285k] ------------------ 719| 74.8M| sum = 0; 720| 74.8M| switch(order) { ------------------ | Branch (720:11): [True: 74.8M, False: 18.4E] ------------------ 721| 3.08M| case 32: sum += qlp_coeff[31] * data[i-32]; /* Falls through. */ ------------------ | Branch (721:5): [True: 3.08M, False: 71.8M] ------------------ 722| 6.33M| case 31: sum += qlp_coeff[30] * data[i-31]; /* Falls through. */ ------------------ | Branch (722:5): [True: 3.25M, False: 71.6M] ------------------ 723| 9.65M| case 30: sum += qlp_coeff[29] * data[i-30]; /* Falls through. */ ------------------ | Branch (723:5): [True: 3.31M, False: 71.5M] ------------------ 724| 12.9M| case 29: sum += qlp_coeff[28] * data[i-29]; /* Falls through. */ ------------------ | Branch (724:5): [True: 3.32M, False: 71.5M] ------------------ 725| 16.3M| case 28: sum += qlp_coeff[27] * data[i-28]; /* Falls through. */ ------------------ | Branch (725:5): [True: 3.34M, False: 71.5M] ------------------ 726| 19.6M| case 27: sum += qlp_coeff[26] * data[i-27]; /* Falls through. */ ------------------ | Branch (726:5): [True: 3.37M, False: 71.5M] ------------------ 727| 23.1M| case 26: sum += qlp_coeff[25] * data[i-26]; /* Falls through. */ ------------------ | Branch (727:5): [True: 3.44M, False: 71.4M] ------------------ 728| 26.6M| case 25: sum += qlp_coeff[24] * data[i-25]; /* Falls through. */ ------------------ | Branch (728:5): [True: 3.48M, False: 71.4M] ------------------ 729| 30.1M| case 24: sum += qlp_coeff[23] * data[i-24]; /* Falls through. */ ------------------ | Branch (729:5): [True: 3.53M, False: 71.3M] ------------------ 730| 33.7M| case 23: sum += qlp_coeff[22] * data[i-23]; /* Falls through. */ ------------------ | Branch (730:5): [True: 3.54M, False: 71.3M] ------------------ 731| 37.2M| case 22: sum += qlp_coeff[21] * data[i-22]; /* Falls through. */ ------------------ | Branch (731:5): [True: 3.57M, False: 71.3M] ------------------ 732| 40.9M| case 21: sum += qlp_coeff[20] * data[i-21]; /* Falls through. */ ------------------ | Branch (732:5): [True: 3.65M, False: 71.2M] ------------------ 733| 44.6M| case 20: sum += qlp_coeff[19] * data[i-20]; /* Falls through. */ ------------------ | Branch (733:5): [True: 3.73M, False: 71.1M] ------------------ 734| 48.4M| case 19: sum += qlp_coeff[18] * data[i-19]; /* Falls through. */ ------------------ | Branch (734:5): [True: 3.77M, False: 71.1M] ------------------ 735| 52.2M| case 18: sum += qlp_coeff[17] * data[i-18]; /* Falls through. */ ------------------ | Branch (735:5): [True: 3.82M, False: 71.0M] ------------------ 736| 56.1M| case 17: sum += qlp_coeff[16] * data[i-17]; /* Falls through. */ ------------------ | Branch (736:5): [True: 3.86M, False: 71.0M] ------------------ 737| 60.0M| case 16: sum += qlp_coeff[15] * data[i-16]; /* Falls through. */ ------------------ | Branch (737:5): [True: 3.94M, False: 70.9M] ------------------ 738| 64.0M| case 15: sum += qlp_coeff[14] * data[i-15]; /* Falls through. */ ------------------ | Branch (738:5): [True: 4.02M, False: 70.8M] ------------------ 739| 69.4M| case 14: sum += qlp_coeff[13] * data[i-14]; /* Falls through. */ ------------------ | Branch (739:5): [True: 5.33M, False: 69.5M] ------------------ 740| 74.8M| case 13: sum += qlp_coeff[12] * data[i-13]; ------------------ | Branch (740:5): [True: 5.45M, False: 69.4M] ------------------ 741| 74.8M| sum += qlp_coeff[11] * data[i-12]; 742| 74.8M| sum += qlp_coeff[10] * data[i-11]; 743| 74.8M| sum += qlp_coeff[ 9] * data[i-10]; 744| 74.8M| sum += qlp_coeff[ 8] * data[i- 9]; 745| 74.8M| sum += qlp_coeff[ 7] * data[i- 8]; 746| 74.8M| sum += qlp_coeff[ 6] * data[i- 7]; 747| 74.8M| sum += qlp_coeff[ 5] * data[i- 6]; 748| 74.8M| sum += qlp_coeff[ 4] * data[i- 5]; 749| 74.8M| sum += qlp_coeff[ 3] * data[i- 4]; 750| 74.8M| sum += qlp_coeff[ 2] * data[i- 3]; 751| 74.8M| sum += qlp_coeff[ 1] * data[i- 2]; 752| 74.8M| sum += qlp_coeff[ 0] * data[i- 1]; 753| 74.8M| } 754| 74.8M| residual[i] = data[i] - (sum >> lp_quantization); 755| 74.8M| } 756| 285k| } 757| 1.64M| _mm256_zeroupper(); 758| 1.64M|} FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2: 764| 2.57M|{ 765| 2.57M| int i; 766| 2.57M| FLAC__int64 sum; 767| 2.57M| const __m128i cnt = _mm_cvtsi32_si128(lp_quantization); 768| 2.57M| const __m256i pack = _mm256_loadu_si256((const __m256i *)(const void*)pack_arr); 769| | 770| 2.57M| FLAC__ASSERT(order > 0); ------------------ | | 38| 2.57M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 2.57M] | | ------------------ ------------------ 771| 2.57M| FLAC__ASSERT(order <= 32); ------------------ | | 38| 2.57M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 2.57M] | | ------------------ ------------------ 772| 2.57M| FLAC__ASSERT(lp_quantization <= 32); /* there's no _mm256_sra_epi64() so we have to use _mm256_srl_epi64() */ ------------------ | | 38| 2.57M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 2.57M] | | ------------------ ------------------ 773| | 774| 2.57M| if(order <= 12) { ------------------ | Branch (774:5): [True: 2.04M, False: 528k] ------------------ 775| 2.04M| if(order > 8) { ------------------ | Branch (775:6): [True: 683k, False: 1.36M] ------------------ 776| 683k| if(order > 10) { ------------------ | Branch (776:7): [True: 342k, False: 340k] ------------------ 777| 342k| if(order == 12) { ------------------ | Branch (777:8): [True: 171k, False: 171k] ------------------ 778| 171k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11; 779| 171k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 780| 171k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 781| 171k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 782| 171k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 783| 171k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 784| 171k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 785| 171k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 786| 171k| q7 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[7 ])); 787| 171k| q8 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[8 ])); 788| 171k| q9 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[9 ])); 789| 171k| q10 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[10])); 790| 171k| q11 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[11])); 791| | 792| 5.99M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (792:17): [True: 5.82M, False: 171k] ------------------ 793| 5.82M| __m256i summ, mull; 794| 5.82M| summ = _mm256_mul_epi32(q11, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-12)))); 795| 5.82M| 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.82M| 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.82M| 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.82M| 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.82M| 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.82M| 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.82M| 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.82M| 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.82M| 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.82M| 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.82M| 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.82M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 807| 5.82M| _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.82M| } 809| 171k| } 810| 171k| else { /* order == 11 */ 811| 171k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10; 812| 171k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 813| 171k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 814| 171k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 815| 171k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 816| 171k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 817| 171k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 818| 171k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 819| 171k| q7 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[7 ])); 820| 171k| q8 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[8 ])); 821| 171k| q9 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[9 ])); 822| 171k| q10 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[10])); 823| | 824| 5.95M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (824:17): [True: 5.78M, False: 171k] ------------------ 825| 5.78M| __m256i summ, mull; 826| 5.78M| summ = _mm256_mul_epi32(q10, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-11)))); 827| 5.78M| 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.78M| 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.78M| 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.78M| 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.78M| 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.78M| 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.78M| 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.78M| 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.78M| 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.78M| 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.78M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 838| 5.78M| _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.78M| } 840| 171k| } 841| 342k| } 842| 340k| else { 843| 340k| if(order == 10) { ------------------ | Branch (843:8): [True: 170k, False: 169k] ------------------ 844| 170k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8, q9; 845| 170k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 846| 170k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 847| 170k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 848| 170k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 849| 170k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 850| 170k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 851| 170k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 852| 170k| q7 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[7 ])); 853| 170k| q8 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[8 ])); 854| 170k| q9 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[9 ])); 855| | 856| 5.94M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (856:17): [True: 5.77M, False: 170k] ------------------ 857| 5.77M| __m256i summ, mull; 858| 5.77M| summ = _mm256_mul_epi32(q9, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-10)))); 859| 5.77M| 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.77M| 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.77M| 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.77M| 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.77M| 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.77M| 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.77M| 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.77M| 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.77M| 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.77M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 869| 5.77M| _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.77M| } 871| 170k| } 872| 169k| else { /* order == 9 */ 873| 169k| __m256i q0, q1, q2, q3, q4, q5, q6, q7, q8; 874| 169k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 875| 169k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 876| 169k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 877| 169k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 878| 169k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 879| 169k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 880| 169k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 881| 169k| q7 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[7 ])); 882| 169k| q8 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[8 ])); 883| | 884| 6.07M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (884:17): [True: 5.90M, False: 169k] ------------------ 885| 5.90M| __m256i summ, mull; 886| 5.90M| summ = _mm256_mul_epi32(q8, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-9 )))); 887| 5.90M| 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.90M| 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.90M| 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.90M| 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.90M| 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.90M| 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.90M| 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.90M| 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.90M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 896| 5.90M| _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.90M| } 898| 169k| } 899| 340k| } 900| 683k| } 901| 1.36M| else if(order > 4) { ------------------ | Branch (901:11): [True: 668k, False: 696k] ------------------ 902| 668k| if(order > 6) { ------------------ | Branch (902:7): [True: 336k, False: 331k] ------------------ 903| 336k| if(order == 8) { ------------------ | Branch (903:8): [True: 169k, False: 167k] ------------------ 904| 169k| __m256i q0, q1, q2, q3, q4, q5, q6, q7; 905| 169k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 906| 169k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 907| 169k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 908| 169k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 909| 169k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 910| 169k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 911| 169k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 912| 169k| 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.92M, False: 169k] ------------------ 915| 5.92M| __m256i summ, mull; 916| 5.92M| summ = _mm256_mul_epi32(q7, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-8 )))); 917| 5.92M| 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.92M| 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.92M| 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.92M| 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.92M| 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.92M| 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.92M| 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.92M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 925| 5.92M| _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.92M| } 927| 169k| } 928| 167k| else { /* order == 7 */ 929| 167k| __m256i q0, q1, q2, q3, q4, q5, q6; 930| 167k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 931| 167k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 932| 167k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 933| 167k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 934| 167k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 935| 167k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 936| 167k| q6 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[6 ])); 937| | 938| 5.84M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (938:17): [True: 5.67M, False: 167k] ------------------ 939| 5.67M| __m256i summ, mull; 940| 5.67M| summ = _mm256_mul_epi32(q6, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-7 )))); 941| 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); 942| 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); 943| 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); 944| 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); 945| 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); 946| 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); 947| 5.67M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 948| 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))); 949| 5.67M| } 950| 167k| } 951| 336k| } 952| 331k| else { 953| 331k| if(order == 6) { ------------------ | Branch (953:8): [True: 165k, False: 166k] ------------------ 954| 165k| __m256i q0, q1, q2, q3, q4, q5; 955| 165k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 956| 165k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 957| 165k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 958| 165k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 959| 165k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 960| 165k| q5 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[5 ])); 961| | 962| 5.81M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (962:17): [True: 5.65M, False: 165k] ------------------ 963| 5.65M| __m256i summ, mull; 964| 5.65M| summ = _mm256_mul_epi32(q5, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-6 )))); 965| 5.65M| 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.65M| 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.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); 968| 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); 969| 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); 970| 5.65M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 971| 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))); 972| 5.65M| } 973| 165k| } 974| 166k| else { /* order == 5 */ 975| 166k| __m256i q0, q1, q2, q3, q4; 976| 166k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 977| 166k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 978| 166k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 979| 166k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 980| 166k| q4 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[4 ])); 981| | 982| 5.90M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (982:17): [True: 5.74M, False: 166k] ------------------ 983| 5.74M| __m256i summ, mull; 984| 5.74M| summ = _mm256_mul_epi32(q4, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-5 )))); 985| 5.74M| 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.74M| 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.74M| 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.74M| 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.74M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 990| 5.74M| _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.74M| } 992| 166k| } 993| 331k| } 994| 668k| } 995| 696k| else { 996| 696k| if(order > 2) { ------------------ | Branch (996:7): [True: 320k, False: 376k] ------------------ 997| 320k| if(order == 4) { ------------------ | Branch (997:8): [True: 164k, False: 155k] ------------------ 998| 164k| __m256i q0, q1, q2, q3; 999| 164k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 1000| 164k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 1001| 164k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 1002| 164k| q3 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[3 ])); 1003| | 1004| 5.82M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (1004:17): [True: 5.66M, False: 164k] ------------------ 1005| 5.66M| __m256i summ, mull; 1006| 5.66M| summ = _mm256_mul_epi32(q3, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-4 )))); 1007| 5.66M| 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.66M| 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.66M| 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.66M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 1011| 5.66M| _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.66M| } 1013| 164k| } 1014| 155k| else { /* order == 3 */ 1015| 155k| __m256i q0, q1, q2; 1016| 155k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 1017| 155k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 1018| 155k| q2 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[2 ])); 1019| | 1020| 5.31M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (1020:17): [True: 5.16M, False: 155k] ------------------ 1021| 5.16M| __m256i summ, mull; 1022| 5.16M| summ = _mm256_mul_epi32(q2, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-3 )))); 1023| 5.16M| 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.16M| 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.16M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 1026| 5.16M| _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.16M| } 1028| 155k| } 1029| 320k| } 1030| 376k| else { 1031| 376k| if(order == 2) { ------------------ | Branch (1031:8): [True: 150k, False: 225k] ------------------ 1032| 150k| __m256i q0, q1; 1033| 150k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 1034| 150k| q1 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[1 ])); 1035| | 1036| 4.87M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (1036:17): [True: 4.72M, False: 150k] ------------------ 1037| 4.72M| __m256i summ, mull; 1038| 4.72M| summ = _mm256_mul_epi32(q1, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-2 )))); 1039| 4.72M| 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| 4.72M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 1041| 4.72M| _mm_storeu_si128((__m128i*)(void*)(residual+i), _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(const void*)(data+i)), _mm256_castsi256_si128(summ))); 1042| 4.72M| } 1043| 150k| } 1044| 225k| else { /* order == 1 */ 1045| 225k| __m256i q0; 1046| 225k| q0 = _mm256_cvtepu32_epi64(_mm_set1_epi32(qlp_coeff[0 ])); 1047| | 1048| 5.31M| for(i = 0; i < (int)data_len-3; i+=4) { ------------------ | Branch (1048:17): [True: 5.09M, False: 225k] ------------------ 1049| 5.09M| __m256i summ; 1050| 5.09M| summ = _mm256_mul_epi32(q0, _mm256_cvtepu32_epi64(_mm_loadu_si128((const __m128i*)(const void*)(data+i-1 )))); 1051| 5.09M| summ = _mm256_permutevar8x32_epi32(_mm256_srl_epi64(summ, cnt), pack); 1052| 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))); 1053| 5.09M| } 1054| 225k| } 1055| 376k| } 1056| 696k| } 1057| 5.01M| for(; i < (int)data_len; i++) { ------------------ | Branch (1057:9): [True: 2.96M, False: 2.04M] ------------------ 1058| 2.96M| sum = 0; 1059| 2.96M| switch(order) { ------------------ | Branch (1059:11): [True: 2.97M, False: 18.4E] ------------------ 1060| 128k| case 12: sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; /* Falls through. */ ------------------ | Branch (1060:5): [True: 128k, False: 2.83M] ------------------ 1061| 406k| case 11: sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; /* Falls through. */ ------------------ | Branch (1061:5): [True: 278k, False: 2.68M] ------------------ 1062| 839k| case 10: sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10]; /* Falls through. */ ------------------ | Branch (1062:5): [True: 432k, False: 2.53M] ------------------ 1063| 1.02M| case 9: sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9]; /* Falls through. */ ------------------ | Branch (1063:5): [True: 187k, False: 2.78M] ------------------ 1064| 1.15M| case 8: sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8]; /* Falls through. */ ------------------ | Branch (1064:5): [True: 127k, False: 2.83M] ------------------ 1065| 1.42M| case 7: sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7]; /* Falls through. */ ------------------ | Branch (1065:5): [True: 269k, False: 2.69M] ------------------ 1066| 1.84M| case 6: sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6]; /* Falls through. */ ------------------ | Branch (1066:5): [True: 415k, False: 2.55M] ------------------ 1067| 2.02M| case 5: sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5]; /* Falls through. */ ------------------ | Branch (1067:5): [True: 186k, False: 2.78M] ------------------ 1068| 2.15M| case 4: sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4]; /* Falls through. */ ------------------ | Branch (1068:5): [True: 127k, False: 2.83M] ------------------ 1069| 2.40M| case 3: sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3]; /* Falls through. */ ------------------ | Branch (1069:5): [True: 254k, False: 2.71M] ------------------ 1070| 2.79M| case 2: sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2]; /* Falls through. */ ------------------ | Branch (1070:5): [True: 381k, False: 2.58M] ------------------ 1071| 2.97M| case 1: sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1]; ------------------ | Branch (1071:5): [True: 186k, False: 2.78M] ------------------ 1072| 2.96M| } 1073| 2.96M| residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization); 1074| 2.96M| } 1075| 2.04M| } 1076| 528k| else { /* order > 12 */ 1077| 231M| for(i = 0; i < (int)data_len; i++) { ------------------ | Branch (1077:14): [True: 231M, False: 526k] ------------------ 1078| 231M| sum = 0; 1079| 231M| switch(order) { ------------------ | Branch (1079:11): [True: 231M, False: 18.4E] ------------------ 1080| 10.2M| case 32: sum += qlp_coeff[31] * (FLAC__int64)data[i-32]; /* Falls through. */ ------------------ | Branch (1080:5): [True: 10.2M, False: 220M] ------------------ 1081| 20.5M| case 31: sum += qlp_coeff[30] * (FLAC__int64)data[i-31]; /* Falls through. */ ------------------ | Branch (1081:5): [True: 10.3M, False: 220M] ------------------ 1082| 30.9M| case 30: sum += qlp_coeff[29] * (FLAC__int64)data[i-30]; /* Falls through. */ ------------------ | Branch (1082:5): [True: 10.3M, False: 220M] ------------------ 1083| 41.2M| case 29: sum += qlp_coeff[28] * (FLAC__int64)data[i-29]; /* Falls through. */ ------------------ | Branch (1083:5): [True: 10.3M, False: 220M] ------------------ 1084| 51.5M| case 28: sum += qlp_coeff[27] * (FLAC__int64)data[i-28]; /* Falls through. */ ------------------ | Branch (1084:5): [True: 10.3M, False: 220M] ------------------ 1085| 61.8M| case 27: sum += qlp_coeff[26] * (FLAC__int64)data[i-27]; /* Falls through. */ ------------------ | Branch (1085:5): [True: 10.3M, False: 220M] ------------------ 1086| 72.1M| case 26: sum += qlp_coeff[25] * (FLAC__int64)data[i-26]; /* Falls through. */ ------------------ | Branch (1086:5): [True: 10.2M, False: 220M] ------------------ 1087| 82.3M| case 25: sum += qlp_coeff[24] * (FLAC__int64)data[i-25]; /* Falls through. */ ------------------ | Branch (1087:5): [True: 10.2M, False: 220M] ------------------ 1088| 92.5M| case 24: sum += qlp_coeff[23] * (FLAC__int64)data[i-24]; /* Falls through. */ ------------------ | Branch (1088:5): [True: 10.2M, False: 220M] ------------------ 1089| 102M| case 23: sum += qlp_coeff[22] * (FLAC__int64)data[i-23]; /* Falls through. */ ------------------ | Branch (1089:5): [True: 10.2M, False: 220M] ------------------ 1090| 113M| case 22: sum += qlp_coeff[21] * (FLAC__int64)data[i-22]; /* Falls through. */ ------------------ | Branch (1090:5): [True: 10.2M, False: 220M] ------------------ 1091| 123M| case 21: sum += qlp_coeff[20] * (FLAC__int64)data[i-21]; /* Falls through. */ ------------------ | Branch (1091:5): [True: 10.1M, False: 220M] ------------------ 1092| 133M| case 20: sum += qlp_coeff[19] * (FLAC__int64)data[i-20]; /* Falls through. */ ------------------ | Branch (1092:5): [True: 10.0M, False: 221M] ------------------ 1093| 143M| case 19: sum += qlp_coeff[18] * (FLAC__int64)data[i-19]; /* Falls through. */ ------------------ | Branch (1093:5): [True: 10.1M, False: 220M] ------------------ 1094| 153M| case 18: sum += qlp_coeff[17] * (FLAC__int64)data[i-18]; /* Falls through. */ ------------------ | Branch (1094:5): [True: 10.1M, False: 221M] ------------------ 1095| 163M| case 17: sum += qlp_coeff[16] * (FLAC__int64)data[i-17]; /* Falls through. */ ------------------ | Branch (1095:5): [True: 10.0M, False: 221M] ------------------ 1096| 173M| case 16: sum += qlp_coeff[15] * (FLAC__int64)data[i-16]; /* Falls through. */ ------------------ | Branch (1096:5): [True: 10.0M, False: 221M] ------------------ 1097| 183M| case 15: sum += qlp_coeff[14] * (FLAC__int64)data[i-15]; /* Falls through. */ ------------------ | Branch (1097:5): [True: 10.0M, False: 221M] ------------------ 1098| 207M| case 14: sum += qlp_coeff[13] * (FLAC__int64)data[i-14]; /* Falls through. */ ------------------ | Branch (1098:5): [True: 24.0M, False: 207M] ------------------ 1099| 231M| case 13: sum += qlp_coeff[12] * (FLAC__int64)data[i-13]; ------------------ | Branch (1099:5): [True: 23.3M, False: 207M] ------------------ 1100| 231M| sum += qlp_coeff[11] * (FLAC__int64)data[i-12]; 1101| 231M| sum += qlp_coeff[10] * (FLAC__int64)data[i-11]; 1102| 231M| sum += qlp_coeff[ 9] * (FLAC__int64)data[i-10]; 1103| 231M| sum += qlp_coeff[ 8] * (FLAC__int64)data[i- 9]; 1104| 231M| sum += qlp_coeff[ 7] * (FLAC__int64)data[i- 8]; 1105| 231M| sum += qlp_coeff[ 6] * (FLAC__int64)data[i- 7]; 1106| 231M| sum += qlp_coeff[ 5] * (FLAC__int64)data[i- 6]; 1107| 231M| sum += qlp_coeff[ 4] * (FLAC__int64)data[i- 5]; 1108| 231M| sum += qlp_coeff[ 3] * (FLAC__int64)data[i- 4]; 1109| 231M| sum += qlp_coeff[ 2] * (FLAC__int64)data[i- 3]; 1110| 231M| sum += qlp_coeff[ 1] * (FLAC__int64)data[i- 2]; 1111| 231M| sum += qlp_coeff[ 0] * (FLAC__int64)data[i- 1]; 1112| 231M| } 1113| 231M| residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization); 1114| 231M| } 1115| 528k| } 1116| 2.57M| _mm256_zeroupper(); 1117| 2.57M|} FLAC__lpc_compute_autocorrelation_intrin_fma_lag_8: 48| 10.7k|{ 49| 10.7k|#undef MAX_LAG 50| 10.7k|#define MAX_LAG 8 51| 10.7k|#include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 10.7k| int i, j; | | 2| 10.7k| (void) lag; | | 3| 10.7k| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 10.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 10.7k] | | | | ------------------ | | ------------------ | | 4| | | | 5| 96.7k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 50| 96.7k|#define MAX_LAG 8 | | ------------------ | | | Branch (5:20): [True: 85.9k, False: 10.7k] | | ------------------ | | 6| 85.9k| autoc[i] = 0.0; | | 7| | | | 8| 96.7k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 50| 96.7k|#define MAX_LAG 8 | | ------------------ | | | Branch (8:20): [True: 85.9k, False: 10.7k] | | ------------------ | | 9| 472k| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 386k, False: 85.9k] | | ------------------ | | 10| 386k| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 6.43M| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 50| 10.7k|#define MAX_LAG 8 | | ------------------ | | | Branch (12:26): [True: 6.42M, False: 10.7k] | | ------------------ | | 13| 57.8M| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 50| 57.8M|#define MAX_LAG 8 | | ------------------ | | | Branch (13:14): [True: 51.4M, False: 6.42M] | | ------------------ | | 14| 51.4M| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 52| 10.7k|} FLAC__lpc_compute_autocorrelation_intrin_fma_lag_12: 56| 16.8k|{ 57| 16.8k|#undef MAX_LAG 58| 16.8k|#define MAX_LAG 12 59| 16.8k|#include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 16.8k| int i, j; | | 2| 16.8k| (void) lag; | | 3| 16.8k| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 16.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 16.8k] | | | | ------------------ | | ------------------ | | 4| | | | 5| 219k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 58| 219k|#define MAX_LAG 12 | | ------------------ | | | Branch (5:20): [True: 202k, False: 16.8k] | | ------------------ | | 6| 202k| autoc[i] = 0.0; | | 7| | | | 8| 219k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 58| 219k|#define MAX_LAG 12 | | ------------------ | | | Branch (8:20): [True: 202k, False: 16.8k] | | ------------------ | | 9| 1.52M| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 1.31M, False: 202k] | | ------------------ | | 10| 1.31M| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 4.54M| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 58| 16.8k|#define MAX_LAG 12 | | ------------------ | | | Branch (12:26): [True: 4.52M, False: 16.8k] | | ------------------ | | 13| 58.8M| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 58| 58.8M|#define MAX_LAG 12 | | ------------------ | | | Branch (13:14): [True: 54.3M, False: 4.52M] | | ------------------ | | 14| 54.3M| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 60| 16.8k|} FLAC__lpc_compute_autocorrelation_intrin_fma_lag_16: 63| 7.74k|{ 64| 7.74k|#undef MAX_LAG 65| 7.74k|#define MAX_LAG 16 66| 7.74k|#include "deduplication/lpc_compute_autocorrelation_intrin.c" ------------------ | | 1| 7.74k| int i, j; | | 2| 7.74k| (void) lag; | | 3| 7.74k| FLAC__ASSERT(lag <= MAX_LAG); | | ------------------ | | | | 38| 7.74k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | | | ------------------ | | | | | Branch (38:28): [True: 0, False: 7.74k] | | | | ------------------ | | ------------------ | | 4| | | | 5| 131k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 65| 131k|#define MAX_LAG 16 | | ------------------ | | | Branch (5:20): [True: 123k, False: 7.74k] | | ------------------ | | 6| 123k| autoc[i] = 0.0; | | 7| | | | 8| 128k| for(i = 0; i < MAX_LAG; i++) | | ------------------ | | | | 65| 128k|#define MAX_LAG 16 | | ------------------ | | | Branch (8:20): [True: 121k, False: 7.74k] | | ------------------ | | 9| 1.12M| for(j = 0; j <= i; j++) | | ------------------ | | | Branch (9:28): [True: 1.00M, False: 121k] | | ------------------ | | 10| 1.00M| autoc[j] += (double)data[i] * (double)data[i-j]; | | 11| | | | 12| 5.04M| for(i = MAX_LAG; i < (int)data_len; i++) | | ------------------ | | | | 65| 7.74k|#define MAX_LAG 16 | | ------------------ | | | Branch (12:26): [True: 5.03M, False: 7.74k] | | ------------------ | | 13| 85.5M| for(j = 0; j < MAX_LAG; j++) | | ------------------ | | | | 65| 85.5M|#define MAX_LAG 16 | | ------------------ | | | Branch (13:14): [True: 80.4M, False: 5.03M] | | ------------------ | | 14| 80.4M| autoc[j] += (double)data[i] * (double)data[i-j]; ------------------ 67| | 68| 7.74k|} FLAC__MD5Init: 224| 18.5k|{ 225| 18.5k| ctx->buf[0] = 0x67452301; 226| 18.5k| ctx->buf[1] = 0xefcdab89; 227| 18.5k| ctx->buf[2] = 0x98badcfe; 228| 18.5k| ctx->buf[3] = 0x10325476; 229| | 230| 18.5k| ctx->bytes[0] = 0; 231| 18.5k| ctx->bytes[1] = 0; 232| | 233| 18.5k| ctx->internal_buf.p8 = 0; 234| 18.5k| ctx->capacity = 0; 235| 18.5k|} FLAC__MD5Final: 242| 18.5k|{ 243| 18.5k| int count = ctx->bytes[0] & 0x3f; /* Number of bytes in ctx->in */ 244| 18.5k| FLAC__byte *p = (FLAC__byte *)ctx->in + count; 245| | 246| | /* Set the first char of padding to 0x80. There is always room. */ 247| 18.5k| *p++ = 0x80; 248| | 249| | /* Bytes of padding needed to make 56 bytes (-8..55) */ 250| 18.5k| count = 56 - 1 - count; 251| | 252| 18.5k| if (count < 0) { /* Padding forces an extra block */ ------------------ | Branch (252:6): [True: 758, False: 17.8k] ------------------ 253| 758| memset(p, 0, count + 8); 254| 758| byteSwapX16(ctx->in); 255| 758| FLAC__MD5Transform(ctx->buf, ctx->in); 256| 758| p = (FLAC__byte *)ctx->in; 257| 758| count = 56; 258| 758| } 259| 18.5k| memset(p, 0, count); 260| 18.5k| byteSwap(ctx->in, 14); 261| | 262| | /* Append length in bits and transform */ 263| 18.5k| ctx->in[14] = ctx->bytes[0] << 3; 264| 18.5k| ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29; 265| 18.5k| FLAC__MD5Transform(ctx->buf, ctx->in); 266| | 267| 18.5k| byteSwap(ctx->buf, 4); 268| 18.5k| memcpy(digest, ctx->buf, 16); 269| 18.5k| if (0 != ctx->internal_buf.p8) { ------------------ | Branch (269:6): [True: 8.97k, False: 9.58k] ------------------ 270| 8.97k| free(ctx->internal_buf.p8); 271| 8.97k| ctx->internal_buf.p8 = 0; 272| 8.97k| ctx->capacity = 0; 273| 8.97k| } 274| 18.5k| memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */ 275| 18.5k|} FLAC__MD5Accumulate: 498| 201k|{ 499| 201k| const size_t bytes_needed = (size_t)channels * (size_t)samples * (size_t)bytes_per_sample; 500| | 501| | /* overflow check */ 502| 201k| if ((size_t)channels > SIZE_MAX / (size_t)bytes_per_sample) ------------------ | Branch (502:6): [True: 0, False: 201k] ------------------ 503| 0| return false; 504| 201k| if ((size_t)channels * (size_t)bytes_per_sample > SIZE_MAX / (size_t)samples) ------------------ | Branch (504:6): [True: 0, False: 201k] ------------------ 505| 0| return false; 506| | 507| 201k| if (ctx->capacity < bytes_needed) { ------------------ | Branch (507:6): [True: 9.49k, False: 192k] ------------------ 508| 9.49k| if (0 == (ctx->internal_buf.p8 = safe_realloc_(ctx->internal_buf.p8, bytes_needed))) { ------------------ | Branch (508:7): [True: 0, False: 9.49k] ------------------ 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.49k| ctx->capacity = bytes_needed; 515| 9.49k| } 516| | 517| 201k| format_input_(&ctx->internal_buf, signal, channels, samples, bytes_per_sample); 518| | 519| 201k| FLAC__MD5Update(ctx, ctx->internal_buf.p8, bytes_needed); 520| | 521| | return true; 522| 201k|} 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| 201k|{ 282| 201k| FLAC__byte *buf_ = mbuf->p8; 283| 201k| FLAC__int16 *buf16 = mbuf->p16; 284| 201k| FLAC__int32 *buf32 = mbuf->p32; 285| 201k| FLAC__int32 a_word; 286| 201k| uint32_t channel, sample; 287| | 288| | /* Storage in the output buffer, buf, is little endian. */ 289| | 290| 201k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) 291| | 292| | /* First do the most commonly used combinations. */ 293| 201k| switch (BYTES_CHANNEL_SELECTOR (bytes_per_sample, channels)) { ------------------ | | 290| 201k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ 294| | /* One byte per sample. */ 295| 3.99k| case (BYTES_CHANNEL_SELECTOR (1, 1)): ------------------ | | 290| 3.99k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (295:3): [True: 3.99k, False: 197k] ------------------ 296| 1.67M| for (sample = 0; sample < samples; sample++) ------------------ | Branch (296:21): [True: 1.67M, False: 3.99k] ------------------ 297| 1.67M| *buf_++ = signal[0][sample]; 298| 3.99k| return; 299| | 300| 1.40k| case (BYTES_CHANNEL_SELECTOR (1, 2)): ------------------ | | 290| 1.40k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (300:3): [True: 1.40k, False: 200k] ------------------ 301| 57.2k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (301:21): [True: 55.8k, False: 1.40k] ------------------ 302| 55.8k| *buf_++ = signal[0][sample]; 303| 55.8k| *buf_++ = signal[1][sample]; 304| 55.8k| } 305| 1.40k| return; 306| | 307| 414| case (BYTES_CHANNEL_SELECTOR (1, 4)): ------------------ | | 290| 414|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (307:3): [True: 414, False: 201k] ------------------ 308| 7.22k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (308:21): [True: 6.81k, False: 414] ------------------ 309| 6.81k| *buf_++ = signal[0][sample]; 310| 6.81k| *buf_++ = signal[1][sample]; 311| 6.81k| *buf_++ = signal[2][sample]; 312| 6.81k| *buf_++ = signal[3][sample]; 313| 6.81k| } 314| 414| return; 315| | 316| 211| case (BYTES_CHANNEL_SELECTOR (1, 6)): ------------------ | | 290| 211|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (316:3): [True: 211, False: 201k] ------------------ 317| 13.6k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (317:21): [True: 13.3k, False: 211] ------------------ 318| 13.3k| *buf_++ = signal[0][sample]; 319| 13.3k| *buf_++ = signal[1][sample]; 320| 13.3k| *buf_++ = signal[2][sample]; 321| 13.3k| *buf_++ = signal[3][sample]; 322| 13.3k| *buf_++ = signal[4][sample]; 323| 13.3k| *buf_++ = signal[5][sample]; 324| 13.3k| } 325| 211| return; 326| | 327| 240| case (BYTES_CHANNEL_SELECTOR (1, 8)): ------------------ | | 290| 240|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (327:3): [True: 240, False: 201k] ------------------ 328| 3.97k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (328:21): [True: 3.73k, False: 240] ------------------ 329| 3.73k| *buf_++ = signal[0][sample]; 330| 3.73k| *buf_++ = signal[1][sample]; 331| 3.73k| *buf_++ = signal[2][sample]; 332| 3.73k| *buf_++ = signal[3][sample]; 333| 3.73k| *buf_++ = signal[4][sample]; 334| 3.73k| *buf_++ = signal[5][sample]; 335| 3.73k| *buf_++ = signal[6][sample]; 336| 3.73k| *buf_++ = signal[7][sample]; 337| 3.73k| } 338| 240| return; 339| | 340| | /* Two bytes per sample. */ 341| 2.08k| case (BYTES_CHANNEL_SELECTOR (2, 1)): ------------------ | | 290| 2.08k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (341:3): [True: 2.08k, False: 199k] ------------------ 342| 80.0k| for (sample = 0; sample < samples; sample++) ------------------ | Branch (342:21): [True: 77.9k, False: 2.08k] ------------------ 343| 77.9k| *buf16++ = H2LE_16(signal[0][sample]); ------------------ | | 81| 80.0k|#define H2LE_16(x) (x) ------------------ 344| 2.08k| return; 345| | 346| 2.19k| case (BYTES_CHANNEL_SELECTOR (2, 2)): ------------------ | | 290| 2.19k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (346:3): [True: 2.19k, False: 199k] ------------------ 347| 49.0k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (347:21): [True: 46.8k, False: 2.19k] ------------------ 348| 46.8k| *buf16++ = H2LE_16(signal[0][sample]); ------------------ | | 81| 46.8k|#define H2LE_16(x) (x) ------------------ 349| 46.8k| *buf16++ = H2LE_16(signal[1][sample]); ------------------ | | 81| 46.8k|#define H2LE_16(x) (x) ------------------ 350| 46.8k| } 351| 2.19k| return; 352| | 353| 444| case (BYTES_CHANNEL_SELECTOR (2, 4)): ------------------ | | 290| 444|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (353:3): [True: 444, False: 201k] ------------------ 354| 7.73k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (354:21): [True: 7.28k, False: 444] ------------------ 355| 7.28k| *buf16++ = H2LE_16(signal[0][sample]); ------------------ | | 81| 7.28k|#define H2LE_16(x) (x) ------------------ 356| 7.28k| *buf16++ = H2LE_16(signal[1][sample]); ------------------ | | 81| 7.28k|#define H2LE_16(x) (x) ------------------ 357| 7.28k| *buf16++ = H2LE_16(signal[2][sample]); ------------------ | | 81| 7.28k|#define H2LE_16(x) (x) ------------------ 358| 7.28k| *buf16++ = H2LE_16(signal[3][sample]); ------------------ | | 81| 7.28k|#define H2LE_16(x) (x) ------------------ 359| 7.28k| } 360| 444| return; 361| | 362| 408| case (BYTES_CHANNEL_SELECTOR (2, 6)): ------------------ | | 290| 408|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (362:3): [True: 408, False: 201k] ------------------ 363| 10.9k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (363:21): [True: 10.5k, False: 408] ------------------ 364| 10.5k| *buf16++ = H2LE_16(signal[0][sample]); ------------------ | | 81| 10.5k|#define H2LE_16(x) (x) ------------------ 365| 10.5k| *buf16++ = H2LE_16(signal[1][sample]); ------------------ | | 81| 10.5k|#define H2LE_16(x) (x) ------------------ 366| 10.5k| *buf16++ = H2LE_16(signal[2][sample]); ------------------ | | 81| 10.5k|#define H2LE_16(x) (x) ------------------ 367| 10.5k| *buf16++ = H2LE_16(signal[3][sample]); ------------------ | | 81| 10.5k|#define H2LE_16(x) (x) ------------------ 368| 10.5k| *buf16++ = H2LE_16(signal[4][sample]); ------------------ | | 81| 10.5k|#define H2LE_16(x) (x) ------------------ 369| 10.5k| *buf16++ = H2LE_16(signal[5][sample]); ------------------ | | 81| 10.5k|#define H2LE_16(x) (x) ------------------ 370| 10.5k| } 371| 408| return; 372| | 373| 256| case (BYTES_CHANNEL_SELECTOR (2, 8)): ------------------ | | 290| 256|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (373:3): [True: 256, False: 201k] ------------------ 374| 4.21k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (374:21): [True: 3.95k, False: 256] ------------------ 375| 3.95k| *buf16++ = H2LE_16(signal[0][sample]); ------------------ | | 81| 3.95k|#define H2LE_16(x) (x) ------------------ 376| 3.95k| *buf16++ = H2LE_16(signal[1][sample]); ------------------ | | 81| 3.95k|#define H2LE_16(x) (x) ------------------ 377| 3.95k| *buf16++ = H2LE_16(signal[2][sample]); ------------------ | | 81| 3.95k|#define H2LE_16(x) (x) ------------------ 378| 3.95k| *buf16++ = H2LE_16(signal[3][sample]); ------------------ | | 81| 3.95k|#define H2LE_16(x) (x) ------------------ 379| 3.95k| *buf16++ = H2LE_16(signal[4][sample]); ------------------ | | 81| 3.95k|#define H2LE_16(x) (x) ------------------ 380| 3.95k| *buf16++ = H2LE_16(signal[5][sample]); ------------------ | | 81| 3.95k|#define H2LE_16(x) (x) ------------------ 381| 3.95k| *buf16++ = H2LE_16(signal[6][sample]); ------------------ | | 81| 3.95k|#define H2LE_16(x) (x) ------------------ 382| 3.95k| *buf16++ = H2LE_16(signal[7][sample]); ------------------ | | 81| 3.95k|#define H2LE_16(x) (x) ------------------ 383| 3.95k| } 384| 256| return; 385| | 386| | /* Three bytes per sample. */ 387| 1.81k| case (BYTES_CHANNEL_SELECTOR (3, 1)): ------------------ | | 290| 1.81k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (387:3): [True: 1.81k, False: 199k] ------------------ 388| 746k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (388:21): [True: 745k, False: 1.81k] ------------------ 389| 745k| a_word = signal[0][sample]; 390| 745k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 391| 745k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 392| 745k| *buf_++ = (FLAC__byte)a_word; 393| 745k| } 394| 1.81k| return; 395| | 396| 7.95k| case (BYTES_CHANNEL_SELECTOR (3, 2)): ------------------ | | 290| 7.95k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (396:3): [True: 7.95k, False: 193k] ------------------ 397| 287k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (397:21): [True: 279k, False: 7.95k] ------------------ 398| 279k| a_word = signal[0][sample]; 399| 279k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 400| 279k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 401| 279k| *buf_++ = (FLAC__byte)a_word; 402| 279k| a_word = signal[1][sample]; 403| 279k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 404| 279k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 405| 279k| *buf_++ = (FLAC__byte)a_word; 406| 279k| } 407| 7.95k| return; 408| | 409| | /* Four bytes per sample. */ 410| 146k| case (BYTES_CHANNEL_SELECTOR (4, 1)): ------------------ | | 290| 146k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (410:3): [True: 146k, False: 55.1k] ------------------ 411| 15.8M| for (sample = 0; sample < samples; sample++) ------------------ | Branch (411:21): [True: 15.7M, False: 146k] ------------------ 412| 15.7M| *buf32++ = H2LE_32(signal[0][sample]); ------------------ | | 82| 15.8M|#define H2LE_32(x) (x) ------------------ 413| 146k| return; 414| | 415| 30.0k| case (BYTES_CHANNEL_SELECTOR (4, 2)): ------------------ | | 290| 30.0k|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (415:3): [True: 30.0k, False: 171k] ------------------ 416| 4.59M| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (416:21): [True: 4.56M, False: 30.0k] ------------------ 417| 4.56M| *buf32++ = H2LE_32(signal[0][sample]); ------------------ | | 82| 4.56M|#define H2LE_32(x) (x) ------------------ 418| 4.56M| *buf32++ = H2LE_32(signal[1][sample]); ------------------ | | 82| 4.56M|#define H2LE_32(x) (x) ------------------ 419| 4.56M| } 420| 30.0k| return; 421| | 422| 834| case (BYTES_CHANNEL_SELECTOR (4, 4)): ------------------ | | 290| 834|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (422:3): [True: 834, False: 200k] ------------------ 423| 57.0k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (423:21): [True: 56.2k, False: 834] ------------------ 424| 56.2k| *buf32++ = H2LE_32(signal[0][sample]); ------------------ | | 82| 56.2k|#define H2LE_32(x) (x) ------------------ 425| 56.2k| *buf32++ = H2LE_32(signal[1][sample]); ------------------ | | 82| 56.2k|#define H2LE_32(x) (x) ------------------ 426| 56.2k| *buf32++ = H2LE_32(signal[2][sample]); ------------------ | | 82| 56.2k|#define H2LE_32(x) (x) ------------------ 427| 56.2k| *buf32++ = H2LE_32(signal[3][sample]); ------------------ | | 82| 56.2k|#define H2LE_32(x) (x) ------------------ 428| 56.2k| } 429| 834| return; 430| | 431| 866| case (BYTES_CHANNEL_SELECTOR (4, 6)): ------------------ | | 290| 866|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (431:3): [True: 866, False: 200k] ------------------ 432| 34.6k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (432:21): [True: 33.7k, False: 866] ------------------ 433| 33.7k| *buf32++ = H2LE_32(signal[0][sample]); ------------------ | | 82| 33.7k|#define H2LE_32(x) (x) ------------------ 434| 33.7k| *buf32++ = H2LE_32(signal[1][sample]); ------------------ | | 82| 33.7k|#define H2LE_32(x) (x) ------------------ 435| 33.7k| *buf32++ = H2LE_32(signal[2][sample]); ------------------ | | 82| 33.7k|#define H2LE_32(x) (x) ------------------ 436| 33.7k| *buf32++ = H2LE_32(signal[3][sample]); ------------------ | | 82| 33.7k|#define H2LE_32(x) (x) ------------------ 437| 33.7k| *buf32++ = H2LE_32(signal[4][sample]); ------------------ | | 82| 33.7k|#define H2LE_32(x) (x) ------------------ 438| 33.7k| *buf32++ = H2LE_32(signal[5][sample]); ------------------ | | 82| 33.7k|#define H2LE_32(x) (x) ------------------ 439| 33.7k| } 440| 866| return; 441| | 442| 658| case (BYTES_CHANNEL_SELECTOR (4, 8)): ------------------ | | 290| 658|#define BYTES_CHANNEL_SELECTOR(bytes, channels) (bytes * 100 + channels) ------------------ | Branch (442:3): [True: 658, False: 200k] ------------------ 443| 26.2k| for (sample = 0; sample < samples; sample++) { ------------------ | Branch (443:21): [True: 25.5k, False: 658] ------------------ 444| 25.5k| *buf32++ = H2LE_32(signal[0][sample]); ------------------ | | 82| 25.5k|#define H2LE_32(x) (x) ------------------ 445| 25.5k| *buf32++ = H2LE_32(signal[1][sample]); ------------------ | | 82| 25.5k|#define H2LE_32(x) (x) ------------------ 446| 25.5k| *buf32++ = H2LE_32(signal[2][sample]); ------------------ | | 82| 25.5k|#define H2LE_32(x) (x) ------------------ 447| 25.5k| *buf32++ = H2LE_32(signal[3][sample]); ------------------ | | 82| 25.5k|#define H2LE_32(x) (x) ------------------ 448| 25.5k| *buf32++ = H2LE_32(signal[4][sample]); ------------------ | | 82| 25.5k|#define H2LE_32(x) (x) ------------------ 449| 25.5k| *buf32++ = H2LE_32(signal[5][sample]); ------------------ | | 82| 25.5k|#define H2LE_32(x) (x) ------------------ 450| 25.5k| *buf32++ = H2LE_32(signal[6][sample]); ------------------ | | 82| 25.5k|#define H2LE_32(x) (x) ------------------ 451| 25.5k| *buf32++ = H2LE_32(signal[7][sample]); ------------------ | | 82| 25.5k|#define H2LE_32(x) (x) ------------------ 452| 25.5k| } 453| 658| return; 454| | 455| 1.41k| default: ------------------ | Branch (455:3): [True: 1.41k, False: 200k] ------------------ 456| 1.41k| break; 457| 201k| } 458| | 459| | /* General version. */ 460| 1.41k| switch (bytes_per_sample) { 461| 269| case 1: ------------------ | Branch (461:3): [True: 269, False: 1.14k] ------------------ 462| 4.43k| for (sample = 0; sample < samples; sample++) ------------------ | Branch (462:21): [True: 4.16k, False: 269] ------------------ 463| 17.2k| for (channel = 0; channel < channels; channel++) ------------------ | Branch (463:23): [True: 13.0k, False: 4.16k] ------------------ 464| 13.0k| *buf_++ = signal[channel][sample]; 465| 269| return; 466| | 467| 230| case 2: ------------------ | Branch (467:3): [True: 230, False: 1.18k] ------------------ 468| 3.86k| for (sample = 0; sample < samples; sample++) ------------------ | Branch (468:21): [True: 3.63k, False: 230] ------------------ 469| 14.9k| for (channel = 0; channel < channels; channel++) ------------------ | Branch (469:23): [True: 11.2k, False: 3.63k] ------------------ 470| 11.2k| *buf16++ = H2LE_16(signal[channel][sample]); ------------------ | | 81| 11.5k|#define H2LE_16(x) (x) ------------------ 471| 230| return; 472| | 473| 425| case 3: ------------------ | Branch (473:3): [True: 425, False: 992] ------------------ 474| 9.73k| for (sample = 0; sample < samples; sample++) ------------------ | Branch (474:21): [True: 9.30k, False: 425] ------------------ 475| 39.2k| for (channel = 0; channel < channels; channel++) { ------------------ | Branch (475:23): [True: 29.9k, False: 9.30k] ------------------ 476| 29.9k| a_word = signal[channel][sample]; 477| 29.9k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 478| 29.9k| *buf_++ = (FLAC__byte)a_word; a_word >>= 8; 479| 29.9k| *buf_++ = (FLAC__byte)a_word; 480| 29.9k| } 481| 425| return; 482| | 483| 493| case 4: ------------------ | Branch (483:3): [True: 493, False: 924] ------------------ 484| 48.0k| for (sample = 0; sample < samples; sample++) ------------------ | Branch (484:21): [True: 47.5k, False: 493] ------------------ 485| 337k| for (channel = 0; channel < channels; channel++) ------------------ | Branch (485:23): [True: 290k, False: 47.5k] ------------------ 486| 290k| *buf32++ = H2LE_32(signal[channel][sample]); ------------------ | | 82| 290k|#define H2LE_32(x) (x) ------------------ 487| 493| return; 488| | 489| 0| default: ------------------ | Branch (489:3): [True: 0, False: 1.41k] ------------------ 490| 0| break; 491| 1.41k| } 492| 1.41k|} md5.c:FLAC__MD5Update: 185| 201k|{ 186| 201k| FLAC__uint32 t; 187| | 188| | /* Update byte count */ 189| | 190| 201k| t = ctx->bytes[0]; 191| 201k| if ((ctx->bytes[0] = t + len) < t) ------------------ | Branch (191:6): [True: 0, False: 201k] ------------------ 192| 0| ctx->bytes[1]++; /* Carry from low to high */ 193| | 194| 201k| t = 64 - (t & 0x3f); /* Space available in ctx->in (at least 1) */ 195| 201k| if (t > len) { ------------------ | Branch (195:6): [True: 8.85k, False: 192k] ------------------ 196| 8.85k| memcpy((FLAC__byte *)ctx->in + 64 - t, buf, len); 197| 8.85k| return; 198| 8.85k| } 199| | /* First chunk is an odd size */ 200| 192k| memcpy((FLAC__byte *)ctx->in + 64 - t, buf, t); 201| 192k| byteSwapX16(ctx->in); 202| 192k| FLAC__MD5Transform(ctx->buf, ctx->in); 203| 192k| buf += t; 204| 192k| len -= t; 205| | 206| | /* Process data in 64-byte chunks */ 207| 1.70M| while (len >= 64) { ------------------ | Branch (207:9): [True: 1.51M, False: 192k] ------------------ 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| 192k| memcpy(ctx->in, buf, len); 217| 192k|} FLAC__memory_alloc_aligned: 47| 366k|{ 48| 366k| void *x; 49| | 50| 366k| FLAC__ASSERT(0 != aligned_address); ------------------ | | 38| 366k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 366k] | | ------------------ ------------------ 51| | 52| 366k|#ifdef FLAC__ALIGN_MALLOC_DATA 53| | /* align on 32-byte (256-bit) boundary */ 54| 366k| x = safe_malloc_add_2op_(bytes, /*+*/31L); 55| 366k| *aligned_address = (void*)(((uintptr_t)x + 31L) & -32L); 56| |#else 57| | x = safe_malloc_(bytes); 58| | *aligned_address = x; 59| |#endif 60| 366k| return x; 61| 366k|} FLAC__memory_alloc_aligned_int32_array: 64| 267k|{ 65| 267k| FLAC__int32 *pu; /* unaligned pointer */ 66| 267k| union { /* union needed to comply with C99 pointer aliasing rules */ 67| 267k| FLAC__int32 *pa; /* aligned pointer */ 68| 267k| void *pv; /* aligned pointer alias */ 69| 267k| } u; 70| | 71| 267k| FLAC__ASSERT(elements > 0); ------------------ | | 38| 267k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 267k] | | ------------------ ------------------ 72| 267k| FLAC__ASSERT(0 != unaligned_pointer); ------------------ | | 38| 267k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 267k] | | ------------------ ------------------ 73| 267k| FLAC__ASSERT(0 != aligned_pointer); ------------------ | | 38| 267k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 267k] | | ------------------ ------------------ 74| 267k| FLAC__ASSERT(unaligned_pointer != aligned_pointer); ------------------ | | 38| 267k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 267k] | | ------------------ ------------------ 75| | 76| 267k| if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */ ------------------ | Branch (76:5): [True: 0, False: 267k] ------------------ 77| 0| return false; 78| | 79| 267k| pu = FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv); 80| 267k| if(0 == pu) { ------------------ | Branch (80:5): [True: 0, False: 267k] ------------------ 81| 0| return false; 82| 0| } 83| 267k| else { 84| 267k| if(*unaligned_pointer != 0) ------------------ | Branch (84:6): [True: 0, False: 267k] ------------------ 85| 0| free(*unaligned_pointer); 86| 267k| *unaligned_pointer = pu; 87| 267k| *aligned_pointer = u.pa; 88| | return true; 89| 267k| } 90| 267k|} 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| 23.2k|{ 123| 23.2k| FLAC__int64 *pu; /* unaligned pointer */ 124| 23.2k| union { /* union needed to comply with C99 pointer aliasing rules */ 125| 23.2k| FLAC__int64 *pa; /* aligned pointer */ 126| 23.2k| void *pv; /* aligned pointer alias */ 127| 23.2k| } u; 128| | 129| 23.2k| FLAC__ASSERT(elements > 0); ------------------ | | 38| 23.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.2k] | | ------------------ ------------------ 130| 23.2k| FLAC__ASSERT(0 != unaligned_pointer); ------------------ | | 38| 23.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.2k] | | ------------------ ------------------ 131| 23.2k| FLAC__ASSERT(0 != aligned_pointer); ------------------ | | 38| 23.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.2k] | | ------------------ ------------------ 132| 23.2k| FLAC__ASSERT(unaligned_pointer != aligned_pointer); ------------------ | | 38| 23.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.2k] | | ------------------ ------------------ 133| | 134| 23.2k| if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */ ------------------ | Branch (134:5): [True: 0, False: 23.2k] ------------------ 135| 0| return false; 136| | 137| 23.2k| pu = FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv); 138| 23.2k| if(0 == pu) { ------------------ | Branch (138:5): [True: 0, False: 23.2k] ------------------ 139| 0| return false; 140| 0| } 141| 23.2k| else { 142| 23.2k| if(*unaligned_pointer != 0) ------------------ | Branch (142:6): [True: 0, False: 23.2k] ------------------ 143| 0| free(*unaligned_pointer); 144| 23.2k| *unaligned_pointer = pu; 145| 23.2k| *aligned_pointer = u.pa; 146| | return true; 147| 23.2k| } 148| 23.2k|} FLAC__memory_alloc_aligned_uint64_array: 151| 23.2k|{ 152| 23.2k| FLAC__uint64 *pu; /* unaligned pointer */ 153| 23.2k| union { /* union needed to comply with C99 pointer aliasing rules */ 154| 23.2k| FLAC__uint64 *pa; /* aligned pointer */ 155| 23.2k| void *pv; /* aligned pointer alias */ 156| 23.2k| } u; 157| | 158| 23.2k| FLAC__ASSERT(elements > 0); ------------------ | | 38| 23.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.2k] | | ------------------ ------------------ 159| 23.2k| FLAC__ASSERT(0 != unaligned_pointer); ------------------ | | 38| 23.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.2k] | | ------------------ ------------------ 160| 23.2k| FLAC__ASSERT(0 != aligned_pointer); ------------------ | | 38| 23.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.2k] | | ------------------ ------------------ 161| 23.2k| FLAC__ASSERT(unaligned_pointer != aligned_pointer); ------------------ | | 38| 23.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 23.2k] | | ------------------ ------------------ 162| | 163| 23.2k| if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */ ------------------ | Branch (163:5): [True: 0, False: 23.2k] ------------------ 164| 0| return false; 165| | 166| 23.2k| pu = FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv); 167| 23.2k| if(0 == pu) { ------------------ | Branch (167:5): [True: 0, False: 23.2k] ------------------ 168| 0| return false; 169| 0| } 170| 23.2k| else { 171| 23.2k| if(*unaligned_pointer != 0) ------------------ | Branch (171:6): [True: 0, False: 23.2k] ------------------ 172| 0| free(*unaligned_pointer); 173| 23.2k| *unaligned_pointer = pu; 174| 23.2k| *aligned_pointer = u.pa; 175| | return true; 176| 23.2k| } 177| 23.2k|} FLAC__memory_alloc_aligned_real_array: 182| 36.7k|{ 183| 36.7k| FLAC__real *pu; /* unaligned pointer */ 184| 36.7k| union { /* union needed to comply with C99 pointer aliasing rules */ 185| 36.7k| FLAC__real *pa; /* aligned pointer */ 186| 36.7k| void *pv; /* aligned pointer alias */ 187| 36.7k| } u; 188| | 189| 36.7k| FLAC__ASSERT(elements > 0); ------------------ | | 38| 36.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 36.7k] | | ------------------ ------------------ 190| 36.7k| FLAC__ASSERT(0 != unaligned_pointer); ------------------ | | 38| 36.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 36.7k] | | ------------------ ------------------ 191| 36.7k| FLAC__ASSERT(0 != aligned_pointer); ------------------ | | 38| 36.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 36.7k] | | ------------------ ------------------ 192| 36.7k| FLAC__ASSERT(unaligned_pointer != aligned_pointer); ------------------ | | 38| 36.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 36.7k] | | ------------------ ------------------ 193| | 194| 36.7k| if(elements > SIZE_MAX / sizeof(*pu)) /* overflow check */ ------------------ | Branch (194:5): [True: 0, False: 36.7k] ------------------ 195| 0| return false; 196| | 197| 36.7k| pu = FLAC__memory_alloc_aligned(sizeof(*pu) * elements, &u.pv); 198| 36.7k| if(0 == pu) { ------------------ | Branch (198:5): [True: 0, False: 36.7k] ------------------ 199| 0| return false; 200| 0| } 201| 36.7k| else { 202| 36.7k| if(*unaligned_pointer != 0) ------------------ | Branch (202:6): [True: 0, False: 36.7k] ------------------ 203| 0| free(*unaligned_pointer); 204| 36.7k| *unaligned_pointer = pu; 205| 36.7k| *aligned_pointer = u.pa; 206| | return true; 207| 36.7k| } 208| 36.7k|} safe_malloc_mul_2op_p: 213| 21.6k|{ 214| 21.6k| if(!size1 || !size2) ------------------ | Branch (214:5): [True: 0, False: 21.6k] | Branch (214:15): [True: 0, False: 21.6k] ------------------ 215| 0| return malloc(1); /* malloc(0) is undefined; FLAC src convention is to always allocate */ 216| 21.6k| if(size1 > SIZE_MAX / size2) ------------------ | Branch (216:5): [True: 0, False: 21.6k] ------------------ 217| 0| return 0; 218| 21.6k| return malloc(size1*size2); 219| 21.6k|} FLAC__ogg_decoder_aspect_set_defaults: 215| 17.4k|{ 216| 17.4k| aspect->use_first_serial_number = true; 217| | aspect->decode_chained_stream = false; 218| 17.4k|} FLAC__ogg_encoder_aspect_init: 52| 3.09k|{ 53| | /* we will determine the serial number later if necessary */ 54| 3.09k| if(ogg_stream_init(&aspect->stream_state, aspect->serial_number) != 0) ------------------ | Branch (54:5): [True: 0, False: 3.09k] ------------------ 55| 0| return false; 56| | 57| 3.09k| aspect->seen_magic = false; 58| 3.09k| aspect->is_first_packet = true; 59| 3.09k| aspect->samples_written = 0; 60| 3.09k| aspect->last_page_granule_pos = 0; 61| | 62| | return true; 63| 3.09k|} FLAC__ogg_encoder_aspect_finish: 66| 3.09k|{ 67| 3.09k| (void)ogg_stream_clear(&aspect->stream_state); 68| | /*@@@ what about the page? */ 69| 3.09k|} FLAC__ogg_encoder_aspect_set_serial_number: 72| 12.0k|{ 73| 12.0k| aspect->serial_number = value; 74| 12.0k|} FLAC__ogg_encoder_aspect_set_defaults: 87| 21.9k|{ 88| 21.9k| aspect->serial_number = 0; 89| 21.9k| aspect->num_metadata = 0; 90| 21.9k|} FLAC__ogg_encoder_aspect_write_callback_wrapper: 114| 170k|{ 115| | /* WATCHOUT: 116| | * This depends on the behavior of FLAC__StreamEncoder that 'samples' 117| | * will be 0 for metadata writes. 118| | */ 119| 170k| 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| 170k| if(aspect->seen_magic) { ------------------ | Branch (125:5): [True: 167k, False: 3.09k] ------------------ 126| 167k| ogg_packet packet; 127| 167k| FLAC__byte synthetic_first_packet_body[ 128| 167k| FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH + 129| 167k| FLAC__OGG_MAPPING_MAGIC_LENGTH + 130| 167k| FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH + 131| 167k| FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH + 132| 167k| FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH + 133| 167k| FLAC__STREAM_SYNC_LENGTH + 134| 167k| FLAC__STREAM_METADATA_HEADER_LENGTH + 135| 167k| FLAC__STREAM_METADATA_STREAMINFO_LENGTH 136| 167k| ]; 137| | 138| 167k| memset(&packet, 0, sizeof(packet)); 139| 167k| packet.granulepos = aspect->samples_written + samples; 140| | 141| 167k| if(aspect->is_first_packet) { ------------------ | Branch (141:6): [True: 3.09k, False: 164k] ------------------ 142| 3.09k| FLAC__byte *b = synthetic_first_packet_body; 143| 3.09k| if(bytes != FLAC__STREAM_METADATA_HEADER_LENGTH + FLAC__STREAM_METADATA_STREAMINFO_LENGTH) { ------------------ | | 872| 3.09k|#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) ------------------ if(bytes != FLAC__STREAM_METADATA_HEADER_LENGTH + FLAC__STREAM_METADATA_STREAMINFO_LENGTH) { ------------------ | | 557| 3.09k|#define FLAC__STREAM_METADATA_STREAMINFO_LENGTH (34u) ------------------ | Branch (143:7): [True: 0, False: 3.09k] ------------------ 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| 3.09k| *b = FLAC__OGG_MAPPING_FIRST_HEADER_PACKET_TYPE; 153| 3.09k| b += FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH; ------------------ | | 39| 3.09k|#define FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH (1u) ------------------ 154| | /* add 'FLAC' mapping magic */ 155| 3.09k| memcpy(b, FLAC__OGG_MAPPING_MAGIC, FLAC__OGG_MAPPING_MAGIC_LENGTH); ------------------ | | 46| 3.09k|#define FLAC__OGG_MAPPING_MAGIC_LENGTH (4u) ------------------ 156| 3.09k| b += FLAC__OGG_MAPPING_MAGIC_LENGTH; ------------------ | | 46| 3.09k|#define FLAC__OGG_MAPPING_MAGIC_LENGTH (4u) ------------------ 157| | /* add Ogg FLAC mapping major version number */ 158| 3.09k| memcpy(b, &FLAC__OGG_MAPPING_VERSION_MAJOR, FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH); ------------------ | | 54| 3.09k|#define FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH (1u) ------------------ 159| 3.09k| b += FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH; ------------------ | | 54| 3.09k|#define FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH (1u) ------------------ 160| | /* add Ogg FLAC mapping minor version number */ 161| 3.09k| memcpy(b, &FLAC__OGG_MAPPING_VERSION_MINOR, FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH); ------------------ | | 57| 3.09k|#define FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH (1u) ------------------ 162| 3.09k| b += FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH; ------------------ | | 57| 3.09k|#define FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH (1u) ------------------ 163| | /* add number of header packets */ 164| 3.09k| *b = (FLAC__byte)(aspect->num_metadata >> 8); 165| 3.09k| b++; 166| 3.09k| *b = (FLAC__byte)(aspect->num_metadata); 167| 3.09k| b++; 168| | /* add native FLAC 'fLaC' magic */ 169| 3.09k| memcpy(b, FLAC__STREAM_SYNC_STRING, FLAC__STREAM_SYNC_LENGTH); ------------------ | | 179| 3.09k|#define FLAC__STREAM_SYNC_LENGTH (4u) ------------------ 170| 3.09k| b += FLAC__STREAM_SYNC_LENGTH; ------------------ | | 179| 3.09k|#define FLAC__STREAM_SYNC_LENGTH (4u) ------------------ 171| | /* add STREAMINFO */ 172| 3.09k| memcpy(b, buffer, bytes); 173| 3.09k| FLAC__ASSERT(b + bytes - synthetic_first_packet_body == sizeof(synthetic_first_packet_body)); ------------------ | | 38| 3.09k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.09k] | | ------------------ ------------------ 174| 3.09k| packet.packet = (uint8_t *)synthetic_first_packet_body; 175| 3.09k| packet.bytes = sizeof(synthetic_first_packet_body); 176| | 177| 3.09k| packet.b_o_s = 1; 178| 3.09k| aspect->is_first_packet = false; 179| 3.09k| } 180| 164k| else { 181| 164k| packet.packet = (uint8_t *)buffer; 182| 164k| packet.bytes = bytes; 183| 164k| } 184| | 185| 167k| if(is_last_block) { ------------------ | Branch (185:6): [True: 2.75k, False: 164k] ------------------ 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.75k| packet.e_o_s = 1; 191| 2.75k| } 192| | 193| 167k| if(ogg_stream_packetin(&aspect->stream_state, &packet) != 0) ------------------ | Branch (193:6): [True: 0, False: 167k] ------------------ 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| 167k| if(is_metadata) { ------------------ | Branch (200:6): [True: 6.19k, False: 160k] ------------------ 201| 12.3k| while(ogg_stream_flush(&aspect->stream_state, &aspect->page) != 0) { ------------------ | Branch (201:10): [True: 6.19k, False: 6.19k] ------------------ 202| 6.19k| FLAC__int64 page_granule_pos = ogg_page_granulepos(&aspect->page); 203| 6.19k| uint32_t samples_on_this_page; 204| 6.19k| if(page_granule_pos == -1) { ------------------ | Branch (204:8): [True: 0, False: 6.19k] ------------------ 205| | /* a granule position of -1 means no packets finish on this page */ 206| 0| samples_on_this_page = 0; 207| 0| } 208| 6.19k| else { 209| 6.19k| samples_on_this_page = (uint32_t)(page_granule_pos - aspect->last_page_granule_pos); 210| 6.19k| aspect->last_page_granule_pos = page_granule_pos; 211| 6.19k| } 212| 6.19k| 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: 6.19k] ------------------ 213| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 214| 6.19k| 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: 6.19k] ------------------ 215| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 216| 6.19k| } 217| 6.19k| } 218| 160k| else { 219| 165k| while(ogg_stream_pageout(&aspect->stream_state, &aspect->page) != 0) { ------------------ | Branch (219:10): [True: 4.86k, False: 160k] ------------------ 220| 4.86k| FLAC__int64 page_granule_pos = ogg_page_granulepos(&aspect->page); 221| 4.86k| uint32_t samples_on_this_page; 222| 4.86k| if(page_granule_pos == -1) { ------------------ | Branch (222:8): [True: 345, False: 4.51k] ------------------ 223| | /* a granule position of -1 means no packets finish on this page */ 224| 345| samples_on_this_page = 0; 225| 345| } 226| 4.51k| else { 227| 4.51k| samples_on_this_page = (uint32_t)(page_granule_pos - aspect->last_page_granule_pos); 228| 4.51k| aspect->last_page_granule_pos = page_granule_pos; 229| 4.51k| } 230| 4.86k| 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.86k] ------------------ 231| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 232| 4.86k| 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.86k] ------------------ 233| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 234| 4.86k| } 235| 160k| } 236| 167k| } 237| 3.09k| 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: 3.09k, False: 0] | Branch (237:25): [True: 3.09k, False: 0] | Branch (237:47): [True: 3.09k, False: 0] | Branch (237:63): [True: 3.09k, False: 0] | Branch (237:77): [True: 3.09k, False: 0] ------------------ 238| 3.09k| aspect->seen_magic = true; 239| 3.09k| } 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| 170k| aspect->samples_written += samples; 250| | 251| 170k| return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; 252| 170k|} FLAC__stream_decoder_new: 256| 8.73k|{ 257| 8.73k| FLAC__StreamDecoder *decoder; 258| 8.73k| uint32_t i; 259| | 260| 8.73k| FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */ ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 8.73k] | | ------------------ ------------------ 261| | 262| 8.73k| decoder = safe_calloc_(1, sizeof(FLAC__StreamDecoder)); 263| 8.73k| if(decoder == 0) { ------------------ | Branch (263:5): [True: 0, False: 8.73k] ------------------ 264| 0| return 0; 265| 0| } 266| | 267| 8.73k| decoder->protected_ = safe_calloc_(1, sizeof(FLAC__StreamDecoderProtected)); 268| 8.73k| if(decoder->protected_ == 0) { ------------------ | Branch (268:5): [True: 0, False: 8.73k] ------------------ 269| 0| free(decoder); 270| 0| return 0; 271| 0| } 272| | 273| 8.73k| decoder->private_ = safe_calloc_(1, sizeof(FLAC__StreamDecoderPrivate)); 274| 8.73k| if(decoder->private_ == 0) { ------------------ | Branch (274:5): [True: 0, False: 8.73k] ------------------ 275| 0| free(decoder->protected_); 276| 0| free(decoder); 277| 0| return 0; 278| 0| } 279| | 280| 8.73k| decoder->private_->input = FLAC__bitreader_new(); 281| 8.73k| if(decoder->private_->input == 0) { ------------------ | Branch (281:5): [True: 0, False: 8.73k] ------------------ 282| 0| free(decoder->private_); 283| 0| free(decoder->protected_); 284| 0| free(decoder); 285| 0| return 0; 286| 0| } 287| | 288| 8.73k| decoder->private_->metadata_filter_ids_capacity = 16; 289| 8.73k| 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.73k] ------------------ 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| 78.6k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 78.6k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (297:13): [True: 69.9k, False: 8.73k] ------------------ 298| 69.9k| decoder->private_->output[i] = 0; 299| 69.9k| decoder->private_->residual_unaligned[i] = decoder->private_->residual[i] = 0; 300| 69.9k| } 301| | 302| 8.73k| decoder->private_->side_subframe = 0; 303| | 304| 8.73k| decoder->private_->output_capacity = 0; 305| 8.73k| decoder->private_->output_channels = 0; 306| 8.73k| decoder->private_->has_seek_table = false; 307| | 308| 78.6k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) ------------------ | | 106| 78.6k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (308:13): [True: 69.9k, False: 8.73k] ------------------ 309| 69.9k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&decoder->private_->partitioned_rice_contents[i]); 310| | 311| 8.73k| decoder->private_->file = 0; 312| | 313| 8.73k| set_defaults_(decoder); 314| | 315| 8.73k| decoder->protected_->state = FLAC__STREAM_DECODER_UNINITIALIZED; 316| | 317| 8.73k| return decoder; 318| 8.73k|} FLAC__stream_decoder_delete: 321| 8.73k|{ 322| 8.73k| uint32_t i; 323| | 324| 8.73k| if (decoder == NULL) ------------------ | Branch (324:6): [True: 0, False: 8.73k] ------------------ 325| 0| return ; 326| | 327| 8.73k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 328| 8.73k| FLAC__ASSERT(0 != decoder->private_); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 329| 8.73k| FLAC__ASSERT(0 != decoder->private_->input); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 330| | 331| 8.73k| (void)FLAC__stream_decoder_finish(decoder); 332| | 333| 8.73k| if(0 != decoder->private_->metadata_filter_ids) ------------------ | Branch (333:5): [True: 8.73k, False: 0] ------------------ 334| 8.73k| free(decoder->private_->metadata_filter_ids); 335| | 336| 8.73k| FLAC__bitreader_delete(decoder->private_->input); 337| | 338| 78.6k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) ------------------ | | 106| 78.6k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (338:13): [True: 69.9k, False: 8.73k] ------------------ 339| 69.9k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&decoder->private_->partitioned_rice_contents[i]); 340| | 341| 8.73k| free(decoder->private_); 342| 8.73k| free(decoder->protected_); 343| 8.73k| free(decoder); 344| 8.73k|} FLAC__stream_decoder_init_stream: 445| 8.73k|{ 446| 8.73k| return init_stream_internal_( 447| 8.73k| decoder, 448| 8.73k| read_callback, 449| 8.73k| seek_callback, 450| 8.73k| tell_callback, 451| 8.73k| length_callback, 452| 8.73k| eof_callback, 453| 8.73k| write_callback, 454| 8.73k| metadata_callback, 455| 8.73k| error_callback, 456| 8.73k| client_data, 457| | /*is_ogg=*/false 458| 8.73k| ); 459| 8.73k|} FLAC__stream_decoder_finish: 615| 17.4k|{ 616| 17.4k| FLAC__bool md5_failed = false; 617| 17.4k| uint32_t i; 618| | 619| 17.4k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 17.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.4k] | | ------------------ ------------------ 620| 17.4k| FLAC__ASSERT(0 != decoder->private_); ------------------ | | 38| 17.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.4k] | | ------------------ ------------------ 621| 17.4k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 17.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.4k] | | ------------------ ------------------ 622| | 623| 17.4k| if(decoder->protected_->state == FLAC__STREAM_DECODER_UNINITIALIZED) ------------------ | Branch (623:5): [True: 8.73k, False: 8.73k] ------------------ 624| 8.73k| return true; 625| | 626| | /* see the comment in FLAC__stream_decoder_reset() as to why we 627| | * always call FLAC__MD5Final() 628| | */ 629| 8.73k| FLAC__MD5Final(decoder->private_->computed_md5sum, &decoder->private_->md5context); 630| | 631| 8.73k| free(decoder->private_->seek_table.data.seek_table.points); 632| 8.73k| decoder->private_->seek_table.data.seek_table.points = 0; 633| 8.73k| decoder->private_->has_seek_table = false; 634| | 635| 8.73k| FLAC__bitreader_free(decoder->private_->input); 636| 78.6k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 78.6k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (636:13): [True: 69.9k, False: 8.73k] ------------------ 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| 69.9k| if(0 != decoder->private_->output[i]) { ------------------ | Branch (643:6): [True: 14.0k, False: 55.9k] ------------------ 644| 14.0k| free(decoder->private_->output[i]-4); 645| 14.0k| decoder->private_->output[i] = 0; 646| 14.0k| } 647| 69.9k| if(0 != decoder->private_->residual_unaligned[i]) { ------------------ | Branch (647:6): [True: 14.0k, False: 55.9k] ------------------ 648| 14.0k| free(decoder->private_->residual_unaligned[i]); 649| 14.0k| decoder->private_->residual_unaligned[i] = decoder->private_->residual[i] = 0; 650| 14.0k| } 651| 69.9k| } 652| 8.73k| if(0 != decoder->private_->side_subframe) { ------------------ | Branch (652:5): [True: 5.45k, False: 3.28k] ------------------ 653| 5.45k| free(decoder->private_->side_subframe); 654| 5.45k| decoder->private_->side_subframe = 0; 655| 5.45k| } 656| 8.73k| decoder->private_->output_capacity = 0; 657| 8.73k| decoder->private_->output_channels = 0; 658| | 659| 8.73k|#if FLAC__HAS_OGG 660| 8.73k| if(decoder->private_->is_ogg) ------------------ | Branch (660:5): [True: 0, False: 8.73k] ------------------ 661| 0| FLAC__ogg_decoder_aspect_finish(&decoder->protected_->ogg_decoder_aspect); 662| 8.73k|#endif 663| | 664| 8.73k| if(0 != decoder->private_->file) { ------------------ | Branch (664:5): [True: 0, False: 8.73k] ------------------ 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.73k| if(decoder->private_->do_md5_checking) { ------------------ | Branch (670:5): [True: 0, False: 8.73k] ------------------ 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.73k| decoder->private_->is_seeking = false; 675| 8.73k| decoder->private_->is_indexing = false; 676| | 677| 8.73k| set_defaults_(decoder); 678| | 679| 8.73k| decoder->protected_->state = FLAC__STREAM_DECODER_UNINITIALIZED; 680| | 681| 8.73k| return !md5_failed; 682| 17.4k|} FLAC__stream_decoder_get_state: 831| 225k|{ 832| 225k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 225k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 225k] | | ------------------ ------------------ 833| 225k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 225k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 225k] | | ------------------ ------------------ 834| 225k| return decoder->protected_->state; 835| 225k|} FLAC__stream_decoder_get_decode_position: 904| 224k|{ 905| 224k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 224k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 224k] | | ------------------ ------------------ 906| 224k| FLAC__ASSERT(0 != decoder->private_); ------------------ | | 38| 224k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 224k] | | ------------------ ------------------ 907| 224k| FLAC__ASSERT(0 != position); ------------------ | | 38| 224k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 224k] | | ------------------ ------------------ 908| | 909| 224k| if(FLAC__HAS_OGG && decoder->private_->is_ogg) ------------------ | | 45| 449k|#define FLAC__HAS_OGG 1 | | ------------------ | | | Branch (45:23): [True: 224k, Folded] | | ------------------ ------------------ | Branch (909:22): [True: 0, False: 224k] ------------------ 910| 0| return false; 911| | 912| 224k| if(0 == decoder->private_->tell_callback) ------------------ | Branch (912:5): [True: 224k, False: 0] ------------------ 913| 224k| 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.73k|{ 931| 8.73k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 932| 8.73k| FLAC__ASSERT(0 != decoder->private_); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 933| 8.73k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 934| | 935| 8.73k| if(!decoder->private_->internal_reset_hack && decoder->protected_->state == FLAC__STREAM_DECODER_UNINITIALIZED) ------------------ | Branch (935:5): [True: 0, False: 8.73k] | Branch (935:48): [True: 0, False: 0] ------------------ 936| 0| return false; 937| 8.73k| if(decoder->protected_->state == FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR) ------------------ | Branch (937:5): [True: 0, False: 8.73k] ------------------ 938| 0| return false; 939| | 940| 8.73k| decoder->private_->samples_decoded = 0; 941| 8.73k| decoder->private_->do_md5_checking = false; 942| 8.73k| decoder->private_->last_seen_framesync = 0; 943| 8.73k| decoder->private_->last_frame_is_set = false; 944| | 945| 8.73k|#if FLAC__HAS_OGG 946| 8.73k| if(decoder->private_->is_ogg) ------------------ | Branch (946:5): [True: 0, False: 8.73k] ------------------ 947| 0| FLAC__ogg_decoder_aspect_flush(&decoder->protected_->ogg_decoder_aspect); 948| 8.73k|#endif 949| | 950| 8.73k| if(!FLAC__bitreader_clear(decoder->private_->input)) { ------------------ | Branch (950:5): [True: 0, False: 8.73k] ------------------ 951| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 952| 0| return false; 953| 0| } 954| 8.73k| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 955| | 956| | return true; 957| 8.73k|} FLAC__stream_decoder_reset: 1001| 8.73k|{ 1002| 8.73k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 1003| 8.73k| FLAC__ASSERT(0 != decoder->private_); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 1004| 8.73k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 1005| | 1006| 8.73k| if(!FLAC__stream_decoder_flush(decoder)) { ------------------ | Branch (1006:5): [True: 0, False: 8.73k] ------------------ 1007| | /* above call sets the state for us */ 1008| 0| return false; 1009| 0| } 1010| | 1011| 8.73k|#if FLAC__HAS_OGG 1012| | /*@@@ could go in !internal_reset_hack block below */ 1013| 8.73k| if(decoder->private_->is_ogg) ------------------ | Branch (1013:5): [True: 0, False: 8.73k] ------------------ 1014| 0| FLAC__ogg_decoder_aspect_reset(&decoder->protected_->ogg_decoder_aspect); 1015| 8.73k|#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.73k| if(!decoder->private_->internal_reset_hack) { ------------------ | Branch (1022:5): [True: 0, False: 8.73k] ------------------ 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.73k| reset_decoder_internal_(decoder); 1030| | 1031| | return true; 1032| 8.73k|} FLAC__stream_decoder_process_single: 1035| 233k|{ 1036| 233k| FLAC__bool got_a_frame; 1037| 233k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 233k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 233k] | | ------------------ ------------------ 1038| 233k| FLAC__ASSERT(0 != decoder->protected_); ------------------ | | 38| 233k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 233k] | | ------------------ ------------------ 1039| | 1040| 458k| while(1) { ------------------ | Branch (1040:8): [True: 458k, Folded] ------------------ 1041| 458k| switch(decoder->protected_->state) { 1042| 8.73k| case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA: ------------------ | Branch (1042:4): [True: 8.73k, False: 449k] ------------------ 1043| 8.73k| if(!find_metadata_(decoder)) ------------------ | Branch (1043:8): [True: 0, False: 8.73k] ------------------ 1044| 0| return false; /* above function sets the status for us */ 1045| 8.73k| break; 1046| 17.4k| case FLAC__STREAM_DECODER_READ_METADATA: ------------------ | Branch (1046:4): [True: 17.4k, False: 441k] ------------------ 1047| 17.4k| if(!read_metadata_(decoder)) ------------------ | Branch (1047:8): [True: 0, False: 17.4k] ------------------ 1048| 0| return false; /* above function sets the status for us */ 1049| 17.4k| else 1050| 17.4k| return true; 1051| 216k| case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC: ------------------ | Branch (1051:4): [True: 216k, False: 242k] ------------------ 1052| 216k| if(!frame_sync_(decoder)) { ------------------ | Branch (1052:8): [True: 0, False: 216k] ------------------ 1053| 0| return true; /* above function sets the status for us */ 1054| 0| } 1055| 216k| break; 1056| 216k| case FLAC__STREAM_DECODER_READ_FRAME: ------------------ | Branch (1056:4): [True: 216k, False: 242k] ------------------ 1057| 216k| if(!read_frame_(decoder, &got_a_frame, /*do_full_decode=*/true)) ------------------ | Branch (1057:8): [True: 0, False: 216k] ------------------ 1058| 0| return false; /* above function sets the status for us */ 1059| 216k| if(got_a_frame) ------------------ | Branch (1059:8): [True: 216k, False: 0] ------------------ 1060| 216k| 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: 458k] ------------------ 1063| 0| case FLAC__STREAM_DECODER_END_OF_LINK: ------------------ | Branch (1063:4): [True: 0, False: 458k] ------------------ 1064| 0| case FLAC__STREAM_DECODER_ABORTED: ------------------ | Branch (1064:4): [True: 0, False: 458k] ------------------ 1065| 0| return true; 1066| 0| default: ------------------ | Branch (1066:4): [True: 0, False: 458k] ------------------ 1067| | return false; 1068| 458k| } 1069| 458k| } 1070| 233k|} stream_decoder.c:init_stream_internal_: 365| 8.73k|{ 366| 8.73k| FLAC__ASSERT(0 != decoder); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 367| | 368| 8.73k| if(decoder->protected_->state != FLAC__STREAM_DECODER_UNINITIALIZED) ------------------ | Branch (368:5): [True: 0, False: 8.73k] ------------------ 369| 0| return FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED; 370| | 371| 8.73k| if(FLAC__HAS_OGG == 0 && is_ogg) ------------------ | | 45| 8.73k|#define FLAC__HAS_OGG 1 ------------------ | Branch (371:5): [Folded, False: 8.73k] | Branch (371:27): [True: 0, False: 0] ------------------ 372| 0| return FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER; 373| | 374| 8.73k| if( 375| 8.73k| 0 == read_callback || ------------------ | Branch (375:3): [True: 0, False: 8.73k] ------------------ 376| 8.73k| 0 == write_callback || ------------------ | Branch (376:3): [True: 0, False: 8.73k] ------------------ 377| 8.73k| 0 == error_callback || ------------------ | Branch (377:3): [True: 0, False: 8.73k] ------------------ 378| 8.73k| (seek_callback && (0 == tell_callback || 0 == length_callback || 0 == eof_callback)) ------------------ | Branch (378:4): [True: 0, False: 8.73k] | Branch (378:22): [True: 0, False: 0] | Branch (378:44): [True: 0, False: 0] | Branch (378:68): [True: 0, False: 0] ------------------ 379| 8.73k| ) 380| 0| return FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS; 381| | 382| 8.73k|#if FLAC__HAS_OGG 383| 8.73k| decoder->private_->is_ogg = is_ogg; 384| 8.73k| if(is_ogg && !FLAC__ogg_decoder_aspect_init(&decoder->protected_->ogg_decoder_aspect)) { ------------------ | Branch (384:5): [True: 0, False: 8.73k] | 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.73k|#endif 389| | 390| 8.73k| FLAC__cpu_info(&decoder->private_->cpuinfo); 391| 8.73k| decoder->private_->local_bitreader_read_rice_signed_block = FLAC__bitreader_read_rice_signed_block; 392| | 393| 8.73k|#ifdef FLAC__BMI2_SUPPORTED 394| 8.73k| if (decoder->private_->cpuinfo.x86.bmi2) { ------------------ | Branch (394:6): [True: 8.73k, False: 0] ------------------ 395| 8.73k| decoder->private_->local_bitreader_read_rice_signed_block = FLAC__bitreader_read_rice_signed_block_bmi2; 396| 8.73k| } 397| 8.73k|#endif 398| | 399| | /* from here on, errors are fatal */ 400| | 401| 8.73k| if(!FLAC__bitreader_init(decoder->private_->input, read_callback_, decoder)) { ------------------ | Branch (401:5): [True: 0, False: 8.73k] ------------------ 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.73k| decoder->private_->read_callback = read_callback; 407| 8.73k| decoder->private_->seek_callback = seek_callback; 408| 8.73k| decoder->private_->tell_callback = tell_callback; 409| 8.73k| decoder->private_->length_callback = length_callback; 410| 8.73k| decoder->private_->eof_callback = eof_callback; 411| 8.73k| decoder->private_->write_callback = write_callback; 412| 8.73k| decoder->private_->metadata_callback = metadata_callback; 413| 8.73k| decoder->private_->error_callback = error_callback; 414| 8.73k| decoder->private_->client_data = client_data; 415| 8.73k| decoder->private_->fixed_block_size = decoder->private_->next_fixed_block_size = 0; 416| 8.73k| decoder->private_->samples_decoded = 0; 417| 8.73k| decoder->private_->has_stream_info = false; 418| 8.73k| decoder->private_->cached = false; 419| | 420| 8.73k| decoder->private_->do_md5_checking = decoder->protected_->md5_checking; 421| 8.73k| decoder->private_->is_seeking = false; 422| 8.73k| decoder->private_->is_indexing = false; 423| | 424| 8.73k| decoder->private_->internal_reset_hack = true; /* so the following reset does not try to rewind the input */ 425| 8.73k| if(!FLAC__stream_decoder_reset(decoder)) { ------------------ | Branch (425:5): [True: 0, False: 8.73k] ------------------ 426| | /* above call sets the state for us */ 427| 0| return FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR; 428| 0| } 429| | 430| 8.73k| return FLAC__STREAM_DECODER_INIT_STATUS_OK; 431| 8.73k|} stream_decoder.c:read_callback_: 3376| 250k|{ 3377| 250k| FLAC__StreamDecoder *decoder = (FLAC__StreamDecoder *)client_data; 3378| | 3379| 250k| if( 3380| 250k|#if FLAC__HAS_OGG 3381| | /* see [1] HACK NOTE below for why we don't call the eof_callback when decoding Ogg FLAC */ 3382| 250k| !decoder->private_->is_ogg && ------------------ | Branch (3382:3): [True: 250k, False: 0] ------------------ 3383| 250k|#endif 3384| 250k| decoder->private_->eof_callback && decoder->private_->eof_callback(decoder, decoder->private_->client_data) ------------------ | Branch (3384:3): [True: 0, False: 250k] | Branch (3384:38): [True: 0, False: 0] ------------------ 3385| 250k| ) { 3386| 0| *bytes = 0; 3387| 0| decoder->protected_->state = FLAC__STREAM_DECODER_END_OF_STREAM; 3388| 0| return false; 3389| 0| } 3390| 250k| else if(*bytes > 0) { ------------------ | Branch (3390:10): [True: 250k, 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| 250k| if(decoder->private_->is_seeking && decoder->private_->unparseable_frame_count > 20) { ------------------ | Branch (3401:6): [True: 0, False: 250k] | Branch (3401:39): [True: 0, False: 0] ------------------ 3402| 0| decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED; 3403| 0| return false; 3404| 0| } 3405| 250k| else { 3406| 250k| const FLAC__StreamDecoderReadStatus status = 3407| 250k|#if FLAC__HAS_OGG 3408| 250k| decoder->private_->is_ogg? ------------------ | Branch (3408:5): [True: 0, False: 250k] ------------------ 3409| 0| read_callback_ogg_aspect_(decoder, buffer, bytes) : 3410| 250k|#endif 3411| 250k| decoder->private_->read_callback(decoder, buffer, bytes, decoder->private_->client_data) 3412| 250k| ; 3413| 250k| if(status == FLAC__STREAM_DECODER_READ_STATUS_ABORT) { ------------------ | Branch (3413:7): [True: 0, False: 250k] ------------------ 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| 250k| else if(*bytes == 0) { ------------------ | Branch (3423:12): [True: 0, False: 250k] ------------------ 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| 250k| else 3448| 250k| return true; 3449| 250k| } 3450| 250k| } 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| 250k|} stream_decoder.c:reset_decoder_internal_: 959| 8.73k|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.73k| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_METADATA; 964| | 965| 8.73k| decoder->private_->has_stream_info = false; 966| | 967| 8.73k| free(decoder->private_->seek_table.data.seek_table.points); 968| 8.73k| decoder->private_->seek_table.data.seek_table.points = 0; 969| 8.73k| decoder->private_->has_seek_table = false; 970| | 971| 8.73k| 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.73k| 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.73k| if(!decoder->private_->internal_reset_hack) { ------------------ | Branch (984:5): [True: 0, False: 8.73k] ------------------ 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.73k| else 990| 8.73k| decoder->private_->internal_reset_hack = false; 991| 8.73k| FLAC__MD5Init(&decoder->private_->md5context); 992| | 993| 8.73k| decoder->private_->first_frame_offset = 0; 994| 8.73k| decoder->private_->unparseable_frame_count = 0; 995| 8.73k| decoder->private_->last_seen_framesync = 0; 996| 8.73k| decoder->private_->last_frame_is_set = false; 997| | decoder->private_->error_has_been_sent = false; 998| 8.73k|} stream_decoder.c:set_defaults_: 1532| 17.4k|{ 1533| 17.4k| decoder->private_->is_ogg = false; 1534| 17.4k| decoder->private_->read_callback = 0; 1535| 17.4k| decoder->private_->seek_callback = 0; 1536| 17.4k| decoder->private_->tell_callback = 0; 1537| 17.4k| decoder->private_->length_callback = 0; 1538| 17.4k| decoder->private_->eof_callback = 0; 1539| 17.4k| decoder->private_->write_callback = 0; 1540| 17.4k| decoder->private_->metadata_callback = 0; 1541| 17.4k| decoder->private_->error_callback = 0; 1542| 17.4k| decoder->private_->client_data = 0; 1543| | 1544| 17.4k| memset(decoder->private_->metadata_filter, 0, sizeof(decoder->private_->metadata_filter)); 1545| 17.4k| decoder->private_->metadata_filter[FLAC__METADATA_TYPE_STREAMINFO] = true; 1546| 17.4k| decoder->private_->metadata_filter_ids_count = 0; 1547| | 1548| 17.4k| decoder->protected_->md5_checking = false; 1549| | 1550| 17.4k|#if FLAC__HAS_OGG 1551| 17.4k| FLAC__ogg_decoder_aspect_set_defaults(&decoder->protected_->ogg_decoder_aspect); 1552| 17.4k|#endif 1553| 17.4k|} stream_decoder.c:find_metadata_: 1655| 8.73k|{ 1656| 8.73k| FLAC__uint32 x; 1657| 8.73k| uint32_t i, id; 1658| 8.73k| FLAC__bool first = true; 1659| | 1660| 8.73k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 1661| | 1662| 43.6k| for(i = id = 0; i < 4; ) { ------------------ | Branch (1662:18): [True: 34.9k, False: 8.73k] ------------------ 1663| 34.9k| if(decoder->private_->cached) { ------------------ | Branch (1663:6): [True: 0, False: 34.9k] ------------------ 1664| 0| x = (FLAC__uint32)decoder->private_->lookahead; 1665| 0| decoder->private_->cached = false; 1666| 0| } 1667| 34.9k| else { 1668| 34.9k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (1668:7): [True: 0, False: 34.9k] ------------------ 1669| 0| return false; /* read_callback_ sets the state for us */ 1670| 34.9k| } 1671| 34.9k| if(x == FLAC__STREAM_SYNC_STRING[i]) { ------------------ | Branch (1671:6): [True: 34.9k, False: 0] ------------------ 1672| 34.9k| first = true; 1673| 34.9k| i++; 1674| 34.9k| id = 0; 1675| 34.9k| continue; 1676| 34.9k| } 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.73k| decoder->protected_->state = FLAC__STREAM_DECODER_READ_METADATA; 1716| | return true; 1717| 8.73k|} stream_decoder.c:read_metadata_: 1720| 17.4k|{ 1721| 17.4k| FLAC__bool is_last; 1722| 17.4k| FLAC__uint32 i, x, type, length; 1723| | 1724| 17.4k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)); ------------------ | | 38| 17.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 17.4k] | | ------------------ ------------------ 1725| | 1726| 17.4k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_IS_LAST_LEN)) ------------------ | Branch (1726:5): [True: 0, False: 17.4k] ------------------ 1727| 0| return false; /* read_callback_ sets the state for us */ 1728| 17.4k| is_last = x? true : false; ------------------ | Branch (1728:12): [True: 8.73k, False: 8.73k] ------------------ 1729| | 1730| 17.4k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &type, FLAC__STREAM_METADATA_TYPE_LEN)) ------------------ | Branch (1730:5): [True: 0, False: 17.4k] ------------------ 1731| 0| return false; /* read_callback_ sets the state for us */ 1732| | 1733| 17.4k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &length, FLAC__STREAM_METADATA_LENGTH_LEN)) ------------------ | Branch (1733:5): [True: 0, False: 17.4k] ------------------ 1734| 0| return false; /* read_callback_ sets the state for us */ 1735| | 1736| 17.4k| if(type == FLAC__METADATA_TYPE_STREAMINFO) { ------------------ | Branch (1736:5): [True: 8.73k, False: 8.73k] ------------------ 1737| 8.73k| if(!read_metadata_streaminfo_(decoder, is_last, length)) ------------------ | Branch (1737:6): [True: 0, False: 8.73k] ------------------ 1738| 0| return false; 1739| | 1740| 8.73k| decoder->private_->has_stream_info = true; 1741| 8.73k| 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.73k, False: 0] ------------------ 1742| 8.73k| decoder->private_->do_md5_checking = false; 1743| 8.73k| if(!decoder->private_->is_seeking && decoder->private_->metadata_filter[FLAC__METADATA_TYPE_STREAMINFO] && decoder->private_->metadata_callback) ------------------ | Branch (1743:6): [True: 8.73k, False: 0] | Branch (1743:40): [True: 8.73k, False: 0] | Branch (1743:110): [True: 8.73k, False: 0] ------------------ 1744| 8.73k| decoder->private_->metadata_callback(decoder, &decoder->private_->stream_info, decoder->private_->client_data); 1745| 8.73k| } 1746| 8.73k| else if(type == FLAC__METADATA_TYPE_SEEKTABLE) { ------------------ | Branch (1746:10): [True: 0, False: 8.73k] ------------------ 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.73k| else { 1760| 8.73k| FLAC__bool skip_it = !decoder->private_->metadata_filter[type]; 1761| 8.73k| uint32_t real_length = length; 1762| 8.73k| FLAC__StreamMetadata block; 1763| | 1764| 8.73k| memset(&block, 0, sizeof(block)); 1765| 8.73k| block.is_last = is_last; 1766| 8.73k| block.type = (FLAC__MetadataType)type; 1767| 8.73k| block.length = length; 1768| | 1769| 8.73k| if(type == FLAC__METADATA_TYPE_APPLICATION) { ------------------ | Branch (1769:6): [True: 0, False: 8.73k] ------------------ 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.73k| if(skip_it) { ------------------ | Branch (1784:6): [True: 8.73k, False: 0] ------------------ 1785| 8.73k| if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(decoder->private_->input, real_length)) ------------------ | Branch (1785:7): [True: 0, False: 8.73k] ------------------ 1786| 0| return false; /* read_callback_ sets the state for us */ 1787| 8.73k| } 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.73k| } 1899| | 1900| 17.4k| if(is_last) { ------------------ | Branch (1900:5): [True: 8.73k, False: 8.73k] ------------------ 1901| | /* if this fails, it's OK, it's just a hint for the seek routine */ 1902| 8.73k| if(!FLAC__stream_decoder_get_decode_position(decoder, &decoder->private_->first_frame_offset)) ------------------ | Branch (1902:6): [True: 8.73k, False: 0] ------------------ 1903| 8.73k| decoder->private_->first_frame_offset = 0; 1904| 8.73k| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 1905| 8.73k| } 1906| | 1907| | return true; 1908| 17.4k|} stream_decoder.c:read_metadata_streaminfo_: 1911| 8.73k|{ 1912| 8.73k| FLAC__uint32 x; 1913| 8.73k| uint32_t bits, used_bits = 0; 1914| | 1915| 8.73k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 1916| | 1917| 8.73k| decoder->private_->stream_info.type = FLAC__METADATA_TYPE_STREAMINFO; 1918| 8.73k| decoder->private_->stream_info.is_last = is_last; 1919| 8.73k| decoder->private_->stream_info.length = length; 1920| | 1921| 8.73k| bits = FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN; 1922| 8.73k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, bits)) ------------------ | Branch (1922:5): [True: 0, False: 8.73k] ------------------ 1923| 0| return false; /* read_callback_ sets the state for us */ 1924| 8.73k| decoder->private_->stream_info.data.stream_info.min_blocksize = x; 1925| 8.73k| used_bits += bits; 1926| | 1927| 8.73k| bits = FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN; 1928| 8.73k| 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.73k] ------------------ 1929| 0| return false; /* read_callback_ sets the state for us */ 1930| 8.73k| decoder->private_->stream_info.data.stream_info.max_blocksize = x; 1931| 8.73k| used_bits += bits; 1932| | 1933| 8.73k| bits = FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN; 1934| 8.73k| 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.73k] ------------------ 1935| 0| return false; /* read_callback_ sets the state for us */ 1936| 8.73k| decoder->private_->stream_info.data.stream_info.min_framesize = x; 1937| 8.73k| used_bits += bits; 1938| | 1939| 8.73k| bits = FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN; 1940| 8.73k| 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.73k] ------------------ 1941| 0| return false; /* read_callback_ sets the state for us */ 1942| 8.73k| decoder->private_->stream_info.data.stream_info.max_framesize = x; 1943| 8.73k| used_bits += bits; 1944| | 1945| 8.73k| bits = FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN; 1946| 8.73k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN)) ------------------ | Branch (1946:5): [True: 0, False: 8.73k] ------------------ 1947| 0| return false; /* read_callback_ sets the state for us */ 1948| 8.73k| decoder->private_->stream_info.data.stream_info.sample_rate = x; 1949| 8.73k| used_bits += bits; 1950| | 1951| 8.73k| bits = FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN; 1952| 8.73k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN)) ------------------ | Branch (1952:5): [True: 0, False: 8.73k] ------------------ 1953| 0| return false; /* read_callback_ sets the state for us */ 1954| 8.73k| decoder->private_->stream_info.data.stream_info.channels = x+1; 1955| 8.73k| used_bits += bits; 1956| | 1957| 8.73k| bits = FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN; 1958| 8.73k| 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.73k] ------------------ 1959| 0| return false; /* read_callback_ sets the state for us */ 1960| 8.73k| decoder->private_->stream_info.data.stream_info.bits_per_sample = x+1; 1961| 8.73k| used_bits += bits; 1962| | 1963| 8.73k| bits = FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN; 1964| 8.73k| 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.73k] ------------------ 1965| 0| return false; /* read_callback_ sets the state for us */ 1966| 8.73k| used_bits += bits; 1967| | 1968| 8.73k| 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.73k] ------------------ 1969| 0| return false; /* read_callback_ sets the state for us */ 1970| 8.73k| used_bits += 16*8; 1971| | 1972| | /* skip the rest of the block */ 1973| 8.73k| FLAC__ASSERT(used_bits % 8 == 0); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 1974| 8.73k| if (length < (used_bits / 8)) ------------------ | Branch (1974:6): [True: 0, False: 8.73k] ------------------ 1975| 0| return false; /* read_callback_ sets the state for us */ 1976| 8.73k| length -= (used_bits / 8); 1977| 8.73k| if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(decoder->private_->input, length)) ------------------ | Branch (1977:5): [True: 0, False: 8.73k] ------------------ 1978| 0| return false; /* read_callback_ sets the state for us */ 1979| | 1980| 8.73k| return true; 1981| 8.73k|} stream_decoder.c:frame_sync_: 2322| 216k|{ 2323| 216k| FLAC__uint32 x; 2324| 216k| FLAC__bool first = true; 2325| | 2326| | /* make sure we're byte aligned */ 2327| 216k| if(!FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)) { ------------------ | Branch (2327:5): [True: 0, False: 216k] ------------------ 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| 216k| while(1) { ------------------ | Branch (2332:8): [True: 216k, Folded] ------------------ 2333| 216k| if(decoder->private_->cached) { ------------------ | Branch (2333:6): [True: 0, False: 216k] ------------------ 2334| 0| x = (FLAC__uint32)decoder->private_->lookahead; 2335| 0| decoder->private_->cached = false; 2336| 0| } 2337| 216k| else { 2338| 216k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2338:7): [True: 0, False: 216k] ------------------ 2339| 0| return false; /* read_callback_ sets the state for us */ 2340| 216k| } 2341| 216k| if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */ ------------------ | Branch (2341:6): [True: 216k, False: 0] ------------------ 2342| 216k| decoder->private_->header_warmup[0] = (FLAC__byte)x; 2343| 216k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2343:7): [True: 0, False: 216k] ------------------ 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| 216k| if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */ ------------------ | Branch (2348:7): [True: 0, False: 216k] ------------------ 2349| 0| decoder->private_->lookahead = (FLAC__byte)x; 2350| 0| decoder->private_->cached = true; 2351| 0| } 2352| 216k| else if(x >> 1 == 0x7c) { /* MAGIC NUMBER for the last 6 sync bits and reserved 7th bit */ ------------------ | Branch (2352:12): [True: 216k, False: 0] ------------------ 2353| 216k| decoder->private_->header_warmup[1] = (FLAC__byte)x; 2354| 216k| 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| 216k| FLAC__bitreader_set_framesync_location(decoder->private_->input); 2359| 216k| if(!FLAC__stream_decoder_get_decode_position(decoder, &decoder->private_->last_seen_framesync)) ------------------ | Branch (2359:8): [True: 216k, False: 0] ------------------ 2360| 216k| decoder->private_->last_seen_framesync = 0; 2361| 216k| return true; 2362| 216k| } 2363| 216k| } 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| 216k|} stream_decoder.c:read_frame_: 2374| 216k|{ 2375| 216k| uint32_t channel; 2376| 216k| uint32_t i; 2377| 216k| uint32_t frame_crc; /* the one we calculate from the input stream */ 2378| 216k| FLAC__uint32 x; 2379| | 2380| 216k| *got_a_frame = false; 2381| 216k| decoder->private_->side_subframe_in_use = false; 2382| | 2383| | /* init the CRC */ 2384| 216k| frame_crc = 0; 2385| 216k| frame_crc = FLAC__CRC16_UPDATE(decoder->private_->header_warmup[0], frame_crc); ------------------ | | 50| 216k|#define FLAC__CRC16_UPDATE(data, crc) ((((crc)<<8) & 0xffff) ^ FLAC__crc16_table[0][((crc)>>8) ^ (data)]) ------------------ 2386| 216k| frame_crc = FLAC__CRC16_UPDATE(decoder->private_->header_warmup[1], frame_crc); ------------------ | | 50| 216k|#define FLAC__CRC16_UPDATE(data, crc) ((((crc)<<8) & 0xffff) ^ FLAC__crc16_table[0][((crc)>>8) ^ (data)]) ------------------ 2387| 216k| FLAC__bitreader_reset_read_crc16(decoder->private_->input, (FLAC__uint16)frame_crc); 2388| | 2389| 216k| if(!read_frame_header_(decoder)) ------------------ | Branch (2389:5): [True: 0, False: 216k] ------------------ 2390| 0| return false; 2391| 216k| 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: 216k] ------------------ 2392| 0| return true; 2393| 216k| 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: 216k] ------------------ 2394| 0| return false; 2395| 500k| for(channel = 0; channel < decoder->private_->frame.header.channels; channel++) { ------------------ | Branch (2395:19): [True: 284k, False: 216k] ------------------ 2396| | /* 2397| | * first figure the correct bits-per-sample of the subframe 2398| | */ 2399| 284k| uint32_t bps = decoder->private_->frame.header.bits_per_sample; 2400| 284k| switch(decoder->private_->frame.header.channel_assignment) { 2401| 220k| case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: ------------------ | Branch (2401:4): [True: 220k, False: 64.2k] ------------------ 2402| | /* no adjustment needed */ 2403| 220k| break; 2404| 28.6k| case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: ------------------ | Branch (2404:4): [True: 28.6k, False: 255k] ------------------ 2405| 28.6k| FLAC__ASSERT(decoder->private_->frame.header.channels == 2); ------------------ | | 38| 28.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 28.6k] | | ------------------ ------------------ 2406| 28.6k| if(channel == 1) ------------------ | Branch (2406:8): [True: 14.3k, False: 14.3k] ------------------ 2407| 14.3k| bps++; 2408| 28.6k| break; 2409| 13.6k| case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: ------------------ | Branch (2409:4): [True: 13.6k, False: 270k] ------------------ 2410| 13.6k| FLAC__ASSERT(decoder->private_->frame.header.channels == 2); ------------------ | | 38| 13.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 13.6k] | | ------------------ ------------------ 2411| 13.6k| if(channel == 0) ------------------ | Branch (2411:8): [True: 6.82k, False: 6.82k] ------------------ 2412| 6.82k| bps++; 2413| 13.6k| break; 2414| 21.9k| case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: ------------------ | Branch (2414:4): [True: 21.9k, False: 262k] ------------------ 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: 284k] ------------------ 2420| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 2421| 284k| } 2422| | /* 2423| | * now read it 2424| | */ 2425| 284k| if(!read_subframe_(decoder, channel, bps, do_full_decode)){ ------------------ | Branch (2425:6): [True: 0, False: 284k] ------------------ 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| 284k| if(decoder->protected_->state != FLAC__STREAM_DECODER_READ_FRAME) ------------------ | Branch (2432:6): [True: 0, False: 284k] ------------------ 2433| 0| break; 2434| 284k| } 2435| | 2436| 216k| if(decoder->protected_->state != FLAC__STREAM_DECODER_END_OF_STREAM) ------------------ | Branch (2436:5): [True: 216k, False: 0] ------------------ 2437| 216k| if(!read_zero_padding_(decoder)) ------------------ | Branch (2437:6): [True: 0, False: 216k] ------------------ 2438| 0| return false; 2439| | 2440| | /* 2441| | * Read the frame CRC-16 from the footer and check 2442| | */ 2443| 216k| if(decoder->protected_->state == FLAC__STREAM_DECODER_READ_FRAME) { ------------------ | Branch (2443:5): [True: 216k, False: 0] ------------------ 2444| 216k| frame_crc = FLAC__bitreader_get_read_crc16(decoder->private_->input); 2445| 216k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, FLAC__FRAME_FOOTER_CRC_LEN)) { ------------------ | Branch (2445:6): [True: 0, False: 216k] ------------------ 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| 216k| if(do_full_decode) { ------------------ | Branch (2454:6): [True: 216k, False: 0] ------------------ 2455| | /* Undo any special channel coding */ 2456| 216k| undo_channel_coding(decoder); 2457| | /* Check whether decoded data actually fits bps */ 2458| 500k| for(channel = 0; channel < decoder->private_->frame.header.channels; channel++) { ------------------ | Branch (2458:21): [True: 284k, False: 216k] ------------------ 2459| 284k| int shift_bits = 32 - decoder->private_->frame.header.bits_per_sample; 2460| 284k| int lower_limit = INT32_MIN >> shift_bits; 2461| 284k| int upper_limit = INT32_MAX >> shift_bits; 2462| 28.3M| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (2462:16): [True: 28.1M, False: 284k] ------------------ 2463| | /* Check whether shift_bits MSBs are 'empty' by shifting up and down */ 2464| 28.1M| if((decoder->private_->output[channel][i] < lower_limit) || ------------------ | Branch (2464:9): [True: 0, False: 28.1M] ------------------ 2465| 28.1M| (decoder->private_->output[channel][i] > upper_limit)) { ------------------ | Branch (2465:9): [True: 0, False: 28.1M] ------------------ 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| 28.1M| } 2472| 284k| } 2473| 216k| } 2474| 216k| } 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| 216k| 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: 207k, False: 8.23k] | Branch (2484:45): [True: 207k, False: 0] | Branch (2484:110): [True: 207k, False: 0] | Branch (2484:144): [True: 207k, False: 0] ------------------ 2485| 207k| FLAC__ASSERT(decoder->private_->frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); ------------------ | | 38| 207k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 207k] | | ------------------ ------------------ 2486| 207k| FLAC__ASSERT(decoder->private_->last_frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); ------------------ | | 38| 207k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 207k] | | ------------------ ------------------ 2487| 207k| 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: 207k] ------------------ 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| 207k| } 2555| | 2556| 216k| decoder->private_->error_has_been_sent = false; 2557| | 2558| 216k| 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: 216k] | Branch (2558:81): [True: 0, False: 216k] ------------------ 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| 216k| else { 2592| 216k| *got_a_frame = true; 2593| 216k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 2594| 216k| decoder->private_->fuzzing_rewind_count = 0; 2595| 216k|#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| 216k| if(decoder->private_->next_fixed_block_size) ------------------ | Branch (2598:6): [True: 8.23k, False: 207k] ------------------ 2599| 8.23k| 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| 216k| decoder->protected_->channels = decoder->private_->frame.header.channels; 2603| 216k| decoder->protected_->channel_assignment = decoder->private_->frame.header.channel_assignment; 2604| 216k| decoder->protected_->bits_per_sample = decoder->private_->frame.header.bits_per_sample; 2605| 216k| decoder->protected_->sample_rate = decoder->private_->frame.header.sample_rate; 2606| 216k| decoder->protected_->blocksize = decoder->private_->frame.header.blocksize; 2607| | 2608| 216k| FLAC__ASSERT(decoder->private_->frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER); ------------------ | | 38| 216k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 216k] | | ------------------ ------------------ 2609| 216k| decoder->private_->samples_decoded = decoder->private_->frame.header.number.sample_number + decoder->private_->frame.header.blocksize; 2610| | 2611| | /* write it */ 2612| 216k| if(do_full_decode) { ------------------ | Branch (2612:6): [True: 216k, False: 0] ------------------ 2613| 216k| 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: 216k] ------------------ 2614| 0| decoder->protected_->state = FLAC__STREAM_DECODER_ABORTED; 2615| 0| return false; 2616| 0| } 2617| 216k| } 2618| 216k| } 2619| | 2620| 216k| decoder->protected_->state = FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; 2621| | return true; 2622| 216k|} stream_decoder.c:read_frame_header_: 2625| 216k|{ 2626| 216k| FLAC__uint32 x; 2627| 216k| FLAC__uint64 xx; 2628| 216k| uint32_t i, blocksize_hint = 0, sample_rate_hint = 0; 2629| 216k| FLAC__byte crc8, raw_header[16]; /* MAGIC NUMBER based on the maximum frame header size, including CRC */ 2630| 216k| uint32_t raw_header_len; 2631| 216k| FLAC__bool is_unparseable = false; 2632| | 2633| 216k| FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)); ------------------ | | 38| 216k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 216k] | | ------------------ ------------------ 2634| | 2635| | /* init the raw header with the saved bits from synchronization */ 2636| 216k| raw_header[0] = decoder->private_->header_warmup[0]; 2637| 216k| raw_header[1] = decoder->private_->header_warmup[1]; 2638| 216k| raw_header_len = 2; 2639| | 2640| | /* check to make sure that reserved bit is 0 */ 2641| 216k| if(raw_header[1] & 0x02) /* MAGIC NUMBER */ ------------------ | Branch (2641:5): [True: 0, False: 216k] ------------------ 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| 648k| for(i = 0; i < 2; i++) { ------------------ | Branch (2666:13): [True: 432k, False: 216k] ------------------ 2667| 432k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2667:6): [True: 0, False: 432k] ------------------ 2668| 0| return false; /* read_callback_ sets the state for us */ 2669| 432k| if(x == 0xff) { /* MAGIC NUMBER for the first 8 frame sync bits */ ------------------ | Branch (2669:6): [True: 0, False: 432k] ------------------ 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| 432k| raw_header[raw_header_len++] = (FLAC__byte)x; 2678| 432k| } 2679| | 2680| 216k| switch(x = raw_header[2] >> 4) { 2681| 0| case 0: ------------------ | Branch (2681:3): [True: 0, False: 216k] ------------------ 2682| 0| is_unparseable = true; 2683| 0| break; 2684| 196| case 1: ------------------ | Branch (2684:3): [True: 196, False: 215k] ------------------ 2685| 196| decoder->private_->frame.header.blocksize = 192; 2686| 196| break; 2687| 195| case 2: ------------------ | Branch (2687:3): [True: 195, False: 215k] ------------------ 2688| 328| case 3: ------------------ | Branch (2688:3): [True: 133, False: 216k] ------------------ 2689| 395| case 4: ------------------ | Branch (2689:3): [True: 67, False: 216k] ------------------ 2690| 446| case 5: ------------------ | Branch (2690:3): [True: 51, False: 216k] ------------------ 2691| 446| decoder->private_->frame.header.blocksize = 576 << (x-2); 2692| 446| break; 2693| 212k| case 6: ------------------ | Branch (2693:3): [True: 212k, False: 3.49k] ------------------ 2694| 214k| case 7: ------------------ | Branch (2694:3): [True: 1.86k, False: 214k] ------------------ 2695| 214k| blocksize_hint = x; 2696| 214k| break; 2697| 218| case 8: ------------------ | Branch (2697:3): [True: 218, False: 215k] ------------------ 2698| 441| case 9: ------------------ | Branch (2698:3): [True: 223, False: 215k] ------------------ 2699| 593| case 10: ------------------ | Branch (2699:3): [True: 152, False: 216k] ------------------ 2700| 702| case 11: ------------------ | Branch (2700:3): [True: 109, False: 216k] ------------------ 2701| 897| case 12: ------------------ | Branch (2701:3): [True: 195, False: 215k] ------------------ 2702| 930| case 13: ------------------ | Branch (2702:3): [True: 33, False: 216k] ------------------ 2703| 966| case 14: ------------------ | Branch (2703:3): [True: 36, False: 216k] ------------------ 2704| 984| case 15: ------------------ | Branch (2704:3): [True: 18, False: 216k] ------------------ 2705| 984| decoder->private_->frame.header.blocksize = 256 << (x-8); 2706| 984| break; 2707| 0| default: ------------------ | Branch (2707:3): [True: 0, False: 216k] ------------------ 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| 216k| } 2711| | 2712| 216k| switch(x = raw_header[2] & 0x0f) { 2713| 19.2k| case 0: ------------------ | Branch (2713:3): [True: 19.2k, False: 196k] ------------------ 2714| 19.2k| if(decoder->private_->has_stream_info) ------------------ | Branch (2714:7): [True: 19.2k, False: 0] ------------------ 2715| 19.2k| decoder->private_->frame.header.sample_rate = decoder->private_->stream_info.data.stream_info.sample_rate; 2716| 0| else 2717| 0| is_unparseable = true; 2718| 19.2k| break; 2719| 239| case 1: ------------------ | Branch (2719:3): [True: 239, False: 215k] ------------------ 2720| 239| decoder->private_->frame.header.sample_rate = 88200; 2721| 239| break; 2722| 594| case 2: ------------------ | Branch (2722:3): [True: 594, False: 215k] ------------------ 2723| 594| decoder->private_->frame.header.sample_rate = 176400; 2724| 594| break; 2725| 2.51k| case 3: ------------------ | Branch (2725:3): [True: 2.51k, False: 213k] ------------------ 2726| 2.51k| decoder->private_->frame.header.sample_rate = 192000; 2727| 2.51k| break; 2728| 1.60k| case 4: ------------------ | Branch (2728:3): [True: 1.60k, False: 214k] ------------------ 2729| 1.60k| decoder->private_->frame.header.sample_rate = 8000; 2730| 1.60k| break; 2731| 234| case 5: ------------------ | Branch (2731:3): [True: 234, False: 215k] ------------------ 2732| 234| decoder->private_->frame.header.sample_rate = 16000; 2733| 234| break; 2734| 6.55k| case 6: ------------------ | Branch (2734:3): [True: 6.55k, False: 209k] ------------------ 2735| 6.55k| decoder->private_->frame.header.sample_rate = 22050; 2736| 6.55k| break; 2737| 388| case 7: ------------------ | Branch (2737:3): [True: 388, False: 215k] ------------------ 2738| 388| decoder->private_->frame.header.sample_rate = 24000; 2739| 388| break; 2740| 9.60k| case 8: ------------------ | Branch (2740:3): [True: 9.60k, False: 206k] ------------------ 2741| 9.60k| decoder->private_->frame.header.sample_rate = 32000; 2742| 9.60k| break; 2743| 33.2k| case 9: ------------------ | Branch (2743:3): [True: 33.2k, False: 182k] ------------------ 2744| 33.2k| decoder->private_->frame.header.sample_rate = 44100; 2745| 33.2k| break; 2746| 251| case 10: ------------------ | Branch (2746:3): [True: 251, False: 215k] ------------------ 2747| 251| decoder->private_->frame.header.sample_rate = 48000; 2748| 251| break; 2749| 2.04k| case 11: ------------------ | Branch (2749:3): [True: 2.04k, False: 214k] ------------------ 2750| 2.04k| decoder->private_->frame.header.sample_rate = 96000; 2751| 2.04k| break; 2752| 6.96k| case 12: ------------------ | Branch (2752:3): [True: 6.96k, False: 209k] ------------------ 2753| 98.0k| case 13: ------------------ | Branch (2753:3): [True: 91.0k, False: 125k] ------------------ 2754| 139k| case 14: ------------------ | Branch (2754:3): [True: 41.7k, False: 174k] ------------------ 2755| 139k| sample_rate_hint = x; 2756| 139k| break; 2757| 0| case 15: ------------------ | Branch (2757:3): [True: 0, False: 216k] ------------------ 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: 216k] ------------------ 2762| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 2763| 216k| } 2764| | 2765| 216k| x = (uint32_t)(raw_header[3] >> 4); 2766| 216k| if(x & 8) { ------------------ | Branch (2766:5): [True: 32.1k, False: 184k] ------------------ 2767| 32.1k| decoder->private_->frame.header.channels = 2; 2768| 32.1k| switch(x & 7) { 2769| 14.3k| case 0: ------------------ | Branch (2769:4): [True: 14.3k, False: 17.7k] ------------------ 2770| 14.3k| decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE; 2771| 14.3k| break; 2772| 6.82k| case 1: ------------------ | Branch (2772:4): [True: 6.82k, False: 25.2k] ------------------ 2773| 6.82k| decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE; 2774| 6.82k| break; 2775| 10.9k| case 2: ------------------ | Branch (2775:4): [True: 10.9k, False: 21.1k] ------------------ 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: 32.1k] ------------------ 2779| 0| is_unparseable = true; 2780| 0| break; 2781| 32.1k| } 2782| 32.1k| } 2783| 184k| else { 2784| 184k| decoder->private_->frame.header.channels = (uint32_t)x + 1; 2785| 184k| decoder->private_->frame.header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; 2786| 184k| } 2787| | 2788| 216k| switch(x = (uint32_t)(raw_header[3] & 0x0e) >> 1) { 2789| 4.29k| case 0: ------------------ | Branch (2789:3): [True: 4.29k, False: 211k] ------------------ 2790| 4.29k| if(decoder->private_->has_stream_info) ------------------ | Branch (2790:7): [True: 4.29k, False: 0] ------------------ 2791| 4.29k| 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.29k| break; 2795| 3.43k| case 1: ------------------ | Branch (2795:3): [True: 3.43k, False: 212k] ------------------ 2796| 3.43k| decoder->private_->frame.header.bits_per_sample = 8; 2797| 3.43k| break; 2798| 268| case 2: ------------------ | Branch (2798:3): [True: 268, False: 215k] ------------------ 2799| 268| decoder->private_->frame.header.bits_per_sample = 12; 2800| 268| break; 2801| 0| case 3: ------------------ | Branch (2801:3): [True: 0, False: 216k] ------------------ 2802| 0| is_unparseable = true; 2803| 0| break; 2804| 4.95k| case 4: ------------------ | Branch (2804:3): [True: 4.95k, False: 211k] ------------------ 2805| 4.95k| decoder->private_->frame.header.bits_per_sample = 16; 2806| 4.95k| break; 2807| 541| case 5: ------------------ | Branch (2807:3): [True: 541, False: 215k] ------------------ 2808| 541| decoder->private_->frame.header.bits_per_sample = 20; 2809| 541| break; 2810| 10.2k| case 6: ------------------ | Branch (2810:3): [True: 10.2k, False: 205k] ------------------ 2811| 10.2k| decoder->private_->frame.header.bits_per_sample = 24; 2812| 10.2k| break; 2813| 192k| case 7: ------------------ | Branch (2813:3): [True: 192k, False: 23.7k] ------------------ 2814| 192k| decoder->private_->frame.header.bits_per_sample = 32; 2815| 192k| break; 2816| 0| default: ------------------ | Branch (2816:3): [True: 0, False: 216k] ------------------ 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| 216k| } 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| 216k| if( 2829| 216k| raw_header[1] & 0x01 || ------------------ | Branch (2829:3): [True: 0, False: 216k] ------------------ 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| 216k| (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: 216k, False: 0] | Branch (2831:42): [True: 0, False: 216k] ------------------ 2832| 216k| ) { /* 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| 216k| else { /* fixed blocksize */ 2846| 216k| if(!FLAC__bitreader_read_utf8_uint32(decoder->private_->input, &x, raw_header, &raw_header_len)) ------------------ | Branch (2846:6): [True: 0, False: 216k] ------------------ 2847| 0| return false; /* read_callback_ sets the state for us */ 2848| 216k| if(x == 0xffffffff) { /* i.e. non-UTF8 code... */ ------------------ | Branch (2848:6): [True: 0, False: 216k] ------------------ 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| 216k| decoder->private_->frame.header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER; 2856| 216k| decoder->private_->frame.header.number.frame_number = x; 2857| 216k| } 2858| | 2859| 216k| if(blocksize_hint) { ------------------ | Branch (2859:5): [True: 214k, False: 1.62k] ------------------ 2860| 214k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2860:6): [True: 0, False: 214k] ------------------ 2861| 0| return false; /* read_callback_ sets the state for us */ 2862| 214k| raw_header[raw_header_len++] = (FLAC__byte)x; 2863| 214k| if(blocksize_hint == 7) { ------------------ | Branch (2863:6): [True: 1.86k, False: 212k] ------------------ 2864| 1.86k| FLAC__uint32 _x; 2865| 1.86k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &_x, 8)) ------------------ | Branch (2865:7): [True: 0, False: 1.86k] ------------------ 2866| 0| return false; /* read_callback_ sets the state for us */ 2867| 1.86k| raw_header[raw_header_len++] = (FLAC__byte)_x; 2868| 1.86k| x = (x << 8) | _x; 2869| 1.86k| } 2870| 214k| decoder->private_->frame.header.blocksize = x+1; 2871| 214k| if(decoder->private_->frame.header.blocksize > 65535) { /* invalid blocksize (65536) specified */ ------------------ | Branch (2871:6): [True: 0, False: 214k] ------------------ 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| 214k| } 2880| | 2881| 216k| if(sample_rate_hint) { ------------------ | Branch (2881:5): [True: 139k, False: 76.4k] ------------------ 2882| 139k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2882:6): [True: 0, False: 139k] ------------------ 2883| 0| return false; /* read_callback_ sets the state for us */ 2884| 139k| raw_header[raw_header_len++] = (FLAC__byte)x; 2885| 139k| if(sample_rate_hint != 12) { ------------------ | Branch (2885:6): [True: 132k, False: 6.96k] ------------------ 2886| 132k| FLAC__uint32 _x; 2887| 132k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &_x, 8)) ------------------ | Branch (2887:7): [True: 0, False: 132k] ------------------ 2888| 0| return false; /* read_callback_ sets the state for us */ 2889| 132k| raw_header[raw_header_len++] = (FLAC__byte)_x; 2890| 132k| x = (x << 8) | _x; 2891| 132k| } 2892| 139k| if(sample_rate_hint == 12) ------------------ | Branch (2892:6): [True: 6.96k, False: 132k] ------------------ 2893| 6.96k| decoder->private_->frame.header.sample_rate = x*1000; 2894| 132k| else if(sample_rate_hint == 13) ------------------ | Branch (2894:11): [True: 91.0k, False: 41.7k] ------------------ 2895| 91.0k| decoder->private_->frame.header.sample_rate = x; 2896| 41.7k| else 2897| 41.7k| decoder->private_->frame.header.sample_rate = x*10; 2898| 139k| } 2899| | 2900| | /* read the CRC-8 byte */ 2901| 216k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) ------------------ | Branch (2901:5): [True: 0, False: 216k] ------------------ 2902| 0| return false; /* read_callback_ sets the state for us */ 2903| 216k| 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| 216k| if(decoder->private_->fuzzing_rewind_count > 8 && (FLAC__crc8(raw_header, raw_header_len) << 4) != (crc8 << 4)) { ------------------ | Branch (2908:5): [True: 0, False: 216k] | 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| 216k| decoder->private_->next_fixed_block_size = 0; 2917| 216k| if(decoder->private_->frame.header.number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER) { ------------------ | Branch (2917:5): [True: 216k, False: 0] ------------------ 2918| 216k| x = decoder->private_->frame.header.number.frame_number; 2919| 216k| decoder->private_->frame.header.number_type = FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER; 2920| 216k| if(decoder->private_->fixed_block_size) ------------------ | Branch (2920:6): [True: 207k, False: 8.23k] ------------------ 2921| 207k| decoder->private_->frame.header.number.sample_number = (FLAC__uint64)decoder->private_->fixed_block_size * (FLAC__uint64)x; 2922| 8.23k| else if(decoder->private_->has_stream_info) { ------------------ | Branch (2922:11): [True: 8.23k, False: 0] ------------------ 2923| 8.23k| if(decoder->private_->stream_info.data.stream_info.min_blocksize == decoder->private_->stream_info.data.stream_info.max_blocksize) { ------------------ | Branch (2923:7): [True: 8.23k, False: 0] ------------------ 2924| 8.23k| decoder->private_->frame.header.number.sample_number = (FLAC__uint64)decoder->private_->stream_info.data.stream_info.min_blocksize * (FLAC__uint64)x; 2925| 8.23k| decoder->private_->next_fixed_block_size = decoder->private_->stream_info.data.stream_info.max_blocksize; 2926| 8.23k| } 2927| 0| else 2928| 0| is_unparseable = true; 2929| 8.23k| } 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| 216k| } 2939| | 2940| 216k| if(is_unparseable) { ------------------ | Branch (2940:5): [True: 0, False: 216k] ------------------ 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| 216k| return true; 2947| 216k|} stream_decoder.c:allocate_output_: 1574| 216k|{ 1575| 216k| uint32_t i; 1576| 216k| FLAC__int32 *tmp; 1577| | 1578| 216k| if(size <= decoder->private_->output_capacity && channels <= decoder->private_->output_channels && ------------------ | Branch (1578:5): [True: 207k, False: 8.23k] | Branch (1578:51): [True: 207k, False: 0] ------------------ 1579| 207k| (bps < 32 || decoder->private_->side_subframe != 0)) ------------------ | Branch (1579:6): [True: 20.9k, False: 186k] | Branch (1579:18): [True: 186k, False: 0] ------------------ 1580| 207k| return true; 1581| | 1582| | /* simply using realloc() is not practical because the number of channels may change mid-stream */ 1583| | 1584| 74.0k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 74.0k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (1584:13): [True: 65.8k, False: 8.23k] ------------------ 1585| 65.8k| if(0 != decoder->private_->output[i]) { ------------------ | Branch (1585:6): [True: 0, False: 65.8k] ------------------ 1586| 0| free(decoder->private_->output[i]-4); 1587| 0| decoder->private_->output[i] = 0; 1588| 0| } 1589| 65.8k| if(0 != decoder->private_->residual_unaligned[i]) { ------------------ | Branch (1589:6): [True: 0, False: 65.8k] ------------------ 1590| 0| free(decoder->private_->residual_unaligned[i]); 1591| 0| decoder->private_->residual_unaligned[i] = decoder->private_->residual[i] = 0; 1592| 0| } 1593| 65.8k| } 1594| | 1595| 8.23k| if(0 != decoder->private_->side_subframe) { ------------------ | Branch (1595:5): [True: 0, False: 8.23k] ------------------ 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| 8.23k| if(decoder->private_->output_capacity > size) { ------------------ | Branch (1601:5): [True: 0, False: 8.23k] ------------------ 1602| 0| size = decoder->private_->output_capacity; 1603| 0| } 1604| | 1605| 22.2k| for(i = 0; i < channels; i++) { ------------------ | Branch (1605:13): [True: 14.0k, False: 8.23k] ------------------ 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| 14.0k| tmp = safe_malloc_muladd2_(sizeof(FLAC__int32), /*times (*/size, /*+*/4/*)*/); 1613| 14.0k| if(tmp == 0) { ------------------ | Branch (1613:6): [True: 0, False: 14.0k] ------------------ 1614| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 1615| 0| return false; 1616| 0| } 1617| 14.0k| memset(tmp, 0, sizeof(FLAC__int32)*4); 1618| 14.0k| decoder->private_->output[i] = tmp + 4; 1619| | 1620| 14.0k| if(!FLAC__memory_alloc_aligned_int32_array(size, &decoder->private_->residual_unaligned[i], &decoder->private_->residual[i])) { ------------------ | Branch (1620:6): [True: 0, False: 14.0k] ------------------ 1621| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 1622| 0| return false; 1623| 0| } 1624| 14.0k| } 1625| | 1626| 8.23k| if(bps == 32) { ------------------ | Branch (1626:5): [True: 5.45k, False: 2.77k] ------------------ 1627| 5.45k| decoder->private_->side_subframe = safe_malloc_mul_2op_p(sizeof(FLAC__int64), /*times (*/size); 1628| 5.45k| if(decoder->private_->side_subframe == NULL) { ------------------ | Branch (1628:6): [True: 0, False: 5.45k] ------------------ 1629| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 1630| 0| return false; 1631| 0| } 1632| 5.45k| } 1633| | 1634| 8.23k| decoder->private_->output_capacity = size; 1635| 8.23k| decoder->private_->output_channels = channels; 1636| | 1637| | return true; 1638| 8.23k|} stream_decoder.c:read_subframe_: 2950| 284k|{ 2951| 284k| FLAC__uint32 x; 2952| 284k| FLAC__bool wasted_bits; 2953| 284k| uint32_t i; 2954| | 2955| 284k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &x, 8)) /* MAGIC NUMBER */ ------------------ | Branch (2955:5): [True: 0, False: 284k] ------------------ 2956| 0| return false; /* read_callback_ sets the state for us */ 2957| | 2958| 284k| wasted_bits = (x & 1); 2959| 284k| x &= 0xfe; 2960| | 2961| 284k| if(wasted_bits) { ------------------ | Branch (2961:5): [True: 26.0k, False: 258k] ------------------ 2962| 26.0k| uint32_t u; 2963| 26.0k| if(!FLAC__bitreader_read_unary_unsigned(decoder->private_->input, &u)) ------------------ | Branch (2963:6): [True: 0, False: 26.0k] ------------------ 2964| 0| return false; /* read_callback_ sets the state for us */ 2965| 26.0k| decoder->private_->frame.subframes[channel].wasted_bits = u+1; 2966| 26.0k| if (decoder->private_->frame.subframes[channel].wasted_bits >= bps) { ------------------ | Branch (2966:7): [True: 0, False: 26.0k] ------------------ 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| 26.0k| bps -= decoder->private_->frame.subframes[channel].wasted_bits; 2972| 26.0k| } 2973| 258k| else 2974| 258k| decoder->private_->frame.subframes[channel].wasted_bits = 0; 2975| | 2976| | /* 2977| | * Lots of magic numbers here 2978| | */ 2979| 284k| if(x & 0x80) { ------------------ | Branch (2979:5): [True: 0, False: 284k] ------------------ 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| 284k| else if(x == 0) { ------------------ | Branch (2984:10): [True: 88.2k, False: 196k] ------------------ 2985| 88.2k| if(!read_subframe_constant_(decoder, channel, bps, do_full_decode)) ------------------ | Branch (2985:6): [True: 0, False: 88.2k] ------------------ 2986| 0| return false; 2987| 88.2k| } 2988| 196k| else if(x == 2) { ------------------ | Branch (2988:10): [True: 42.3k, False: 153k] ------------------ 2989| 42.3k| if(!read_subframe_verbatim_(decoder, channel, bps, do_full_decode)) ------------------ | Branch (2989:6): [True: 0, False: 42.3k] ------------------ 2990| 0| return false; 2991| 42.3k| } 2992| 153k| else if(x < 16) { ------------------ | Branch (2992:10): [True: 0, False: 153k] ------------------ 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| 153k| else if(x <= 24) { ------------------ | Branch (2997:10): [True: 133k, False: 20.1k] ------------------ 2998| 133k| uint32_t predictor_order = (x>>1)&7; 2999| 133k| if(decoder->private_->frame.header.blocksize <= predictor_order){ ------------------ | Branch (2999:6): [True: 0, False: 133k] ------------------ 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| 133k| if(!read_subframe_fixed_(decoder, channel, bps, predictor_order, do_full_decode)) ------------------ | Branch (3004:6): [True: 0, False: 133k] ------------------ 3005| 0| return false; 3006| 133k| if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC) /* means bad sync or got corruption */ ------------------ | Branch (3006:6): [True: 0, False: 133k] ------------------ 3007| 0| return true; 3008| 133k| } 3009| 20.1k| else if(x < 64) { ------------------ | Branch (3009:10): [True: 0, False: 20.1k] ------------------ 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| 20.1k| else { 3015| 20.1k| uint32_t predictor_order = ((x>>1)&31)+1; 3016| 20.1k| if(decoder->private_->frame.header.blocksize <= predictor_order){ ------------------ | Branch (3016:6): [True: 0, False: 20.1k] ------------------ 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| 20.1k| if(!read_subframe_lpc_(decoder, channel, bps, predictor_order, do_full_decode)) ------------------ | Branch (3021:6): [True: 0, False: 20.1k] ------------------ 3022| 0| return false; 3023| 20.1k| if(decoder->protected_->state == FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC) /* means bad sync or got corruption */ ------------------ | Branch (3023:6): [True: 0, False: 20.1k] ------------------ 3024| 0| return true; 3025| 20.1k| } 3026| | 3027| 284k| if(wasted_bits && do_full_decode) { ------------------ | Branch (3027:5): [True: 26.0k, False: 258k] | Branch (3027:20): [True: 26.0k, False: 0] ------------------ 3028| 26.0k| x = decoder->private_->frame.subframes[channel].wasted_bits; 3029| 26.0k| if((bps + x) < 33) { ------------------ | Branch (3029:6): [True: 13.5k, False: 12.5k] ------------------ 3030| 264k| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (3030:15): [True: 250k, False: 13.5k] ------------------ 3031| 250k| uint32_t val = decoder->private_->output[channel][i]; 3032| 250k| decoder->private_->output[channel][i] = (val << x); 3033| 250k| } 3034| 13.5k| } 3035| 12.5k| else { 3036| | /* When there are wasted bits, bps is never 33 and so 3037| | * side_subframe is never already in use */ 3038| 12.5k| FLAC__ASSERT(!decoder->private_->side_subframe_in_use); ------------------ | | 38| 12.5k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.5k] | | ------------------ ------------------ 3039| 12.5k| decoder->private_->side_subframe_in_use = true; 3040| 430k| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (3040:15): [True: 417k, False: 12.5k] ------------------ 3041| 417k| uint64_t val = decoder->private_->output[channel][i]; 3042| 417k| decoder->private_->side_subframe[i] = (val << x); 3043| 417k| } 3044| 12.5k| } 3045| 26.0k| } 3046| | 3047| 284k| return true; 3048| 284k|} stream_decoder.c:read_subframe_constant_: 3051| 88.2k|{ 3052| 88.2k| FLAC__Subframe_Constant *subframe = &decoder->private_->frame.subframes[channel].data.constant; 3053| 88.2k| FLAC__int64 x; 3054| 88.2k| uint32_t i; 3055| | 3056| 88.2k| decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_CONSTANT; 3057| | 3058| 88.2k| if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &x, bps)) ------------------ | Branch (3058:5): [True: 0, False: 88.2k] ------------------ 3059| 0| return false; /* read_callback_ sets the state for us */ 3060| | 3061| 88.2k| subframe->value = x; 3062| | 3063| | /* decode the subframe */ 3064| 88.2k| if(do_full_decode) { ------------------ | Branch (3064:5): [True: 88.2k, False: 0] ------------------ 3065| 88.2k| if(bps <= 32) { ------------------ | Branch (3065:6): [True: 87.4k, False: 802] ------------------ 3066| 87.4k| 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: 87.4k] ------------------ 3068| 1.56M| output[i] = x; 3069| 87.4k| } else { 3070| 802| FLAC__int64 *output = decoder->private_->side_subframe; 3071| 802| decoder->private_->side_subframe_in_use = true; 3072| 14.7k| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) ------------------ | Branch (3072:15): [True: 13.9k, False: 802] ------------------ 3073| 13.9k| output[i] = x; 3074| 802| } 3075| 88.2k| } 3076| | 3077| | return true; 3078| 88.2k|} stream_decoder.c:read_subframe_verbatim_: 3260| 42.3k|{ 3261| 42.3k| FLAC__Subframe_Verbatim *subframe = &decoder->private_->frame.subframes[channel].data.verbatim; 3262| 42.3k| uint32_t i; 3263| | 3264| 42.3k| decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_VERBATIM; 3265| | 3266| 42.3k| if(bps < 33) { ------------------ | Branch (3266:5): [True: 41.4k, False: 901] ------------------ 3267| 41.4k| FLAC__int32 x, *residual = decoder->private_->residual[channel]; 3268| | 3269| 41.4k| subframe->data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32; 3270| 41.4k| subframe->data.int32 = residual; 3271| | 3272| 3.20M| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (3272:14): [True: 3.16M, False: 41.4k] ------------------ 3273| 3.16M| if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &x, bps)) ------------------ | Branch (3273:7): [True: 0, False: 3.16M] ------------------ 3274| 0| return false; /* read_callback_ sets the state for us */ 3275| 3.16M| residual[i] = x; 3276| 3.16M| } 3277| | 3278| | /* decode the subframe */ 3279| 41.4k| if(do_full_decode) ------------------ | Branch (3279:6): [True: 41.4k, False: 0] ------------------ 3280| 41.4k| memcpy(decoder->private_->output[channel], subframe->data.int32, sizeof(FLAC__int32) * decoder->private_->frame.header.blocksize); 3281| 41.4k| } 3282| 901| else { 3283| 901| FLAC__int64 x, *side = decoder->private_->side_subframe; 3284| | 3285| 901| subframe->data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT64; 3286| 901| subframe->data.int64 = side; 3287| 901| decoder->private_->side_subframe_in_use = true; 3288| | 3289| 1.79M| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (3289:14): [True: 1.79M, False: 901] ------------------ 3290| 1.79M| if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &x, bps)) ------------------ | Branch (3290:7): [True: 0, False: 1.79M] ------------------ 3291| 0| return false; /* read_callback_ sets the state for us */ 3292| 1.79M| side[i] = x; 3293| 1.79M| } 3294| 901| } 3295| | 3296| 42.3k| return true; 3297| 42.3k|} stream_decoder.c:read_subframe_fixed_: 3081| 133k|{ 3082| 133k| FLAC__Subframe_Fixed *subframe = &decoder->private_->frame.subframes[channel].data.fixed; 3083| 133k| FLAC__int64 i64; 3084| 133k| FLAC__uint32 u32; 3085| 133k| uint32_t u; 3086| | 3087| 133k| decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_FIXED; 3088| | 3089| 133k| subframe->residual = decoder->private_->residual[channel]; 3090| 133k| subframe->order = order; 3091| | 3092| | /* read warm-up samples */ 3093| 231k| for(u = 0; u < order; u++) { ------------------ | Branch (3093:13): [True: 97.5k, False: 133k] ------------------ 3094| 97.5k| if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &i64, bps)) ------------------ | Branch (3094:6): [True: 0, False: 97.5k] ------------------ 3095| 0| return false; /* read_callback_ sets the state for us */ 3096| 97.5k| subframe->warmup[u] = i64; 3097| 97.5k| } 3098| | 3099| | /* read entropy coding method info */ 3100| 133k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN)) ------------------ | Branch (3100:5): [True: 0, False: 133k] ------------------ 3101| 0| return false; /* read_callback_ sets the state for us */ 3102| 133k| subframe->entropy_coding_method.type = (FLAC__EntropyCodingMethodType)u32; 3103| 133k| switch(subframe->entropy_coding_method.type) { 3104| 58.7k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (3104:3): [True: 58.7k, False: 75.1k] ------------------ 3105| 133k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (3105:3): [True: 75.1k, False: 58.7k] ------------------ 3106| 133k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) ------------------ | Branch (3106:7): [True: 0, False: 133k] ------------------ 3107| 0| return false; /* read_callback_ sets the state for us */ 3108| 133k| if((decoder->private_->frame.header.blocksize >> u32 < order) || ------------------ | Branch (3108:7): [True: 0, False: 133k] ------------------ 3109| 133k| (decoder->private_->frame.header.blocksize % (1 << u32) > 0)) { ------------------ | Branch (3109:7): [True: 0, False: 133k] ------------------ 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| 133k| subframe->entropy_coding_method.data.partitioned_rice.order = u32; 3115| 133k| subframe->entropy_coding_method.data.partitioned_rice.contents = &decoder->private_->partitioned_rice_contents[channel]; 3116| 133k| break; 3117| 0| default: ------------------ | Branch (3117:3): [True: 0, False: 133k] ------------------ 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| 133k| } 3122| | 3123| | /* read residual */ 3124| 133k| switch(subframe->entropy_coding_method.type) { 3125| 58.7k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (3125:3): [True: 58.7k, False: 75.1k] ------------------ 3126| 133k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (3126:3): [True: 75.1k, False: 58.7k] ------------------ 3127| 133k| 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: 133k] ------------------ 3128| 0| return false; 3129| 133k| break; 3130| 133k| default: ------------------ | Branch (3130:3): [True: 0, False: 133k] ------------------ 3131| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 3132| 133k| } 3133| | 3134| | /* decode the subframe */ 3135| 133k| if(do_full_decode) { ------------------ | Branch (3135:5): [True: 133k, False: 0] ------------------ 3136| 133k| if(bps < 33){ ------------------ | Branch (3136:6): [True: 128k, False: 5.23k] ------------------ 3137| 128k| uint32_t i; 3138| 223k| for(i = 0; i < order; i++) ------------------ | Branch (3138:15): [True: 94.5k, False: 128k] ------------------ 3139| 94.5k| decoder->private_->output[channel][i] = subframe->warmup[i]; 3140| 128k| if(bps+order <= 32) ------------------ | Branch (3140:7): [True: 68.1k, False: 60.4k] ------------------ 3141| 68.1k| FLAC__fixed_restore_signal(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, order, decoder->private_->output[channel]+order); 3142| 60.4k| else 3143| 60.4k| FLAC__fixed_restore_signal_wide(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, order, decoder->private_->output[channel]+order); 3144| 128k| } 3145| 5.23k| else { 3146| 5.23k| decoder->private_->side_subframe_in_use = true; 3147| 5.23k| memcpy(decoder->private_->side_subframe, subframe->warmup, sizeof(FLAC__int64) * order); 3148| 5.23k| FLAC__fixed_restore_signal_wide_33bit(decoder->private_->residual[channel], decoder->private_->frame.header.blocksize-order, order, decoder->private_->side_subframe+order); 3149| 5.23k| } 3150| 133k| } 3151| | 3152| | return true; 3153| 133k|} stream_decoder.c:read_residual_partitioned_rice_: 3300| 153k|{ 3301| 153k| FLAC__uint32 rice_parameter; 3302| 153k| int i; 3303| 153k| uint32_t partition, sample, u; 3304| 153k| const uint32_t partitions = 1u << partition_order; 3305| 153k| const uint32_t partition_samples = decoder->private_->frame.header.blocksize >> partition_order; 3306| 153k| 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.0k, False: 71.9k] ------------------ 3307| 153k| 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.0k, False: 71.9k] ------------------ 3308| | 3309| | /* invalid predictor and partition orders mush be handled in the callers */ 3310| 153k| FLAC__ASSERT(partition_order > 0? partition_samples >= predictor_order : decoder->private_->frame.header.blocksize >= predictor_order); ------------------ | | 38| 307k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 153k] | | | Branch (38:30): [True: 70.6k, False: 83.3k] | | ------------------ ------------------ 3311| | 3312| 153k| if(!FLAC__format_entropy_coding_method_partitioned_rice_contents_ensure_size(partitioned_rice_contents, flac_max(6u, partition_order))) { ------------------ | | 55| 153k|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (3312:5): [True: 0, False: 153k] | Branch (3312:106): [True: 152k, False: 1.14k] ------------------ 3313| 0| decoder->protected_->state = FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 3314| 0| return false; 3315| 0| } 3316| | 3317| 153k| sample = 0; 3318| 1.85M| for(partition = 0; partition < partitions; partition++) { ------------------ | Branch (3318:21): [True: 1.69M, False: 153k] ------------------ 3319| 1.69M| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &rice_parameter, plen)) ------------------ | Branch (3319:6): [True: 0, False: 1.69M] ------------------ 3320| 0| return false; /* read_callback_ sets the state for us */ 3321| 1.69M| partitioned_rice_contents->parameters[partition] = rice_parameter; 3322| 1.69M| if(rice_parameter < pesc) { ------------------ | Branch (3322:6): [True: 1.66M, False: 38.1k] ------------------ 3323| 1.66M| partitioned_rice_contents->raw_bits[partition] = 0; 3324| 1.66M| u = (partition == 0) ? partition_samples - predictor_order : partition_samples; ------------------ | Branch (3324:8): [True: 144k, False: 1.51M] ------------------ 3325| 1.66M| if(!decoder->private_->local_bitreader_read_rice_signed_block(decoder->private_->input, residual + sample, u, rice_parameter)){ ------------------ | Branch (3325:7): [True: 0, False: 1.66M] ------------------ 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.66M| sample += u; 3337| 1.66M| } 3338| 38.1k| else { 3339| 38.1k| 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: 38.1k] ------------------ 3340| 0| return false; /* read_callback_ sets the state for us */ 3341| 38.1k| partitioned_rice_contents->raw_bits[partition] = rice_parameter; 3342| 38.1k| if(rice_parameter == 0) { ------------------ | Branch (3342:7): [True: 0, False: 38.1k] ------------------ 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| 38.1k| else{ 3347| 694k| for(u = (partition == 0)? predictor_order : 0; u < partition_samples; u++, sample++) { ------------------ | Branch (3347:13): [True: 9.75k, False: 28.3k] | Branch (3347:52): [True: 655k, False: 38.1k] ------------------ 3348| 655k| if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &i, rice_parameter)) ------------------ | Branch (3348:9): [True: 0, False: 655k] ------------------ 3349| 0| return false; /* read_callback_ sets the state for us */ 3350| 655k| residual[sample] = i; 3351| 655k| } 3352| 38.1k| } 3353| 38.1k| } 3354| 1.69M| } 3355| | 3356| 153k| return true; 3357| 153k|} stream_decoder.c:read_subframe_lpc_: 3156| 20.1k|{ 3157| 20.1k| FLAC__Subframe_LPC *subframe = &decoder->private_->frame.subframes[channel].data.lpc; 3158| 20.1k| FLAC__int32 i32; 3159| 20.1k| FLAC__int64 i64; 3160| 20.1k| FLAC__uint32 u32; 3161| 20.1k| uint32_t u; 3162| | 3163| 20.1k| decoder->private_->frame.subframes[channel].type = FLAC__SUBFRAME_TYPE_LPC; 3164| | 3165| 20.1k| subframe->residual = decoder->private_->residual[channel]; 3166| 20.1k| subframe->order = order; 3167| | 3168| | /* read warm-up samples */ 3169| 124k| for(u = 0; u < order; u++) { ------------------ | Branch (3169:13): [True: 103k, False: 20.1k] ------------------ 3170| 103k| if(!FLAC__bitreader_read_raw_int64(decoder->private_->input, &i64, bps)) ------------------ | Branch (3170:6): [True: 0, False: 103k] ------------------ 3171| 0| return false; /* read_callback_ sets the state for us */ 3172| 103k| subframe->warmup[u] = i64; 3173| 103k| } 3174| | 3175| | /* read qlp coeff precision */ 3176| 20.1k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN)) ------------------ | Branch (3176:5): [True: 0, False: 20.1k] ------------------ 3177| 0| return false; /* read_callback_ sets the state for us */ 3178| 20.1k| if(u32 == (1u << FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN) - 1) { ------------------ | Branch (3178:5): [True: 0, False: 20.1k] ------------------ 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| 20.1k| subframe->qlp_coeff_precision = u32+1; 3184| | 3185| | /* read qlp shift */ 3186| 20.1k| if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &i32, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN)) ------------------ | Branch (3186:5): [True: 0, False: 20.1k] ------------------ 3187| 0| return false; /* read_callback_ sets the state for us */ 3188| 20.1k| if(i32 < 0) { ------------------ | Branch (3188:5): [True: 0, False: 20.1k] ------------------ 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| 20.1k| subframe->quantization_level = i32; 3194| | 3195| | /* read quantized lp coefficiencts */ 3196| 124k| for(u = 0; u < order; u++) { ------------------ | Branch (3196:13): [True: 103k, False: 20.1k] ------------------ 3197| 103k| if(!FLAC__bitreader_read_raw_int32(decoder->private_->input, &i32, subframe->qlp_coeff_precision)) ------------------ | Branch (3197:6): [True: 0, False: 103k] ------------------ 3198| 0| return false; /* read_callback_ sets the state for us */ 3199| 103k| subframe->qlp_coeff[u] = i32; 3200| 103k| } 3201| | 3202| | /* read entropy coding method info */ 3203| 20.1k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN)) ------------------ | Branch (3203:5): [True: 0, False: 20.1k] ------------------ 3204| 0| return false; /* read_callback_ sets the state for us */ 3205| 20.1k| subframe->entropy_coding_method.type = (FLAC__EntropyCodingMethodType)u32; 3206| 20.1k| switch(subframe->entropy_coding_method.type) { 3207| 13.1k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (3207:3): [True: 13.1k, False: 6.95k] ------------------ 3208| 20.1k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (3208:3): [True: 6.95k, False: 13.1k] ------------------ 3209| 20.1k| if(!FLAC__bitreader_read_raw_uint32(decoder->private_->input, &u32, FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) ------------------ | Branch (3209:7): [True: 0, False: 20.1k] ------------------ 3210| 0| return false; /* read_callback_ sets the state for us */ 3211| 20.1k| if((decoder->private_->frame.header.blocksize >> u32 < order) || ------------------ | Branch (3211:7): [True: 0, False: 20.1k] ------------------ 3212| 20.1k| (decoder->private_->frame.header.blocksize % (1 << u32) > 0)) { ------------------ | Branch (3212:7): [True: 0, False: 20.1k] ------------------ 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| 20.1k| subframe->entropy_coding_method.data.partitioned_rice.order = u32; 3218| 20.1k| subframe->entropy_coding_method.data.partitioned_rice.contents = &decoder->private_->partitioned_rice_contents[channel]; 3219| 20.1k| break; 3220| 0| default: ------------------ | Branch (3220:3): [True: 0, False: 20.1k] ------------------ 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| 20.1k| } 3225| | 3226| | /* read residual */ 3227| 20.1k| switch(subframe->entropy_coding_method.type) { 3228| 13.1k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (3228:3): [True: 13.1k, False: 6.95k] ------------------ 3229| 20.1k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (3229:3): [True: 6.95k, False: 13.1k] ------------------ 3230| 20.1k| 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: 20.1k] ------------------ 3231| 0| return false; 3232| 20.1k| break; 3233| 20.1k| default: ------------------ | Branch (3233:3): [True: 0, False: 20.1k] ------------------ 3234| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 3235| 20.1k| } 3236| | 3237| | /* decode the subframe */ 3238| 20.1k| if(do_full_decode) { ------------------ | Branch (3238:5): [True: 20.1k, False: 0] ------------------ 3239| 20.1k| if(bps <= 32) { ------------------ | Branch (3239:6): [True: 18.2k, False: 1.90k] ------------------ 3240| 18.2k| uint32_t i; 3241| 111k| for(i = 0; i < order; i++) ------------------ | Branch (3241:15): [True: 93.2k, False: 18.2k] ------------------ 3242| 93.2k| decoder->private_->output[channel][i] = subframe->warmup[i]; 3243| 18.2k| if(FLAC__lpc_max_residual_bps(bps, subframe->qlp_coeff, order, subframe->quantization_level) <= 32 && ------------------ | Branch (3243:7): [True: 8.41k, False: 9.81k] ------------------ 3244| 8.41k| FLAC__lpc_max_prediction_before_shift_bps(bps, subframe->qlp_coeff, order) <= 32) ------------------ | Branch (3244:7): [True: 6.98k, False: 1.43k] ------------------ 3245| 6.98k| 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| 11.2k| else 3247| 11.2k| 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| 18.2k| } 3249| 1.90k| else { 3250| 1.90k| decoder->private_->side_subframe_in_use = true; 3251| 1.90k| memcpy(decoder->private_->side_subframe, subframe->warmup, sizeof(FLAC__int64) * order); 3252| 1.90k| 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.90k| } 3254| 20.1k| } 3255| | 3256| | return true; 3257| 20.1k|} stream_decoder.c:read_zero_padding_: 3360| 216k|{ 3361| 216k| if(!FLAC__bitreader_is_consumed_byte_aligned(decoder->private_->input)) { ------------------ | Branch (3361:5): [True: 111k, False: 105k] ------------------ 3362| 111k| FLAC__uint32 zero = 0; 3363| 111k| 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: 111k] ------------------ 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| 111k| } 3372| 216k| return true; 3373| 216k|} stream_decoder.c:undo_channel_coding: 3476| 216k|void undo_channel_coding(FLAC__StreamDecoder *decoder) { 3477| 216k| uint32_t i; 3478| 216k| switch(decoder->private_->frame.header.channel_assignment) { 3479| 184k| case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: ------------------ | Branch (3479:2): [True: 184k, False: 32.1k] ------------------ 3480| | /* do nothing */ 3481| 184k| break; 3482| 14.3k| case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: ------------------ | Branch (3482:2): [True: 14.3k, False: 201k] ------------------ 3483| 14.3k| FLAC__ASSERT(decoder->private_->frame.header.channels == 2); ------------------ | | 38| 14.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 14.3k] | | ------------------ ------------------ 3484| 14.3k| FLAC__ASSERT(decoder->private_->side_subframe_in_use != /* logical XOR */ (decoder->private_->frame.header.bits_per_sample < 32)); ------------------ | | 38| 14.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 14.3k] | | ------------------ ------------------ 3485| 448k| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) ------------------ | Branch (3485:14): [True: 433k, False: 14.3k] ------------------ 3486| 433k| if(decoder->private_->side_subframe_in_use) ------------------ | Branch (3486:7): [True: 260k, False: 173k] ------------------ 3487| 260k| decoder->private_->output[1][i] = decoder->private_->output[0][i] - decoder->private_->side_subframe[i]; 3488| 173k| else 3489| 173k| decoder->private_->output[1][i] = decoder->private_->output[0][i] - decoder->private_->output[1][i]; 3490| 14.3k| break; 3491| 6.82k| case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: ------------------ | Branch (3491:2): [True: 6.82k, False: 209k] ------------------ 3492| 6.82k| FLAC__ASSERT(decoder->private_->frame.header.channels == 2); ------------------ | | 38| 6.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.82k] | | ------------------ ------------------ 3493| 6.82k| FLAC__ASSERT(decoder->private_->side_subframe_in_use != /* logical XOR */ (decoder->private_->frame.header.bits_per_sample < 32)); ------------------ | | 38| 6.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.82k] | | ------------------ ------------------ 3494| 333k| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) ------------------ | Branch (3494:14): [True: 326k, False: 6.82k] ------------------ 3495| 326k| if(decoder->private_->side_subframe_in_use) ------------------ | Branch (3495:7): [True: 292k, False: 34.1k] ------------------ 3496| 292k| decoder->private_->output[0][i] = decoder->private_->output[1][i] + decoder->private_->side_subframe[i]; 3497| 34.1k| else 3498| 34.1k| decoder->private_->output[0][i] += decoder->private_->output[1][i]; 3499| 6.82k| break; 3500| 10.9k| case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: ------------------ | Branch (3500:2): [True: 10.9k, False: 205k] ------------------ 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.31M| for(i = 0; i < decoder->private_->frame.header.blocksize; i++) { ------------------ | Branch (3503:14): [True: 2.30M, False: 10.9k] ------------------ 3504| 2.30M| if(!decoder->private_->side_subframe_in_use){ ------------------ | Branch (3504:7): [True: 111k, False: 2.19M] ------------------ 3505| 111k| FLAC__int32 mid, side; 3506| 111k| mid = decoder->private_->output[0][i]; 3507| 111k| side = decoder->private_->output[1][i]; 3508| 111k| mid = ((uint32_t) mid) << 1; 3509| 111k| mid |= (side & 1); /* i.e. if 'side' is odd... */ 3510| 111k| decoder->private_->output[0][i] = (mid + side) >> 1; 3511| 111k| decoder->private_->output[1][i] = (mid - side) >> 1; 3512| 111k| } 3513| 2.19M| else { /* bps == 32 */ 3514| 2.19M| FLAC__int64 mid; 3515| 2.19M| mid = ((uint64_t)decoder->private_->output[0][i]) << 1; 3516| 2.19M| mid |= (decoder->private_->side_subframe[i] & 1); /* i.e. if 'side' is odd... */ 3517| 2.19M| decoder->private_->output[0][i] = (mid + decoder->private_->side_subframe[i]) >> 1; 3518| 2.19M| decoder->private_->output[1][i] = (mid - decoder->private_->side_subframe[i]) >> 1; 3519| 2.19M| } 3520| 2.30M| } 3521| 10.9k| break; 3522| 0| default: ------------------ | Branch (3522:2): [True: 0, False: 216k] ------------------ 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| 216k| } 3526| 216k|} stream_decoder.c:write_audio_frame_to_client_: 3579| 216k|{ 3580| 216k| decoder->private_->last_frame = *frame; /* save the frame */ 3581| 216k| decoder->private_->last_frame_is_set = true; 3582| 216k| if(decoder->private_->is_seeking && !decoder->private_->is_indexing) { ------------------ | Branch (3582:5): [True: 0, False: 216k] | 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| 216k| else if(!decoder->private_->is_indexing) { ------------------ | Branch (3619:10): [True: 216k, 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| 216k| if(!decoder->private_->has_stream_info) ------------------ | Branch (3624:6): [True: 0, False: 216k] ------------------ 3625| 0| decoder->private_->do_md5_checking = false; 3626| 216k| if(decoder->private_->do_md5_checking) { ------------------ | Branch (3626:6): [True: 0, False: 216k] ------------------ 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| 216k| return decoder->private_->write_callback(decoder, frame, buffer, decoder->private_->client_data); 3631| 216k| } 3632| 0| else { /* decoder->private_->is_indexing == true */ 3633| 0| return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; 3634| 0| } 3635| 216k|} FLAC__stream_encoder_new: 584| 12.1k|{ 585| 12.1k| FLAC__StreamEncoder *encoder; 586| 12.1k| uint32_t i; 587| | 588| 12.1k| FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */ ------------------ | | 38| 12.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 12.1k] | | ------------------ ------------------ 589| | 590| 12.1k| encoder = safe_calloc_(1, sizeof(FLAC__StreamEncoder)); 591| 12.1k| if(encoder == 0) { ------------------ | Branch (591:5): [True: 0, False: 12.1k] ------------------ 592| 0| return 0; 593| 0| } 594| | 595| 12.1k| encoder->protected_ = safe_calloc_(1, sizeof(FLAC__StreamEncoderProtected)); 596| 12.1k| if(encoder->protected_ == 0) { ------------------ | Branch (596:5): [True: 0, False: 12.1k] ------------------ 597| 0| free(encoder); 598| 0| return 0; 599| 0| } 600| | 601| 12.1k| encoder->private_ = safe_calloc_(1, sizeof(FLAC__StreamEncoderPrivate)); 602| 12.1k| if(encoder->private_ == 0) { ------------------ | Branch (602:5): [True: 0, False: 12.1k] ------------------ 603| 0| free(encoder->protected_); 604| 0| free(encoder); 605| 0| return 0; 606| 0| } 607| | 608| 12.1k| encoder->private_->threadtask[0] = safe_calloc_(1, sizeof(FLAC__StreamEncoderThreadTask)); 609| 12.1k| if(encoder->private_->threadtask[0] == 0) { ------------------ | Branch (609:5): [True: 0, False: 12.1k] ------------------ 610| 0| free(encoder->private_); 611| 0| free(encoder->protected_); 612| 0| free(encoder); 613| 0| return 0; 614| 0| } 615| | 616| 12.1k| encoder->private_->threadtask[0]->frame = FLAC__bitwriter_new(); 617| 12.1k| if(encoder->private_->threadtask[0]->frame == 0) { ------------------ | Branch (617:5): [True: 0, False: 12.1k] ------------------ 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| 12.1k| encoder->private_->file = 0; 626| | 627| 12.1k| encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED; 628| | 629| 12.1k| set_defaults_(encoder); 630| | 631| 12.1k| encoder->private_->is_being_deleted = false; 632| | 633| 109k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 109k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (633:13): [True: 97.0k, False: 12.1k] ------------------ 634| 97.0k| encoder->private_->threadtask[0]->subframe_workspace_ptr[i][0] = &encoder->private_->threadtask[0]->subframe_workspace[i][0]; 635| 97.0k| encoder->private_->threadtask[0]->subframe_workspace_ptr[i][1] = &encoder->private_->threadtask[0]->subframe_workspace[i][1]; 636| 97.0k| } 637| 36.3k| for(i = 0; i < 2; i++) { ------------------ | Branch (637:13): [True: 24.2k, False: 12.1k] ------------------ 638| 24.2k| encoder->private_->threadtask[0]->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->threadtask[0]->subframe_workspace_mid_side[i][0]; 639| 24.2k| encoder->private_->threadtask[0]->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->threadtask[0]->subframe_workspace_mid_side[i][1]; 640| 24.2k| } 641| 109k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 109k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (641:13): [True: 97.0k, False: 12.1k] ------------------ 642| 97.0k| encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_ptr[i][0] = &encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][0]; 643| 97.0k| encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_ptr[i][1] = &encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][1]; 644| 97.0k| } 645| 36.3k| for(i = 0; i < 2; i++) { ------------------ | Branch (645:13): [True: 24.2k, False: 12.1k] ------------------ 646| 24.2k| 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| 24.2k| 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| 24.2k| } 649| | 650| 109k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 109k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (650:13): [True: 97.0k, False: 12.1k] ------------------ 651| 97.0k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][0]); 652| 97.0k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][1]); 653| 97.0k| } 654| 36.3k| for(i = 0; i < 2; i++) { ------------------ | Branch (654:13): [True: 24.2k, False: 12.1k] ------------------ 655| 24.2k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_mid_side[i][0]); 656| 24.2k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_mid_side[i][1]); 657| 24.2k| } 658| 36.3k| for(i = 0; i < 2; i++) ------------------ | Branch (658:13): [True: 24.2k, False: 12.1k] ------------------ 659| 24.2k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[0]->partitioned_rice_contents_extra[i]); 660| | 661| 12.1k| return encoder; 662| 12.1k|} FLAC__stream_encoder_delete: 665| 12.1k|{ 666| 12.1k| uint32_t i; 667| | 668| 12.1k| if (encoder == NULL) ------------------ | Branch (668:6): [True: 0, False: 12.1k] ------------------ 669| 0| return ; 670| | 671| 12.1k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 12.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.1k] | | ------------------ ------------------ 672| 12.1k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 12.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.1k] | | ------------------ ------------------ 673| 12.1k| FLAC__ASSERT(0 != encoder->private_->threadtask[0]); ------------------ | | 38| 12.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.1k] | | ------------------ ------------------ 674| 12.1k| FLAC__ASSERT(0 != encoder->private_->threadtask[0]->frame); ------------------ | | 38| 12.1k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.1k] | | ------------------ ------------------ 675| | 676| 12.1k| encoder->private_->is_being_deleted = true; 677| | 678| 12.1k| (void)FLAC__stream_encoder_finish(encoder); 679| | 680| 12.1k| if(0 != encoder->private_->verify.decoder) ------------------ | Branch (680:5): [True: 8.73k, False: 3.39k] ------------------ 681| 8.73k| FLAC__stream_decoder_delete(encoder->private_->verify.decoder); 682| | 683| 109k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 109k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (683:13): [True: 97.0k, False: 12.1k] ------------------ 684| 97.0k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][0]); 685| 97.0k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace[i][1]); 686| 97.0k| } 687| 36.3k| for(i = 0; i < 2; i++) { ------------------ | Branch (687:13): [True: 24.2k, False: 12.1k] ------------------ 688| 24.2k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_mid_side[i][0]); 689| 24.2k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[0]->partitioned_rice_contents_workspace_mid_side[i][1]); 690| 24.2k| } 691| 36.3k| for(i = 0; i < 2; i++) ------------------ | Branch (691:13): [True: 24.2k, False: 12.1k] ------------------ 692| 24.2k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[0]->partitioned_rice_contents_extra[i]); 693| | 694| 12.1k| FLAC__bitwriter_delete(encoder->private_->threadtask[0]->frame); 695| 12.1k| free(encoder->private_->threadtask[0]); 696| 12.1k| free(encoder->private_); 697| 12.1k| free(encoder->protected_); 698| 12.1k| free(encoder); 699| 12.1k|} FLAC__stream_encoder_init_stream: 1450| 6.87k|{ 1451| 6.87k| return init_stream_internal_( 1452| 6.87k| encoder, 1453| 6.87k| /*read_callback=*/0, 1454| 6.87k| write_callback, 1455| 6.87k| seek_callback, 1456| 6.87k| tell_callback, 1457| 6.87k| metadata_callback, 1458| 6.87k| client_data, 1459| | /*is_ogg=*/false 1460| 6.87k| ); 1461| 6.87k|} FLAC__stream_encoder_init_ogg_stream: 1472| 3.17k|{ 1473| 3.17k| return init_stream_internal_( 1474| 3.17k| encoder, 1475| 3.17k| read_callback, 1476| 3.17k| write_callback, 1477| 3.17k| seek_callback, 1478| 3.17k| tell_callback, 1479| 3.17k| metadata_callback, 1480| 3.17k| client_data, 1481| | /*is_ogg=*/true 1482| 3.17k| ); 1483| 3.17k|} FLAC__stream_encoder_finish: 1626| 36.3k|{ 1627| 36.3k| FLAC__bool error = false; 1628| | 1629| 36.3k| if (encoder == NULL) ------------------ | Branch (1629:6): [True: 0, False: 36.3k] ------------------ 1630| 0| return false; 1631| | 1632| 36.3k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 36.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 36.3k] | | ------------------ ------------------ 1633| 36.3k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 36.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 36.3k] | | ------------------ ------------------ 1634| | 1635| 36.3k| if(encoder->protected_->state == FLAC__STREAM_ENCODER_UNINITIALIZED){ ------------------ | Branch (1635:5): [True: 26.5k, False: 9.82k] ------------------ 1636| 26.5k| if(encoder->protected_->metadata){ // True in case FLAC__stream_encoder_set_metadata was used but init failed ------------------ | Branch (1636:6): [True: 0, False: 26.5k] ------------------ 1637| 0| free(encoder->protected_->metadata); 1638| 0| encoder->protected_->metadata = 0; 1639| 0| encoder->protected_->num_metadata_blocks = 0; 1640| 0| } 1641| 26.5k| if(0 != encoder->private_->file) { ------------------ | Branch (1641:6): [True: 0, False: 26.5k] ------------------ 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| 26.5k| return true; 1647| 26.5k| } 1648| | 1649| 9.82k| if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK && !encoder->private_->is_being_deleted) { ------------------ | Branch (1649:5): [True: 9.76k, False: 65] | Branch (1649:62): [True: 9.76k, False: 0] ------------------ 1650| 9.76k| FLAC__bool ok = true; 1651| | /* first finish threads */ 1652| 9.76k| if(encoder->protected_->num_threads > 1) { ------------------ | Branch (1652:6): [True: 783, False: 8.97k] ------------------ 1653| 783|#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| 783| uint32_t start, end, t, twrap; 1671| 783| if(encoder->private_->num_started_threadtasks < encoder->private_->num_threadtasks) { ------------------ | Branch (1671:7): [True: 466, False: 317] ------------------ 1672| 466| start = 1; 1673| 466| end = encoder->private_->num_started_threadtasks; 1674| 466| } 1675| 317| else { 1676| 317| start = encoder->private_->next_thread; 1677| 317| end = encoder->private_->next_thread + encoder->private_->num_threadtasks - 1; 1678| 317| } 1679| 6.40k| for(twrap = start; twrap < end; twrap++) { ------------------ | Branch (1679:23): [True: 5.62k, False: 783] ------------------ 1680| 5.62k| FLAC__ASSERT(twrap > 0); ------------------ | | 38| 5.62k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 5.62k] | | ------------------ ------------------ 1681| 5.62k| t = (twrap - 1) % (encoder->private_->num_threadtasks - 1) + 1; 1682| | /* Lock mutex, if task isn't done yet, wait for condition */ 1683| 5.62k| FLAC__mtx_lock(&encoder->private_->threadtask[t]->mutex_this_task); ------------------ | | 105| 5.62k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 1684| 5.74k| while(!encoder->private_->threadtask[t]->task_done) ------------------ | Branch (1684:11): [True: 122, False: 5.62k] ------------------ 1685| 122| FLAC__cnd_wait(&encoder->private_->threadtask[t]->cond_task_done,&encoder->private_->threadtask[t]->mutex_this_task); ------------------ | | 113| 5.74k|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 1686| | 1687| 5.62k| if(!encoder->private_->threadtask[t]->returnvalue) ------------------ | Branch (1687:8): [True: 0, False: 5.62k] ------------------ 1688| 0| ok = false; 1689| 5.62k| if(ok && !write_bitbuffer_(encoder, encoder->private_->threadtask[t], encoder->protected_->blocksize, 0)) ------------------ | Branch (1689:8): [True: 5.62k, False: 0] | Branch (1689:14): [True: 0, False: 5.62k] ------------------ 1690| 0| ok = false; 1691| 5.62k| FLAC__mtx_unlock(&encoder->private_->threadtask[t]->mutex_this_task); ------------------ | | 106| 5.62k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 1692| 5.62k| } 1693| | /* Wait for MD5 calculation to finish */ 1694| 783| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 783|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 1695| 788| while(encoder->private_->md5_active || encoder->private_->md5_fifo.tail > 0) { ------------------ | Branch (1695:10): [True: 5, False: 783] | Branch (1695:43): [True: 0, False: 783] ------------------ 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| 783| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 783|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 1699| |#else 1700| | FLAC__ASSERT(0); 1701| |#endif 1702| 783| } 1703| 9.76k| if(ok && encoder->private_->current_sample_number != 0) { ------------------ | Branch (1703:6): [True: 9.76k, False: 0] | Branch (1703:12): [True: 8.95k, False: 811] ------------------ 1704| 8.95k| encoder->protected_->blocksize = encoder->private_->current_sample_number; 1705| 8.95k| if(!resize_buffers_(encoder, encoder->protected_->blocksize)) { ------------------ | Branch (1705:7): [True: 0, False: 8.95k] ------------------ 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.95k| if(!process_frame_(encoder, /*is_last_block=*/true)) ------------------ | Branch (1709:7): [True: 0, False: 8.95k] ------------------ 1710| 0| error = true; 1711| 8.95k| } 1712| 9.76k| } 1713| | 1714| 9.82k| if(encoder->protected_->num_threads > 1) { ------------------ | Branch (1714:5): [True: 796, False: 9.03k] ------------------ 1715| 796|#ifdef FLAC__USE_THREADS 1716| | /* Properly finish all threads */ 1717| 796| uint32_t t; 1718| 796| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 796|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 1719| 3.65k| for(t = 1; t < encoder->private_->num_created_threads; t++) ------------------ | Branch (1719:14): [True: 2.85k, False: 796] ------------------ 1720| 2.85k| encoder->private_->finish_work_threads = true; 1721| 796| FLAC__cnd_broadcast(&encoder->private_->cond_wake_up_thread); ------------------ | | 111| 796|#define FLAC__cnd_broadcast(cv) pthread_cond_broadcast(cv) ------------------ 1722| 796| FLAC__cnd_broadcast(&encoder->private_->cond_work_available); ------------------ | | 111| 796|#define FLAC__cnd_broadcast(cv) pthread_cond_broadcast(cv) ------------------ 1723| 796| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 796|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 1724| | 1725| 3.65k| for(t = 1; t < encoder->private_->num_created_threads; t++) ------------------ | Branch (1725:14): [True: 2.85k, False: 796] ------------------ 1726| 2.85k| FLAC__thrd_join(encoder->private_->thread[t], NULL); ------------------ | | 99| 2.85k|#define FLAC__thrd_join(thread, result) pthread_join(thread, result) ------------------ 1727| |#else 1728| | FLAC__ASSERT(0); 1729| |#endif 1730| 796| } 1731| | 1732| 9.82k| if(encoder->protected_->do_md5) ------------------ | Branch (1732:5): [True: 9.82k, False: 0] ------------------ 1733| 9.82k| FLAC__MD5Final(encoder->private_->streaminfo.data.stream_info.md5sum, &encoder->private_->md5context); 1734| | 1735| 9.82k| if(!encoder->private_->is_being_deleted) { ------------------ | Branch (1735:5): [True: 9.82k, False: 0] ------------------ 1736| 9.82k| if(encoder->protected_->state == FLAC__STREAM_ENCODER_OK) { ------------------ | Branch (1736:6): [True: 9.76k, False: 65] ------------------ 1737| 9.76k| if(encoder->private_->seek_callback) { ------------------ | Branch (1737:7): [True: 9.76k, False: 0] ------------------ 1738| 9.76k|#if FLAC__HAS_OGG 1739| 9.76k| if(encoder->private_->is_ogg) ------------------ | Branch (1739:8): [True: 3.09k, False: 6.67k] ------------------ 1740| 3.09k| update_ogg_metadata_(encoder); 1741| 6.67k| else 1742| 6.67k|#endif 1743| 6.67k| update_metadata_(encoder); 1744| | 1745| | /* check if an error occurred while updating metadata */ 1746| 9.76k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK) ------------------ | Branch (1746:8): [True: 0, False: 9.76k] ------------------ 1747| 0| error = true; 1748| 9.76k| } 1749| 9.76k| if(encoder->private_->metadata_callback) ------------------ | Branch (1749:7): [True: 9.76k, False: 0] ------------------ 1750| 9.76k| encoder->private_->metadata_callback(encoder, &encoder->private_->streaminfo, encoder->private_->client_data); 1751| 9.76k| } 1752| | 1753| 9.82k| if(encoder->protected_->verify && 0 != encoder->private_->verify.decoder && !FLAC__stream_decoder_finish(encoder->private_->verify.decoder)) { ------------------ | Branch (1753:6): [True: 8.73k, False: 1.08k] | Branch (1753:37): [True: 8.73k, False: 0] | Branch (1753:79): [True: 0, False: 8.73k] ------------------ 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.82k| } 1759| | 1760| 9.82k| if(0 != encoder->private_->file) { ------------------ | Branch (1760:5): [True: 0, False: 9.82k] ------------------ 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.82k|#if FLAC__HAS_OGG 1767| 9.82k| if(encoder->private_->is_ogg) ------------------ | Branch (1767:5): [True: 3.09k, False: 6.72k] ------------------ 1768| 3.09k| FLAC__ogg_encoder_aspect_finish(&encoder->protected_->ogg_encoder_aspect); 1769| 9.82k|#endif 1770| | 1771| 9.82k| free_(encoder); 1772| 9.82k| set_defaults_(encoder); 1773| | 1774| 9.82k| if(!error) ------------------ | Branch (1774:5): [True: 9.82k, False: 0] ------------------ 1775| 9.82k| encoder->protected_->state = FLAC__STREAM_ENCODER_UNINITIALIZED; 1776| | 1777| 9.82k| return !error; 1778| 9.82k|} FLAC__stream_encoder_set_ogg_serial_number: 1781| 21.9k|{ 1782| 21.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1783| 21.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1784| 21.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1785| 21.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1785:5): [True: 9.82k, False: 12.0k] ------------------ 1786| 9.82k| return false; 1787| 12.0k|#if FLAC__HAS_OGG 1788| | /* can't check encoder->private_->is_ogg since that's not set until init time */ 1789| 12.0k| FLAC__ogg_encoder_aspect_set_serial_number(&encoder->protected_->ogg_encoder_aspect, value); 1790| 12.0k| return true; 1791| |#else 1792| | (void)value; 1793| | return false; 1794| |#endif 1795| 21.9k|} FLAC__stream_encoder_set_verify: 1798| 21.9k|{ 1799| 21.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1800| 21.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1801| 21.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1802| 21.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1802:5): [True: 9.82k, False: 12.0k] ------------------ 1803| 9.82k| return false; 1804| 12.0k|#ifndef FLAC__MANDATORY_VERIFY_WHILE_ENCODING 1805| 12.0k| encoder->protected_->verify = value; 1806| 12.0k|#endif 1807| | return true; 1808| 21.9k|} FLAC__stream_encoder_set_streamable_subset: 1811| 21.9k|{ 1812| 21.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1813| 21.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1814| 21.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1815| 21.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1815:5): [True: 9.82k, False: 12.0k] ------------------ 1816| 9.82k| return false; 1817| 12.0k| encoder->protected_->streamable_subset = value; 1818| | return true; 1819| 21.9k|} FLAC__stream_encoder_set_channels: 1841| 21.9k|{ 1842| 21.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1843| 21.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1844| 21.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1845| 21.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1845:5): [True: 9.82k, False: 12.0k] ------------------ 1846| 9.82k| return false; 1847| 12.0k| encoder->protected_->channels = value; 1848| | return true; 1849| 21.9k|} FLAC__stream_encoder_set_bits_per_sample: 1852| 21.9k|{ 1853| 21.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1854| 21.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1855| 21.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 1856| 21.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1856:5): [True: 9.82k, False: 12.0k] ------------------ 1857| 9.82k| return false; 1858| 12.0k| encoder->protected_->bits_per_sample = value; 1859| | return true; 1860| 21.9k|} FLAC__stream_encoder_set_sample_rate: 1863| 19.9k|{ 1864| 19.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 1865| 19.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 1866| 19.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 1867| 19.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1867:5): [True: 9.82k, False: 10.1k] ------------------ 1868| 9.82k| return false; 1869| 10.1k| encoder->protected_->sample_rate = value; 1870| | return true; 1871| 19.9k|} FLAC__stream_encoder_set_compression_level: 1874| 43.8k|{ 1875| 43.8k| FLAC__bool ok = true; 1876| 43.8k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 43.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.8k] | | ------------------ ------------------ 1877| 43.8k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 43.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.8k] | | ------------------ ------------------ 1878| 43.8k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 43.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.8k] | | ------------------ ------------------ 1879| 43.8k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1879:5): [True: 19.6k, False: 24.2k] ------------------ 1880| 19.6k| return false; 1881| 24.2k| if(value >= sizeof(compression_levels_)/sizeof(compression_levels_[0])) ------------------ | Branch (1881:5): [True: 9.88k, False: 14.3k] ------------------ 1882| 9.88k| value = sizeof(compression_levels_)/sizeof(compression_levels_[0]) - 1; 1883| 24.2k| ok &= FLAC__stream_encoder_set_do_mid_side_stereo (encoder, compression_levels_[value].do_mid_side_stereo); 1884| 24.2k| ok &= FLAC__stream_encoder_set_loose_mid_side_stereo (encoder, compression_levels_[value].loose_mid_side_stereo); 1885| 24.2k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 1886| 24.2k|#if 1 1887| 24.2k| 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| 24.2k|#endif 1895| 24.2k| ok &= FLAC__stream_encoder_set_max_lpc_order (encoder, compression_levels_[value].max_lpc_order); 1896| 24.2k| ok &= FLAC__stream_encoder_set_qlp_coeff_precision (encoder, compression_levels_[value].qlp_coeff_precision); 1897| 24.2k| ok &= FLAC__stream_encoder_set_do_qlp_coeff_prec_search (encoder, compression_levels_[value].do_qlp_coeff_prec_search); 1898| 24.2k| ok &= FLAC__stream_encoder_set_do_escape_coding (encoder, compression_levels_[value].do_escape_coding); 1899| 24.2k| ok &= FLAC__stream_encoder_set_do_exhaustive_model_search (encoder, compression_levels_[value].do_exhaustive_model_search); 1900| 24.2k| ok &= FLAC__stream_encoder_set_min_residual_partition_order(encoder, compression_levels_[value].min_residual_partition_order); 1901| 24.2k| ok &= FLAC__stream_encoder_set_max_residual_partition_order(encoder, compression_levels_[value].max_residual_partition_order); 1902| 24.2k| ok &= FLAC__stream_encoder_set_rice_parameter_search_dist (encoder, compression_levels_[value].rice_parameter_search_dist); 1903| 24.2k| return ok; 1904| 43.8k|} FLAC__stream_encoder_set_blocksize: 1907| 19.9k|{ 1908| 19.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 1909| 19.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 1910| 19.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 1911| 19.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1911:5): [True: 9.82k, False: 10.1k] ------------------ 1912| 9.82k| return false; 1913| 10.1k| encoder->protected_->blocksize = value; 1914| | return true; 1915| 19.9k|} FLAC__stream_encoder_set_do_mid_side_stereo: 1918| 46.0k|{ 1919| 46.0k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 46.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 46.0k] | | ------------------ ------------------ 1920| 46.0k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 46.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 46.0k] | | ------------------ ------------------ 1921| 46.0k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 46.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 46.0k] | | ------------------ ------------------ 1922| 46.0k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1922:5): [True: 9.82k, False: 36.2k] ------------------ 1923| 9.82k| return false; 1924| 36.2k| encoder->protected_->do_mid_side_stereo = value; 1925| | return true; 1926| 46.0k|} FLAC__stream_encoder_set_loose_mid_side_stereo: 1929| 46.0k|{ 1930| 46.0k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 46.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 46.0k] | | ------------------ ------------------ 1931| 46.0k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 46.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 46.0k] | | ------------------ ------------------ 1932| 46.0k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 46.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 46.0k] | | ------------------ ------------------ 1933| 46.0k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1933:5): [True: 9.82k, False: 36.2k] ------------------ 1934| 9.82k| return false; 1935| 36.2k| encoder->protected_->loose_mid_side_stereo = value; 1936| | return true; 1937| 46.0k|} FLAC__stream_encoder_set_apodization: 1941| 47.4k|{ 1942| 47.4k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 47.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 47.4k] | | ------------------ ------------------ 1943| 47.4k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 47.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 47.4k] | | ------------------ ------------------ 1944| 47.4k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 47.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 47.4k] | | ------------------ ------------------ 1945| 47.4k| FLAC__ASSERT(0 != specification); ------------------ | | 38| 47.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 47.4k] | | ------------------ ------------------ 1946| 47.4k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (1946:5): [True: 9.82k, False: 37.6k] ------------------ 1947| 9.82k| 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| 37.6k| encoder->protected_->num_apodizations = 0; 1952| 74.5k| while(1) { ------------------ | Branch (1952:8): [True: 74.5k, Folded] ------------------ 1953| 74.5k| const char *s = strchr(specification, ';'); 1954| 74.5k| const size_t n = s? (size_t)(s - specification) : strlen(specification); ------------------ | Branch (1954:20): [True: 36.9k, False: 37.6k] ------------------ 1955| 74.5k| if (n==8 && 0 == strncmp("bartlett" , specification, n)) ------------------ | Branch (1955:11): [True: 2.48k, False: 72.0k] | Branch (1955:20): [True: 558, False: 1.92k] ------------------ 1956| 558| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT; 1957| 74.0k| else if(n==13 && 0 == strncmp("bartlett_hann", specification, n)) ------------------ | Branch (1957:11): [True: 1.00k, False: 73.0k] | Branch (1957:20): [True: 131, False: 875] ------------------ 1958| 131| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BARTLETT_HANN; 1959| 73.8k| else if(n==8 && 0 == strncmp("blackman" , specification, n)) ------------------ | Branch (1959:11): [True: 1.92k, False: 71.9k] | Branch (1959:20): [True: 119, False: 1.80k] ------------------ 1960| 119| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN; 1961| 73.7k| else if(n==26 && 0 == strncmp("blackman_harris_4term_92db", specification, n)) ------------------ | Branch (1961:11): [True: 1.13k, False: 72.6k] | Branch (1961:20): [True: 97, False: 1.03k] ------------------ 1962| 97| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE; 1963| 73.6k| else if(n==6 && 0 == strncmp("connes" , specification, n)) ------------------ | Branch (1963:11): [True: 1.30k, False: 72.3k] | Branch (1963:20): [True: 249, False: 1.05k] ------------------ 1964| 249| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_CONNES; 1965| 73.4k| else if(n==7 && 0 == strncmp("flattop" , specification, n)) ------------------ | Branch (1965:11): [True: 1.67k, False: 71.7k] | Branch (1965:20): [True: 178, False: 1.49k] ------------------ 1966| 178| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_FLATTOP; 1967| 73.2k| else if(n>7 && 0 == strncmp("gauss(" , specification, 6)) { ------------------ | Branch (1967:11): [True: 39.1k, False: 34.1k] | Branch (1967:20): [True: 416, False: 38.7k] ------------------ 1968| 416| FLAC__real stddev = (FLAC__real)strtod(specification+6, 0); 1969| 416| if (stddev > 0.0 && stddev <= 0.5) { ------------------ | Branch (1969:8): [True: 249, False: 167] | Branch (1969:24): [True: 176, False: 73] ------------------ 1970| 176| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.gauss.stddev = stddev; 1971| 176| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_GAUSS; 1972| 176| } 1973| 416| } 1974| 72.8k| else if(n==7 && 0 == strncmp("hamming" , specification, n)) ------------------ | Branch (1974:11): [True: 1.49k, False: 71.3k] | Branch (1974:20): [True: 245, False: 1.25k] ------------------ 1975| 245| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HAMMING; 1976| 72.5k| else if(n==4 && 0 == strncmp("hann" , specification, n)) ------------------ | Branch (1976:11): [True: 2.24k, False: 70.3k] | Branch (1976:20): [True: 491, False: 1.75k] ------------------ 1977| 491| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_HANN; 1978| 72.0k| else if(n==13 && 0 == strncmp("kaiser_bessel", specification, n)) ------------------ | Branch (1978:11): [True: 872, False: 71.2k] | Branch (1978:20): [True: 145, False: 727] ------------------ 1979| 145| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_KAISER_BESSEL; 1980| 71.9k| else if(n==7 && 0 == strncmp("nuttall" , specification, n)) ------------------ | Branch (1980:11): [True: 1.25k, False: 70.7k] | Branch (1980:20): [True: 163, False: 1.08k] ------------------ 1981| 163| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_NUTTALL; 1982| 71.7k| else if(n==9 && 0 == strncmp("rectangle" , specification, n)) ------------------ | Branch (1982:11): [True: 1.07k, False: 70.7k] | Branch (1982:20): [True: 216, False: 859] ------------------ 1983| 216| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_RECTANGLE; 1984| 71.5k| else if(n==8 && 0 == strncmp("triangle" , specification, n)) ------------------ | Branch (1984:11): [True: 1.74k, False: 69.8k] | Branch (1984:20): [True: 539, False: 1.20k] ------------------ 1985| 539| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TRIANGLE; 1986| 71.0k| else if(n>7 && 0 == strncmp("tukey(" , specification, 6)) { ------------------ | Branch (1986:11): [True: 37.8k, False: 33.2k] | Branch (1986:20): [True: 14.7k, False: 23.0k] ------------------ 1987| 14.7k| FLAC__real p = (FLAC__real)strtod(specification+6, 0); 1988| 14.7k| if (p >= 0.0 && p <= 1.0) { ------------------ | Branch (1988:8): [True: 14.6k, False: 93] | Branch (1988:20): [True: 14.5k, False: 80] ------------------ 1989| 14.5k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = p; 1990| 14.5k| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY; 1991| 14.5k| } 1992| 14.7k| } 1993| 56.2k| else if(n>15 && 0 == strncmp("partial_tukey(", specification, 14)) { ------------------ | Branch (1993:11): [True: 18.6k, False: 37.5k] | Branch (1993:21): [True: 1.48k, False: 17.2k] ------------------ 1994| 1.48k| FLAC__int32 tukey_parts = (FLAC__int32)strtod(specification+14, 0); 1995| 1.48k| const char *si_1 = strchr(specification, '/'); 1996| 1.48k| FLAC__real overlap = si_1?flac_min((FLAC__real)strtod(si_1+1, 0),0.99f):0.1f; ------------------ | | 56| 1.48k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (1996:25): [True: 703, False: 780] | Branch (1996:30): [True: 481, False: 222] ------------------ 1997| 1.48k| FLAC__real overlap_units = 1.0f/(1.0f - overlap) - 1.0f; 1998| 1.48k| const char *si_2 = strchr((si_1?(si_1+1):specification), '/'); ------------------ | Branch (1998:31): [True: 703, False: 780] ------------------ 1999| 1.48k| FLAC__real tukey_p = si_2?(FLAC__real)strtod(si_2+1, 0):0.2f; ------------------ | Branch (1999:25): [True: 447, False: 1.03k] ------------------ 2000| | 2001| 1.48k| if (tukey_parts <= 1) { ------------------ | Branch (2001:8): [True: 196, False: 1.28k] ------------------ 2002| 196| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p; 2003| 196| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY; 2004| 1.28k| }else if (encoder->protected_->num_apodizations + tukey_parts < 32){ ------------------ | Branch (2004:14): [True: 710, False: 577] ------------------ 2005| 710| FLAC__int32 m; 2006| 6.29k| for(m = 0; m < tukey_parts; m++){ ------------------ | Branch (2006:16): [True: 5.58k, False: 710] ------------------ 2007| 5.58k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p; 2008| 5.58k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units); 2009| 5.58k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units); 2010| 5.58k| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PARTIAL_TUKEY; 2011| 5.58k| } 2012| 710| } 2013| 1.48k| } 2014| 54.7k| else if(n>16 && 0 == strncmp("punchout_tukey(", specification, 15)) { ------------------ | Branch (2014:11): [True: 16.9k, False: 37.8k] | Branch (2014:21): [True: 1.38k, False: 15.5k] ------------------ 2015| 1.38k| FLAC__int32 tukey_parts = (FLAC__int32)strtod(specification+15, 0); 2016| 1.38k| const char *si_1 = strchr(specification, '/'); 2017| 1.38k| FLAC__real overlap = si_1?flac_min((FLAC__real)strtod(si_1+1, 0),0.99f):0.2f; ------------------ | | 56| 1.38k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (2017:25): [True: 650, False: 730] | Branch (2017:30): [True: 415, False: 235] ------------------ 2018| 1.38k| FLAC__real overlap_units = 1.0f/(1.0f - overlap) - 1.0f; 2019| 1.38k| const char *si_2 = strchr((si_1?(si_1+1):specification), '/'); ------------------ | Branch (2019:31): [True: 650, False: 730] ------------------ 2020| 1.38k| FLAC__real tukey_p = si_2?(FLAC__real)strtod(si_2+1, 0):0.2f; ------------------ | Branch (2020:25): [True: 425, False: 955] ------------------ 2021| | 2022| 1.38k| if (tukey_parts <= 1) { ------------------ | Branch (2022:8): [True: 427, False: 953] ------------------ 2023| 427| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.tukey.p = tukey_p; 2024| 427| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_TUKEY; 2025| 953| }else if (encoder->protected_->num_apodizations + tukey_parts < 32){ ------------------ | Branch (2025:14): [True: 428, False: 525] ------------------ 2026| 428| FLAC__int32 m; 2027| 6.23k| for(m = 0; m < tukey_parts; m++){ ------------------ | Branch (2027:16): [True: 5.80k, False: 428] ------------------ 2028| 5.80k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.p = tukey_p; 2029| 5.80k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.start = m/(tukey_parts+overlap_units); 2030| 5.80k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.multiple_tukey.end = (m+1+overlap_units)/(tukey_parts+overlap_units); 2031| 5.80k| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_PUNCHOUT_TUKEY; 2032| 5.80k| } 2033| 428| } 2034| 1.38k| } 2035| 53.4k| else if(n>17 && 0 == strncmp("subdivide_tukey(", specification, 16)){ ------------------ | Branch (2035:11): [True: 15.2k, False: 38.1k] | Branch (2035:20): [True: 12.1k, False: 3.12k] ------------------ 2036| 12.1k| FLAC__int32 parts = (FLAC__int32)strtod(specification+16, 0); 2037| 12.1k| if(parts > 1){ ------------------ | Branch (2037:7): [True: 11.9k, False: 240] ------------------ 2038| 11.9k| const char *si_1 = strchr(specification, '/'); 2039| 11.9k| FLAC__real p = si_1?(FLAC__real)strtod(si_1+1, 0):5e-1; ------------------ | Branch (2039:20): [True: 893, False: 11.0k] ------------------ 2040| 11.9k| if(p > 1) ------------------ | Branch (2040:8): [True: 79, False: 11.8k] ------------------ 2041| 79| p = 1; 2042| 11.8k| else if(p < 0) ------------------ | Branch (2042:13): [True: 103, False: 11.7k] ------------------ 2043| 103| p = 0; 2044| 11.9k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.subdivide_tukey.parts = parts; 2045| 11.9k| encoder->protected_->apodizations[encoder->protected_->num_apodizations].parameters.subdivide_tukey.p = p/parts; 2046| 11.9k| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_SUBDIVIDE_TUKEY; 2047| 11.9k| } 2048| 12.1k| } 2049| 41.2k| else if(n==5 && 0 == strncmp("welch" , specification, n)) ------------------ | Branch (2049:11): [True: 1.60k, False: 39.6k] | Branch (2049:20): [True: 228, False: 1.37k] ------------------ 2050| 228| encoder->protected_->apodizations[encoder->protected_->num_apodizations++].type = FLAC__APODIZATION_WELCH; 2051| 74.5k| if (encoder->protected_->num_apodizations == 32) ------------------ | Branch (2051:7): [True: 67, False: 74.5k] ------------------ 2052| 67| break; 2053| 74.5k| if (s) ------------------ | Branch (2053:7): [True: 36.9k, False: 37.5k] ------------------ 2054| 36.9k| specification = s+1; 2055| 37.5k| else 2056| 37.5k| break; 2057| 74.5k| } 2058| 37.6k| if(encoder->protected_->num_apodizations == 0) { ------------------ | Branch (2058:5): [True: 11.1k, False: 26.4k] ------------------ 2059| 11.1k| encoder->protected_->num_apodizations = 1; 2060| 11.1k| encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY; 2061| 11.1k| encoder->protected_->apodizations[0].parameters.tukey.p = 0.5; 2062| 11.1k| } 2063| 37.6k|#endif 2064| | return true; 2065| 47.4k|} FLAC__stream_encoder_set_max_lpc_order: 2068| 44.2k|{ 2069| 44.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2070| 44.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2071| 44.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2072| 44.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2072:5): [True: 9.82k, False: 34.4k] ------------------ 2073| 9.82k| return false; 2074| 34.4k| encoder->protected_->max_lpc_order = value; 2075| | return true; 2076| 44.2k|} FLAC__stream_encoder_set_qlp_coeff_precision: 2079| 44.2k|{ 2080| 44.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2081| 44.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2082| 44.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2083| 44.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2083:5): [True: 9.82k, False: 34.4k] ------------------ 2084| 9.82k| return false; 2085| 34.4k| encoder->protected_->qlp_coeff_precision = value; 2086| | return true; 2087| 44.2k|} FLAC__stream_encoder_set_do_qlp_coeff_prec_search: 2090| 44.4k|{ 2091| 44.4k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 44.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.4k] | | ------------------ ------------------ 2092| 44.4k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 44.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.4k] | | ------------------ ------------------ 2093| 44.4k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 44.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.4k] | | ------------------ ------------------ 2094| 44.4k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2094:5): [True: 9.82k, False: 34.6k] ------------------ 2095| 9.82k| return false; 2096| 34.6k| encoder->protected_->do_qlp_coeff_prec_search = value; 2097| | return true; 2098| 44.4k|} FLAC__stream_encoder_set_do_escape_coding: 2101| 44.2k|{ 2102| 44.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2103| 44.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2104| 44.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2105| 44.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2105:5): [True: 9.82k, False: 34.4k] ------------------ 2106| 9.82k| return false; 2107| 34.4k|#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| 34.4k| encoder->protected_->do_escape_coding = value; 2112| |#else 2113| | (void)value; 2114| |#endif 2115| | return true; 2116| 44.2k|} FLAC__stream_encoder_set_do_exhaustive_model_search: 2119| 46.2k|{ 2120| 46.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 46.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 46.2k] | | ------------------ ------------------ 2121| 46.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 46.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 46.2k] | | ------------------ ------------------ 2122| 46.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 46.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 46.2k] | | ------------------ ------------------ 2123| 46.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2123:5): [True: 9.82k, False: 36.4k] ------------------ 2124| 9.82k| return false; 2125| 36.4k| encoder->protected_->do_exhaustive_model_search = value; 2126| | return true; 2127| 46.2k|} FLAC__stream_encoder_set_min_residual_partition_order: 2130| 44.2k|{ 2131| 44.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2132| 44.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2133| 44.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2134| 44.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2134:5): [True: 9.82k, False: 34.4k] ------------------ 2135| 9.82k| return false; 2136| 34.4k| encoder->protected_->min_residual_partition_order = value; 2137| | return true; 2138| 44.2k|} FLAC__stream_encoder_set_max_residual_partition_order: 2141| 44.2k|{ 2142| 44.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2143| 44.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2144| 44.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2145| 44.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2145:5): [True: 9.82k, False: 34.4k] ------------------ 2146| 9.82k| return false; 2147| 34.4k| encoder->protected_->max_residual_partition_order = value; 2148| | return true; 2149| 44.2k|} FLAC__stream_encoder_set_num_threads: 2152| 19.9k|{ 2153| 19.9k|#ifdef FLAC__USE_THREADS 2154| 19.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 2155| 19.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 2156| 19.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 2157| | 2158| 19.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2158:5): [True: 9.82k, False: 10.0k] ------------------ 2159| 9.82k| return FLAC__STREAM_ENCODER_SET_NUM_THREADS_ALREADY_INITIALIZED; ------------------ | | 293| 9.82k|#define FLAC__STREAM_ENCODER_SET_NUM_THREADS_ALREADY_INITIALIZED 2 ------------------ 2160| 10.0k| if(value > FLAC__STREAM_ENCODER_MAX_THREADS) ------------------ | | 46| 10.0k|#define FLAC__STREAM_ENCODER_MAX_THREADS 16 ------------------ | Branch (2160:5): [True: 8.99k, False: 1.10k] ------------------ 2161| 8.99k| return FLAC__STREAM_ENCODER_SET_NUM_THREADS_TOO_MANY_THREADS; ------------------ | | 294| 8.99k|#define FLAC__STREAM_ENCODER_SET_NUM_THREADS_TOO_MANY_THREADS 3 ------------------ 2162| 1.10k| if(value == 0) ------------------ | Branch (2162:5): [True: 285, False: 822] ------------------ 2163| 285| encoder->protected_->num_threads = 1; 2164| 822| else 2165| 822| encoder->protected_->num_threads = value; 2166| 1.10k| return FLAC__STREAM_ENCODER_SET_NUM_THREADS_OK; ------------------ | | 291| 1.10k|#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| 10.0k|} FLAC__stream_encoder_set_rice_parameter_search_dist: 2175| 44.2k|{ 2176| 44.2k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2177| 44.2k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2178| 44.2k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 2179| 44.2k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2179:5): [True: 9.82k, False: 34.4k] ------------------ 2180| 9.82k| return false; 2181| |#if 0 2182| | /*@@@ deprecated: */ 2183| | encoder->protected_->rice_parameter_search_dist = value; 2184| |#else 2185| 34.4k| (void)value; 2186| 34.4k|#endif 2187| | return true; 2188| 44.2k|} FLAC__stream_encoder_set_total_samples_estimate: 2191| 20.0k|{ 2192| 20.0k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 20.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.0k] | | ------------------ ------------------ 2193| 20.0k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 20.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.0k] | | ------------------ ------------------ 2194| 20.0k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 20.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 20.0k] | | ------------------ ------------------ 2195| 20.0k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2195:5): [True: 9.82k, False: 10.1k] ------------------ 2196| 9.82k| return false; 2197| 10.1k| value = flac_min(value, (FLAC__U64L(1) << FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN) - 1); ------------------ | | 56| 10.1k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (2197:10): [True: 607, False: 9.59k] ------------------ 2198| 10.1k| encoder->protected_->total_samples_estimate = value; 2199| | return true; 2200| 20.0k|} FLAC__stream_encoder_set_limit_min_bitrate: 2235| 19.9k|{ 2236| 19.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 2237| 19.9k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 2238| 19.9k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 19.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.9k] | | ------------------ ------------------ 2239| 19.9k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (2239:5): [True: 9.82k, False: 10.1k] ------------------ 2240| 9.82k| return false; 2241| 10.1k| encoder->protected_->limit_min_bitrate = value; 2242| | return true; 2243| 19.9k|} FLAC__stream_encoder_get_verify_decoder_state: 2308| 225k|{ 2309| 225k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 225k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 225k] | | ------------------ ------------------ 2310| 225k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 225k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 225k] | | ------------------ ------------------ 2311| 225k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 225k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 225k] | | ------------------ ------------------ 2312| 225k| if(encoder->protected_->verify) ------------------ | Branch (2312:5): [True: 225k, False: 0] ------------------ 2313| 225k| if(encoder->private_->verify.decoder == NULL) ------------------ | Branch (2313:6): [True: 0, False: 225k] ------------------ 2314| 0| return FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; 2315| 225k| else 2316| 225k| return FLAC__stream_decoder_get_state(encoder->private_->verify.decoder); 2317| 0| else 2318| 0| return FLAC__STREAM_DECODER_UNINITIALIZED; 2319| 225k|} FLAC__stream_encoder_get_verify: 2354| 9.82k|{ 2355| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2356| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2357| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2358| 9.82k| return encoder->protected_->verify; 2359| 9.82k|} FLAC__stream_encoder_get_streamable_subset: 2362| 9.82k|{ 2363| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2364| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2365| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2366| 9.82k| return encoder->protected_->streamable_subset; 2367| 9.82k|} FLAC__stream_encoder_get_channels: 2378| 9.82k|{ 2379| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2380| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2381| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2382| 9.82k| return encoder->protected_->channels; 2383| 9.82k|} FLAC__stream_encoder_get_bits_per_sample: 2386| 429k|{ 2387| 429k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 429k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 429k] | | ------------------ ------------------ 2388| 429k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 429k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 429k] | | ------------------ ------------------ 2389| 429k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 429k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 429k] | | ------------------ ------------------ 2390| 429k| return encoder->protected_->bits_per_sample; 2391| 429k|} FLAC__stream_encoder_get_sample_rate: 2394| 9.82k|{ 2395| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2396| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2397| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2398| 9.82k| return encoder->protected_->sample_rate; 2399| 9.82k|} FLAC__stream_encoder_get_blocksize: 2402| 9.82k|{ 2403| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2404| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2405| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2406| 9.82k| return encoder->protected_->blocksize; 2407| 9.82k|} FLAC__stream_encoder_get_do_mid_side_stereo: 2410| 9.82k|{ 2411| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2412| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2413| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2414| 9.82k| return encoder->protected_->do_mid_side_stereo; 2415| 9.82k|} FLAC__stream_encoder_get_loose_mid_side_stereo: 2418| 9.82k|{ 2419| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2420| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2421| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2422| 9.82k| return encoder->protected_->loose_mid_side_stereo; 2423| 9.82k|} FLAC__stream_encoder_get_max_lpc_order: 2426| 9.82k|{ 2427| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2428| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2429| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2430| 9.82k| return encoder->protected_->max_lpc_order; 2431| 9.82k|} FLAC__stream_encoder_get_qlp_coeff_precision: 2434| 9.82k|{ 2435| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2436| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2437| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2438| 9.82k| return encoder->protected_->qlp_coeff_precision; 2439| 9.82k|} FLAC__stream_encoder_get_do_qlp_coeff_prec_search: 2442| 9.82k|{ 2443| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2444| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2445| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2446| 9.82k| return encoder->protected_->do_qlp_coeff_prec_search; 2447| 9.82k|} FLAC__stream_encoder_get_do_escape_coding: 2450| 9.82k|{ 2451| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2452| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2453| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2454| 9.82k| return encoder->protected_->do_escape_coding; 2455| 9.82k|} FLAC__stream_encoder_get_do_exhaustive_model_search: 2458| 9.82k|{ 2459| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2460| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2461| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2462| 9.82k| return encoder->protected_->do_exhaustive_model_search; 2463| 9.82k|} FLAC__stream_encoder_get_min_residual_partition_order: 2466| 9.82k|{ 2467| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2468| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2469| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2470| 9.82k| return encoder->protected_->min_residual_partition_order; 2471| 9.82k|} FLAC__stream_encoder_get_num_threads: 2474| 9.82k|{ 2475| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2476| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2477| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2478| 9.82k| return encoder->protected_->num_threads; 2479| 9.82k|} FLAC__stream_encoder_get_max_residual_partition_order: 2482| 9.82k|{ 2483| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2484| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2485| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2486| 9.82k| return encoder->protected_->max_residual_partition_order; 2487| 9.82k|} FLAC__stream_encoder_get_rice_parameter_search_dist: 2490| 9.82k|{ 2491| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2492| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2493| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2494| 9.82k| return encoder->protected_->rice_parameter_search_dist; 2495| 9.82k|} FLAC__stream_encoder_get_total_samples_estimate: 2498| 9.82k|{ 2499| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2500| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2501| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2502| 9.82k| return encoder->protected_->total_samples_estimate; 2503| 9.82k|} FLAC__stream_encoder_get_limit_min_bitrate: 2506| 9.82k|{ 2507| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2508| 9.82k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2509| 9.82k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2510| 9.82k| return encoder->protected_->limit_min_bitrate; 2511| 9.82k|} FLAC__stream_encoder_process_interleaved: 2571| 152k|{ 2572| 152k| uint32_t i, j, k, channel; 2573| 152k| uint32_t channels; 2574| 152k| uint32_t blocksize; 2575| 152k| FLAC__int32 sample_max; 2576| 152k| FLAC__int32 sample_min; 2577| | 2578| 152k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 152k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 152k] | | ------------------ ------------------ 2579| 152k| FLAC__ASSERT(0 != encoder->private_); ------------------ | | 38| 152k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 152k] | | ------------------ ------------------ 2580| 152k| FLAC__ASSERT(0 != encoder->protected_); ------------------ | | 38| 152k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 152k] | | ------------------ ------------------ 2581| | 2582| 152k| channels = encoder->protected_->channels; 2583| 152k| blocksize = encoder->protected_->blocksize; 2584| 152k| sample_max = INT32_MAX >> (32 - encoder->protected_->bits_per_sample); 2585| 152k| sample_min = INT32_MIN >> (32 - encoder->protected_->bits_per_sample); 2586| | 2587| 152k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_OK) ------------------ | Branch (2587:5): [True: 1.50k, False: 151k] ------------------ 2588| 1.50k| return false; 2589| | 2590| 151k| j = k = 0; 2591| 407k| do { 2592| 407k| if(encoder->protected_->verify) ------------------ | Branch (2592:6): [True: 351k, False: 55.1k] ------------------ 2593| 351k| 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| 351k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (2593:99): [True: 205k, False: 146k] ------------------ 2594| | 2595| | /* "i <= blocksize" to overread 1 sample; see comment in OVERREAD_ decl */ 2596| 23.7M| for(i = encoder->private_->current_sample_number; i <= blocksize && j < samples; i++, j++) { ------------------ | Branch (2596:53): [True: 23.5M, False: 258k] | Branch (2596:71): [True: 23.3M, False: 148k] ------------------ 2597| 52.7M| for(channel = 0; channel < channels; channel++){ ------------------ | Branch (2597:21): [True: 29.3M, False: 23.3M] ------------------ 2598| 29.3M| if(buffer[k] < sample_min || buffer[k] > sample_max){ ------------------ | Branch (2598:8): [True: 1, False: 29.3M] | Branch (2598:34): [True: 64, False: 29.3M] ------------------ 2599| 65| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 2600| 65| return false; 2601| 65| } 2602| 29.3M| encoder->private_->threadtask[0]->integer_signal[channel][i] = buffer[k++]; 2603| 29.3M| } 2604| 23.3M| } 2605| 407k| 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| 407k| if(i > blocksize) { ------------------ | Branch (2607:6): [True: 258k, False: 148k] ------------------ 2608| 258k| if(!process_frame_(encoder, /*is_last_block=*/false)) ------------------ | Branch (2608:7): [True: 0, False: 258k] ------------------ 2609| 0| return false; 2610| | /* move unprocessed overread samples to beginnings of arrays */ 2611| 258k| FLAC__ASSERT(i == blocksize+OVERREAD_); ------------------ | | 38| 258k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 258k] | | ------------------ ------------------ 2612| 258k| FLAC__ASSERT(OVERREAD_ == 1); /* assert we only overread 1 sample which simplifies the rest of the code below */ ------------------ | | 38| 258k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 258k] | | ------------------ ------------------ 2613| 581k| for(channel = 0; channel < channels; channel++) ------------------ | Branch (2613:21): [True: 322k, False: 258k] ------------------ 2614| 322k| encoder->private_->threadtask[0]->integer_signal[channel][0] = encoder->private_->threadtask[0]->integer_signal[channel][blocksize]; 2615| 258k| encoder->private_->current_sample_number = 1; 2616| 258k| } 2617| 407k| } while(j < samples); ------------------ | Branch (2617:10): [True: 256k, False: 150k] ------------------ 2618| | 2619| 150k| return true; 2620| 151k|} process_frame_thread_: 3627| 2.85k|FLAC__thread_return_type process_frame_thread_(void * args) { 3628| 2.85k| FLAC__StreamEncoder * encoder = args; 3629| 2.85k| uint32_t channel; 3630| | 3631| 2.85k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 2.85k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3632| 2.85k| encoder->private_->num_running_threads++; 3633| 2.85k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 2.85k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3634| | 3635| 164k| while(1) { ------------------ | Branch (3635:8): [True: 164k, Folded] ------------------ 3636| 164k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 164k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3637| 164k| if(encoder->private_->finish_work_threads) { ------------------ | Branch (3637:6): [True: 86, False: 163k] ------------------ 3638| 86| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 86|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3639| 86| return FLAC__thread_default_return_value; ------------------ | | 117| 86|#define FLAC__thread_default_return_value NULL ------------------ 3640| 86| } 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| 163k| if(encoder->private_->num_available_threadtasks == 0) ------------------ | Branch (3645:6): [True: 32.3k, False: 131k] ------------------ 3646| 32.3k| encoder->private_->overcommitted_indicator++; 3647| 131k| else if(encoder->private_->num_available_threadtasks > encoder->private_->num_running_threads) ------------------ | Branch (3647:11): [True: 49.0k, False: 82.5k] ------------------ 3648| 49.0k| encoder->private_->overcommitted_indicator--; 3649| 163k| if(encoder->private_->overcommitted_indicator < -20) { ------------------ | Branch (3649:6): [True: 1.47k, False: 162k] ------------------ 3650| 1.47k| encoder->private_->overcommitted_indicator = 0; 3651| 1.47k| FLAC__cnd_signal(&encoder->private_->cond_wake_up_thread); ------------------ | | 112| 1.47k|#define FLAC__cnd_signal(cv) pthread_cond_signal(cv) ------------------ 3652| 1.47k| } 3653| 162k| else if(encoder->private_->overcommitted_indicator > 20 && encoder->private_->num_running_threads > 2) { ------------------ | Branch (3653:11): [True: 1.06k, False: 161k] | Branch (3653:62): [True: 644, False: 419] ------------------ 3654| 644| encoder->private_->overcommitted_indicator = 0; 3655| 644| encoder->private_->num_running_threads--; 3656| 644| FLAC__cnd_wait(&encoder->private_->cond_wake_up_thread, &encoder->private_->mutex_work_queue); ------------------ | | 113| 644|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 3657| 644| encoder->private_->num_running_threads++; 3658| 644| } 3659| 204k| while(encoder->private_->num_available_threadtasks == 0 && (encoder->private_->md5_active || encoder->private_->md5_fifo.tail == 0)) { ------------------ | Branch (3659:9): [True: 46.8k, False: 158k] | Branch (3659:63): [True: 14.4k, False: 32.4k] | Branch (3659:96): [True: 29.3k, False: 3.13k] ------------------ 3660| 43.7k| if(encoder->private_->finish_work_threads) { ------------------ | Branch (3660:7): [True: 2.77k, False: 40.9k] ------------------ 3661| 2.77k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 2.77k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3662| 2.77k| return FLAC__thread_default_return_value; ------------------ | | 117| 2.77k|#define FLAC__thread_default_return_value NULL ------------------ 3663| 2.77k| } 3664| 40.9k| FLAC__cnd_wait(&encoder->private_->cond_work_available, &encoder->private_->mutex_work_queue); ------------------ | | 113| 40.9k|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 3665| 40.9k| } 3666| 161k| if(encoder->protected_->do_md5 && !encoder->private_->md5_active && encoder->private_->md5_fifo.tail > 0) { ------------------ | Branch (3666:6): [True: 161k, False: 18.4E] | Branch (3666:37): [True: 124k, False: 36.6k] | Branch (3666:71): [True: 48.1k, False: 76.5k] ------------------ 3667| 48.1k| uint32_t length = 0; 3668| 48.1k| encoder->private_->md5_active = true; 3669| 110k| while(encoder->private_->md5_fifo.tail > 0) { ------------------ | Branch (3669:10): [True: 62.5k, False: 48.1k] ------------------ 3670| 62.5k| length = encoder->private_->md5_fifo.tail; 3671| 62.5k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 62.5k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3672| 62.5k| 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: 62.5k] ------------------ 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| 62.5k| FLAC__mtx_lock(&encoder->private_->mutex_md5_fifo); ------------------ | | 105| 62.5k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3677| 127k| for(channel = 0; channel < encoder->protected_->channels; channel++) ------------------ | Branch (3677:22): [True: 64.4k, False: 62.5k] ------------------ 3678| 64.4k| 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| 62.5k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 62.5k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3680| 62.5k| encoder->private_->md5_fifo.tail -= length; 3681| 62.5k| FLAC__cnd_signal(&encoder->private_->cond_md5_emptied); ------------------ | | 112| 62.5k|#define FLAC__cnd_signal(cv) pthread_cond_signal(cv) ------------------ 3682| 62.5k| FLAC__mtx_unlock(&encoder->private_->mutex_md5_fifo); ------------------ | | 106| 62.5k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3683| 62.5k| } 3684| 48.1k| encoder->private_->md5_active = false; 3685| 48.1k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 48.1k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3686| 48.1k| } 3687| 113k| else if(encoder->private_->num_available_threadtasks > 0) { ------------------ | Branch (3687:11): [True: 113k, False: 18.4E] ------------------ 3688| 113k| FLAC__StreamEncoderThreadTask * task = NULL; 3689| 113k| task = encoder->private_->threadtask[encoder->private_->next_threadtask]; 3690| 113k| encoder->private_->num_available_threadtasks--; 3691| 113k| encoder->private_->next_threadtask++; 3692| 113k| if(encoder->private_->next_threadtask == encoder->private_->num_threadtasks) ------------------ | Branch (3692:7): [True: 12.0k, False: 101k] ------------------ 3693| 12.0k| encoder->private_->next_threadtask = 1; 3694| 113k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 113k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3695| 113k| FLAC__mtx_lock(&task->mutex_this_task); ------------------ | | 105| 113k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3696| 113k| if(!process_frame_thread_inner_(encoder, task)) ------------------ | Branch (3696:7): [True: 0, False: 113k] ------------------ 3697| 0| return FLAC__thread_default_return_value; ------------------ | | 117| 0|#define FLAC__thread_default_return_value NULL ------------------ 3698| 113k| } 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| 161k| } 3703| 2.85k|} process_frame_thread_inner_: 3705| 128k|FLAC__bool process_frame_thread_inner_(FLAC__StreamEncoder * encoder, FLAC__StreamEncoderThreadTask * task) { 3706| 128k| FLAC__bool ok = true; 3707| 128k| FLAC__uint16 crc; 3708| | 3709| | /* 3710| | * Process the frame header and subframes into the frame bitbuffer 3711| | */ 3712| 128k| if(ok && !process_subframes_(encoder, task)) { ------------------ | Branch (3712:5): [True: 128k, False: 15] | Branch (3712:11): [True: 0, False: 128k] ------------------ 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| 128k| if(ok && !FLAC__bitwriter_zero_pad_to_byte_boundary(task->frame)) { ------------------ | Branch (3720:5): [True: 128k, False: 448] | Branch (3720:11): [True: 0, False: 128k] ------------------ 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| 128k| FLAC__ASSERT(!ok || FLAC__bitwriter_is_byte_aligned(task->frame)); ------------------ | | 38| 256k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 612, False: 127k] | | | Branch (38:30): [True: 127k, False: 0] | | ------------------ ------------------ 3729| 128k| if( 3730| 128k| ok && ------------------ | Branch (3730:3): [True: 127k, False: 593] ------------------ 3731| 127k| ( 3732| 127k| !FLAC__bitwriter_get_write_crc16(task->frame, &crc) || ------------------ | Branch (3732:4): [True: 31, False: 127k] ------------------ 3733| 127k| !FLAC__bitwriter_write_raw_uint32(task->frame, crc, FLAC__FRAME_FOOTER_CRC_LEN) ------------------ | Branch (3733:4): [True: 85, False: 127k] ------------------ 3734| 127k| ) 3735| 128k| ) { 3736| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 3737| 0| ok = false; 3738| 0| } 3739| 128k| task->returnvalue = ok; 3740| 128k| task->task_done = true; 3741| 128k| FLAC__cnd_signal(&task->cond_task_done); ------------------ | | 112| 128k|#define FLAC__cnd_signal(cv) pthread_cond_signal(cv) ------------------ 3742| 128k| FLAC__mtx_unlock(&task->mutex_this_task); ------------------ | | 106| 128k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3743| | return true; 3744| 128k|} stream_encoder.c:init_stream_internal_: 717| 10.0k|{ 718| 10.0k| uint32_t i, t; 719| 10.0k| FLAC__bool metadata_has_seektable, metadata_has_vorbis_comment, metadata_picture_has_type1, metadata_picture_has_type2; 720| | 721| 10.0k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 10.0k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 10.0k] | | ------------------ ------------------ 722| | 723| 10.0k| if(encoder->protected_->state != FLAC__STREAM_ENCODER_UNINITIALIZED) ------------------ | Branch (723:5): [True: 0, False: 10.0k] ------------------ 724| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ALREADY_INITIALIZED; 725| | 726| 10.0k| if(FLAC__HAS_OGG == 0 && is_ogg) ------------------ | | 45| 10.0k|#define FLAC__HAS_OGG 1 ------------------ | Branch (726:5): [Folded, False: 10.0k] | Branch (726:27): [True: 0, False: 0] ------------------ 727| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_UNSUPPORTED_CONTAINER; 728| | 729| 10.0k| if(0 == write_callback || (seek_callback && 0 == tell_callback)) ------------------ | Branch (729:5): [True: 0, False: 10.0k] | Branch (729:29): [True: 10.0k, False: 0] | Branch (729:46): [True: 0, False: 10.0k] ------------------ 730| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_CALLBACKS; 731| | 732| 10.0k| if(encoder->protected_->channels == 0 || encoder->protected_->channels > FLAC__MAX_CHANNELS) ------------------ | | 106| 10.0k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (732:5): [True: 4, False: 10.0k] | Branch (732:43): [True: 10, False: 10.0k] ------------------ 733| 14| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_NUMBER_OF_CHANNELS; 734| | 735| 10.0k| if(encoder->protected_->channels != 2) { ------------------ | Branch (735:5): [True: 6.84k, False: 3.19k] ------------------ 736| 6.84k| encoder->protected_->do_mid_side_stereo = false; 737| 6.84k| encoder->protected_->loose_mid_side_stereo = false; 738| 6.84k| } 739| 3.19k| else if(!encoder->protected_->do_mid_side_stereo) ------------------ | Branch (739:10): [True: 96, False: 3.09k] ------------------ 740| 96| encoder->protected_->loose_mid_side_stereo = false; 741| | 742| 10.0k| if(encoder->protected_->bits_per_sample < FLAC__MIN_BITS_PER_SAMPLE || encoder->protected_->bits_per_sample > FLAC__MAX_BITS_PER_SAMPLE) ------------------ | | 109| 20.0k|#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| 10.0k|#define FLAC__MAX_BITS_PER_SAMPLE (32u) ------------------ | Branch (742:5): [True: 3, False: 10.0k] | Branch (742:73): [True: 5, False: 10.0k] ------------------ 743| 8| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE; 744| | 745| 10.0k| if(!FLAC__format_sample_rate_is_valid(encoder->protected_->sample_rate)) ------------------ | Branch (745:5): [True: 18, False: 10.0k] ------------------ 746| 18| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE; 747| | 748| 10.0k| if(encoder->protected_->blocksize == 0) { ------------------ | Branch (748:5): [True: 705, False: 9.30k] ------------------ 749| 705| if(encoder->protected_->max_lpc_order == 0) ------------------ | Branch (749:6): [True: 132, False: 573] ------------------ 750| 132| encoder->protected_->blocksize = 1152; 751| 573| else 752| 573| encoder->protected_->blocksize = 4096; 753| 705| } 754| | 755| 10.0k| if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE) ------------------ | | 96| 20.0k|#define FLAC__MIN_BLOCK_SIZE (16u) ------------------ if(encoder->protected_->blocksize < FLAC__MIN_BLOCK_SIZE || encoder->protected_->blocksize > FLAC__MAX_BLOCK_SIZE) ------------------ | | 99| 10.0k|#define FLAC__MAX_BLOCK_SIZE (65535u) ------------------ | Branch (755:5): [True: 3, False: 10.0k] | Branch (755:62): [True: 0, False: 10.0k] ------------------ 756| 3| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BLOCK_SIZE; 757| | 758| 10.0k| if(encoder->protected_->max_lpc_order > FLAC__MAX_LPC_ORDER) ------------------ | | 128| 10.0k|#define FLAC__MAX_LPC_ORDER (32u) ------------------ | Branch (758:5): [True: 2, False: 10.0k] ------------------ 759| 2| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_MAX_LPC_ORDER; 760| | 761| 10.0k| if(encoder->protected_->blocksize < encoder->protected_->max_lpc_order) ------------------ | Branch (761:5): [True: 1, False: 10.0k] ------------------ 762| 1| return FLAC__STREAM_ENCODER_INIT_STATUS_BLOCK_SIZE_TOO_SMALL_FOR_LPC_ORDER; 763| | 764| 10.0k| if(encoder->protected_->qlp_coeff_precision == 0) { ------------------ | Branch (764:5): [True: 7.41k, False: 2.59k] ------------------ 765| 7.41k| if(encoder->protected_->bits_per_sample < 16) { ------------------ | Branch (765:6): [True: 633, False: 6.78k] ------------------ 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| 633| encoder->protected_->qlp_coeff_precision = flac_max(FLAC__MIN_QLP_COEFF_PRECISION, 2 + encoder->protected_->bits_per_sample / 2); ------------------ | | 55| 633|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (768:47): [True: 174, False: 459] ------------------ 769| 633| } 770| 6.78k| else if(encoder->protected_->bits_per_sample == 16) { ------------------ | Branch (770:11): [True: 544, False: 6.23k] ------------------ 771| 544| if(encoder->protected_->blocksize <= 192) ------------------ | Branch (771:7): [True: 217, False: 327] ------------------ 772| 217| encoder->protected_->qlp_coeff_precision = 7; 773| 327| else if(encoder->protected_->blocksize <= 384) ------------------ | Branch (773:12): [True: 28, False: 299] ------------------ 774| 28| encoder->protected_->qlp_coeff_precision = 8; 775| 299| else if(encoder->protected_->blocksize <= 576) ------------------ | Branch (775:12): [True: 18, False: 281] ------------------ 776| 18| encoder->protected_->qlp_coeff_precision = 9; 777| 281| else if(encoder->protected_->blocksize <= 1152) ------------------ | Branch (777:12): [True: 32, False: 249] ------------------ 778| 32| encoder->protected_->qlp_coeff_precision = 10; 779| 249| else if(encoder->protected_->blocksize <= 2304) ------------------ | Branch (779:12): [True: 22, False: 227] ------------------ 780| 22| encoder->protected_->qlp_coeff_precision = 11; 781| 227| else if(encoder->protected_->blocksize <= 4608) ------------------ | Branch (781:12): [True: 57, False: 170] ------------------ 782| 57| encoder->protected_->qlp_coeff_precision = 12; 783| 170| else 784| 170| encoder->protected_->qlp_coeff_precision = 13; 785| 544| } 786| 6.23k| else { 787| 6.23k| if(encoder->protected_->blocksize <= 384) ------------------ | Branch (787:7): [True: 2.23k, False: 4.00k] ------------------ 788| 2.23k| encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-2; ------------------ | | 142| 2.23k|#define FLAC__MAX_QLP_COEFF_PRECISION (15u) ------------------ 789| 4.00k| else if(encoder->protected_->blocksize <= 1152) ------------------ | Branch (789:12): [True: 289, False: 3.71k] ------------------ 790| 289| encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION-1; ------------------ | | 142| 289|#define FLAC__MAX_QLP_COEFF_PRECISION (15u) ------------------ 791| 3.71k| else 792| 3.71k| encoder->protected_->qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION; ------------------ | | 142| 3.71k|#define FLAC__MAX_QLP_COEFF_PRECISION (15u) ------------------ 793| 6.23k| } 794| 7.41k| FLAC__ASSERT(encoder->protected_->qlp_coeff_precision <= FLAC__MAX_QLP_COEFF_PRECISION); ------------------ | | 38| 7.41k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 7.41k] | | ------------------ ------------------ 795| 7.41k| } 796| 2.59k| else if(encoder->protected_->qlp_coeff_precision < FLAC__MIN_QLP_COEFF_PRECISION || encoder->protected_->qlp_coeff_precision > FLAC__MAX_QLP_COEFF_PRECISION) ------------------ | | 137| 5.18k|#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.59k|#define FLAC__MAX_QLP_COEFF_PRECISION (15u) ------------------ | Branch (796:10): [True: 1, False: 2.59k] | Branch (796:86): [True: 48, False: 2.54k] ------------------ 797| 49| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_QLP_COEFF_PRECISION; 798| | 799| 9.95k| if(encoder->protected_->streamable_subset) { ------------------ | Branch (799:5): [True: 649, False: 9.30k] ------------------ 800| 649| if(!FLAC__format_blocksize_is_subset(encoder->protected_->blocksize, encoder->protected_->sample_rate)) ------------------ | Branch (800:6): [True: 17, False: 632] ------------------ 801| 17| return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 802| 632| if(!FLAC__format_sample_rate_is_subset(encoder->protected_->sample_rate)) ------------------ | Branch (802:6): [True: 45, False: 587] ------------------ 803| 45| return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 804| 587| if( 805| 587| encoder->protected_->bits_per_sample != 8 && ------------------ | Branch (805:4): [True: 545, False: 42] ------------------ 806| 545| encoder->protected_->bits_per_sample != 12 && ------------------ | Branch (806:4): [True: 532, False: 13] ------------------ 807| 532| encoder->protected_->bits_per_sample != 16 && ------------------ | Branch (807:4): [True: 435, False: 97] ------------------ 808| 435| encoder->protected_->bits_per_sample != 20 && ------------------ | Branch (808:4): [True: 432, False: 3] ------------------ 809| 432| encoder->protected_->bits_per_sample != 24 && ------------------ | Branch (809:4): [True: 397, False: 35] ------------------ 810| 397| encoder->protected_->bits_per_sample != 32 ------------------ | Branch (810:4): [True: 14, False: 383] ------------------ 811| 587| ) 812| 14| return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 813| 573| if(encoder->protected_->max_residual_partition_order > FLAC__SUBSET_MAX_RICE_PARTITION_ORDER) ------------------ | | 151| 573|#define FLAC__SUBSET_MAX_RICE_PARTITION_ORDER (8u) ------------------ | Branch (813:6): [True: 46, False: 527] ------------------ 814| 46| return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 815| 527| if( 816| 527| encoder->protected_->sample_rate <= 48000 && ------------------ | Branch (816:4): [True: 215, False: 312] ------------------ 817| 215| ( 818| 215| encoder->protected_->blocksize > FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ || ------------------ | | 103| 430|#define FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ (4608u) ------------------ | Branch (818:5): [True: 0, False: 215] ------------------ 819| 215| encoder->protected_->max_lpc_order > FLAC__SUBSET_MAX_LPC_ORDER_48000HZ ------------------ | | 132| 215|#define FLAC__SUBSET_MAX_LPC_ORDER_48000HZ (12u) ------------------ | Branch (819:5): [True: 8, False: 207] ------------------ 820| 215| ) 821| 527| ) { 822| 8| return FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE; 823| 8| } 824| 527| } 825| | 826| 9.82k| if(encoder->protected_->max_residual_partition_order >= (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN)) ------------------ | Branch (826:5): [True: 7.23k, False: 2.58k] ------------------ 827| 7.23k| encoder->protected_->max_residual_partition_order = (1u << FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN) - 1; 828| 9.82k| if(encoder->protected_->min_residual_partition_order >= encoder->protected_->max_residual_partition_order) ------------------ | Branch (828:5): [True: 9.05k, False: 774] ------------------ 829| 9.05k| encoder->protected_->min_residual_partition_order = encoder->protected_->max_residual_partition_order; 830| | 831| 9.82k|#if FLAC__HAS_OGG 832| | /* drop any seektable for ogg */ 833| 9.82k| if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) { ------------------ | Branch (833:5): [True: 3.09k, False: 6.72k] | Branch (833:15): [True: 0, False: 3.09k] | 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.82k| if(is_ogg && 0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 1) { ------------------ | Branch (845:5): [True: 3.09k, False: 6.72k] | Branch (845:15): [True: 0, False: 3.09k] | 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.82k|#endif 858| | /* keep track of any SEEKTABLE block */ 859| 9.82k| if(0 != encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) { ------------------ | Branch (859:5): [True: 0, False: 9.82k] | 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.82k| if(0 == encoder->protected_->metadata && encoder->protected_->num_metadata_blocks > 0) ------------------ | Branch (870:5): [True: 9.82k, False: 0] | Branch (870:43): [True: 0, False: 9.82k] ------------------ 871| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA; 872| 9.82k| metadata_has_seektable = false; 873| 9.82k| metadata_has_vorbis_comment = false; 874| 9.82k| metadata_picture_has_type1 = false; 875| 9.82k| metadata_picture_has_type2 = false; 876| 9.82k| for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) { ------------------ | Branch (876:13): [True: 0, False: 9.82k] ------------------ 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.82k| encoder->private_->input_capacity = 0; 923| 9.82k| encoder->private_->current_sample_number = 0; 924| 9.82k| encoder->private_->current_frame_number = 0; 925| | 926| | /* 927| | * get the CPU info and set the function pointers 928| | */ 929| 9.82k| FLAC__cpu_info(&encoder->private_->cpuinfo); 930| | /* remove cpu info as requested by 931| | * FLAC__stream_encoder_disable_instruction_set */ 932| 9.82k| if(encoder->private_->disable_mmx) ------------------ | Branch (932:5): [True: 0, False: 9.82k] ------------------ 933| 0| encoder->private_->cpuinfo.x86.mmx = false; 934| 9.82k| if(encoder->private_->disable_sse2) ------------------ | Branch (934:5): [True: 0, False: 9.82k] ------------------ 935| 0| encoder->private_->cpuinfo.x86.sse2 = false; 936| 9.82k| if(encoder->private_->disable_ssse3) ------------------ | Branch (936:5): [True: 0, False: 9.82k] ------------------ 937| 0| encoder->private_->cpuinfo.x86.ssse3 = false; 938| 9.82k| if(encoder->private_->disable_sse41) ------------------ | Branch (938:5): [True: 0, False: 9.82k] ------------------ 939| 0| encoder->private_->cpuinfo.x86.sse41 = false; 940| 9.82k| if(encoder->private_->disable_sse42) ------------------ | Branch (940:5): [True: 0, False: 9.82k] ------------------ 941| 0| encoder->private_->cpuinfo.x86.sse42 = false; 942| 9.82k| if(encoder->private_->disable_avx2) ------------------ | Branch (942:5): [True: 0, False: 9.82k] ------------------ 943| 0| encoder->private_->cpuinfo.x86.avx2 = false; 944| 9.82k| if(encoder->private_->disable_fma) ------------------ | Branch (944:5): [True: 0, False: 9.82k] ------------------ 945| 0| encoder->private_->cpuinfo.x86.fma = false; 946| | /* first default to the non-asm routines */ 947| 9.82k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 948| 9.82k| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation; 949| 9.82k|#endif 950| 9.82k| encoder->private_->local_precompute_partition_info_sums = precompute_partition_info_sums_; 951| 9.82k| encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor; 952| 9.82k| encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide; 953| 9.82k| encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual; 954| 9.82k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 955| 9.82k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients; 956| 9.82k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide; 957| 9.82k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients; 958| 9.82k|#endif 959| | /* now override with asm where appropriate */ 960| 9.82k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 961| 9.82k|# 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.82k| if(encoder->private_->cpuinfo.use_asm) { ------------------ | Branch (978:5): [True: 9.82k, 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.82k| FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_X86_64); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 1033| 9.82k|# if FLAC__HAS_X86INTRIN 1034| 9.82k|# ifdef FLAC__SSE2_SUPPORTED 1035| 9.82k| if(encoder->private_->cpuinfo.x86.sse2) { /* For fuzzing */ ------------------ | Branch (1035:6): [True: 9.82k, False: 0] ------------------ 1036| 9.82k| if(encoder->protected_->max_lpc_order < 8) ------------------ | Branch (1036:7): [True: 2.59k, False: 7.22k] ------------------ 1037| 2.59k| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_8; 1038| 7.22k| else if(encoder->protected_->max_lpc_order < 10) ------------------ | Branch (1038:12): [True: 447, False: 6.78k] ------------------ 1039| 447| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_10; 1040| 6.78k| else if(encoder->protected_->max_lpc_order < 14) ------------------ | Branch (1040:12): [True: 255, False: 6.52k] ------------------ 1041| 255| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_sse2_lag_14; 1042| | 1043| 9.82k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_sse2; 1044| 9.82k| } 1045| 9.82k|# endif 1046| 9.82k|# ifdef FLAC__SSE4_1_SUPPORTED 1047| 9.82k| if(encoder->private_->cpuinfo.x86.sse41) { ------------------ | Branch (1047:6): [True: 9.82k, False: 0] ------------------ 1048| 9.82k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_sse41; 1049| 9.82k| } 1050| 9.82k|# endif 1051| 9.82k|# ifdef FLAC__AVX2_SUPPORTED 1052| 9.82k| if(encoder->private_->cpuinfo.x86.avx2) { ------------------ | Branch (1052:6): [True: 9.82k, False: 0] ------------------ 1053| 9.82k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit = FLAC__lpc_compute_residual_from_qlp_coefficients_16_intrin_avx2; 1054| 9.82k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients = FLAC__lpc_compute_residual_from_qlp_coefficients_intrin_avx2; 1055| 9.82k| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit = FLAC__lpc_compute_residual_from_qlp_coefficients_wide_intrin_avx2; 1056| 9.82k| } 1057| 9.82k|# endif 1058| 9.82k|# ifdef FLAC__FMA_SUPPORTED 1059| 9.82k| if(encoder->private_->cpuinfo.x86.fma) { ------------------ | Branch (1059:6): [True: 9.82k, False: 0] ------------------ 1060| 9.82k| if(encoder->protected_->max_lpc_order < 8) ------------------ | Branch (1060:7): [True: 2.59k, False: 7.22k] ------------------ 1061| 2.59k| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_fma_lag_8; 1062| 7.22k| else if(encoder->protected_->max_lpc_order < 12) ------------------ | Branch (1062:12): [True: 552, False: 6.67k] ------------------ 1063| 552| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_fma_lag_12; 1064| 6.67k| else if(encoder->protected_->max_lpc_order < 16) ------------------ | Branch (1064:12): [True: 1.98k, False: 4.69k] ------------------ 1065| 1.98k| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation_intrin_fma_lag_16; 1066| 9.82k| } 1067| 9.82k|# endif 1068| | 1069| | 1070| 9.82k|# ifdef FLAC__SSE2_SUPPORTED 1071| 9.82k| if(encoder->private_->cpuinfo.x86.sse2) { /* For fuzzing */ ------------------ | Branch (1071:6): [True: 9.82k, False: 0] ------------------ 1072| 9.82k| encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_sse2; 1073| 9.82k| } 1074| 9.82k|# endif 1075| 9.82k|# ifdef FLAC__SSSE3_SUPPORTED 1076| 9.82k| if (encoder->private_->cpuinfo.x86.ssse3) { ------------------ | Branch (1076:7): [True: 9.82k, False: 0] ------------------ 1077| 9.82k| encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3; 1078| 9.82k| } 1079| 9.82k|# endif 1080| 9.82k|# ifdef FLAC__SSE4_2_SUPPORTED 1081| 9.82k| if (encoder->private_->cpuinfo.x86.sse42) { ------------------ | Branch (1081:7): [True: 9.82k, False: 0] ------------------ 1082| 9.82k| encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual_intrin_sse42; 1083| 9.82k| } 1084| 9.82k|# endif 1085| 9.82k|# ifdef FLAC__AVX2_SUPPORTED 1086| 9.82k| if (encoder->private_->cpuinfo.x86.avx2) { ------------------ | Branch (1086:7): [True: 9.82k, False: 0] ------------------ 1087| 9.82k| encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_avx2; 1088| 9.82k| encoder->private_->local_fixed_compute_best_predictor_limit_residual = FLAC__fixed_compute_best_predictor_limit_residual_intrin_avx2; 1089| 9.82k| } 1090| 9.82k|# endif 1091| 9.82k|# endif /* FLAC__HAS_X86INTRIN */ 1092| 9.82k|# endif /* FLAC__CPU_... */ 1093| 9.82k| } 1094| 9.82k|# endif /* !FLAC__NO_ASM */ 1095| | 1096| 9.82k|#endif /* !FLAC__INTEGER_ONLY_LIBRARY */ 1097| 9.82k|#if !defined FLAC__NO_ASM && FLAC__HAS_X86INTRIN 1098| 9.82k| if(encoder->private_->cpuinfo.use_asm) { ------------------ | Branch (1098:5): [True: 9.82k, False: 0] ------------------ 1099| 9.82k|# if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) 1100| 9.82k|# ifdef FLAC__SSE2_SUPPORTED 1101| 9.82k| if (encoder->private_->cpuinfo.x86.sse2) ------------------ | Branch (1101:7): [True: 9.82k, False: 0] ------------------ 1102| 9.82k| encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_sse2; 1103| 9.82k|# endif 1104| 9.82k|# ifdef FLAC__SSSE3_SUPPORTED 1105| 9.82k| if (encoder->private_->cpuinfo.x86.ssse3) ------------------ | Branch (1105:7): [True: 9.82k, False: 0] ------------------ 1106| 9.82k| encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_ssse3; 1107| 9.82k|# endif 1108| 9.82k|# ifdef FLAC__AVX2_SUPPORTED 1109| 9.82k| if (encoder->private_->cpuinfo.x86.avx2) ------------------ | Branch (1109:7): [True: 9.82k, False: 0] ------------------ 1110| 9.82k| encoder->private_->local_precompute_partition_info_sums = FLAC__precompute_partition_info_sums_intrin_avx2; 1111| 9.82k|# endif 1112| 9.82k|# endif /* FLAC__CPU_... */ 1113| 9.82k| } 1114| 9.82k|#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.82k| encoder->protected_->state = FLAC__STREAM_ENCODER_OK; 1118| | 1119| 9.82k|#if FLAC__HAS_OGG 1120| 9.82k| encoder->private_->is_ogg = is_ogg; 1121| 9.82k| if(is_ogg && !FLAC__ogg_encoder_aspect_init(&encoder->protected_->ogg_encoder_aspect)) { ------------------ | Branch (1121:5): [True: 3.09k, False: 6.72k] | Branch (1121:15): [True: 0, False: 3.09k] ------------------ 1122| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_OGG_ERROR; 1123| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1124| 0| } 1125| 9.82k|#endif 1126| | 1127| 9.82k| encoder->private_->read_callback = read_callback; 1128| 9.82k| encoder->private_->write_callback = write_callback; 1129| 9.82k| encoder->private_->seek_callback = seek_callback; 1130| 9.82k| encoder->private_->tell_callback = tell_callback; 1131| 9.82k| encoder->private_->metadata_callback = metadata_callback; 1132| 9.82k| encoder->private_->client_data = client_data; 1133| | 1134| 9.82k| if(encoder->protected_->num_threads > 1) { ------------------ | Branch (1134:5): [True: 796, False: 9.03k] ------------------ 1135| 796|#ifdef FLAC__USE_THREADS 1136| 796| encoder->private_->num_threadtasks = encoder->protected_->num_threads * 2 + 2; /* First threadtask is reserved for main thread */ 1137| 796| if(FLAC__mtx_init(&encoder->private_->mutex_md5_fifo, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 103| 796|#define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 796|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 796|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (103:47): [True: 796, False: 0] | | ------------------ ------------------ if(FLAC__mtx_init(&encoder->private_->mutex_md5_fifo, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 93| 796|#define FLAC__thrd_success 0 ------------------ | Branch (1137:6): [True: 0, False: 796] ------------------ 1138| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1139| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1140| 0| } 1141| 796| if(FLAC__mtx_init(&encoder->private_->mutex_work_queue, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 103| 796|#define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 796|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 796|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (103:47): [True: 796, False: 0] | | ------------------ ------------------ if(FLAC__mtx_init(&encoder->private_->mutex_work_queue, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 93| 796|#define FLAC__thrd_success 0 ------------------ | Branch (1141:6): [True: 0, False: 796] ------------------ 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| 796| if(FLAC__cnd_init(&encoder->private_->cond_md5_emptied) != FLAC__thrd_success) { ------------------ | | 110| 796|#define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 796|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 796|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (110:47): [True: 796, False: 0] | | ------------------ ------------------ if(FLAC__cnd_init(&encoder->private_->cond_md5_emptied) != FLAC__thrd_success) { ------------------ | | 93| 796|#define FLAC__thrd_success 0 ------------------ | Branch (1146:6): [True: 0, False: 796] ------------------ 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| 796| if(FLAC__cnd_init(&encoder->private_->cond_work_available) != FLAC__thrd_success) { ------------------ | | 110| 796|#define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 796|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 796|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (110:47): [True: 796, False: 0] | | ------------------ ------------------ if(FLAC__cnd_init(&encoder->private_->cond_work_available) != FLAC__thrd_success) { ------------------ | | 93| 796|#define FLAC__thrd_success 0 ------------------ | Branch (1152:6): [True: 0, False: 796] ------------------ 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| 796| if(FLAC__cnd_init(&encoder->private_->cond_wake_up_thread) != FLAC__thrd_success) { ------------------ | | 110| 796|#define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 796|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 796|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (110:47): [True: 796, False: 0] | | ------------------ ------------------ if(FLAC__cnd_init(&encoder->private_->cond_wake_up_thread) != FLAC__thrd_success) { ------------------ | | 93| 796|#define FLAC__thrd_success 0 ------------------ | Branch (1159:6): [True: 0, False: 796] ------------------ 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| 796| if(encoder->protected_->do_md5) { ------------------ | Branch (1167:6): [True: 796, False: 0] ------------------ 1168| 796| encoder->private_->md5_fifo.size = (encoder->protected_->blocksize+OVERREAD_) * (encoder->private_->num_threadtasks + 2); 1169| 1.99k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (1169:15): [True: 1.19k, False: 796] ------------------ 1170| 1.19k| 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.19k] ------------------ 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.19k| } 1180| 796| } 1181| 796| encoder->private_->md5_fifo.tail = 0; 1182| 14.2k| for(t = 1; t < encoder->private_->num_threadtasks; t++) { ------------------ | Branch (1182:14): [True: 13.4k, False: 796] ------------------ 1183| 13.4k| encoder->private_->threadtask[t] = safe_calloc_(1, sizeof(FLAC__StreamEncoderThreadTask)); 1184| 13.4k| if(encoder->private_->threadtask[t] == NULL) { ------------------ | Branch (1184:7): [True: 0, False: 13.4k] ------------------ 1185| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1186| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1187| 0| } 1188| 13.4k| encoder->private_->threadtask[t]->frame = FLAC__bitwriter_new(); 1189| 13.4k| if(encoder->private_->threadtask[t]->frame == NULL) { ------------------ | Branch (1189:7): [True: 0, False: 13.4k] ------------------ 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| 13.4k| if(FLAC__mtx_init(&encoder->private_->threadtask[t]->mutex_this_task, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 103| 13.4k|#define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 13.4k|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__mtx_init(mutex, type) ((pthread_mutex_init(mutex, type) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 13.4k|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (103:47): [True: 13.4k, False: 0] | | ------------------ ------------------ if(FLAC__mtx_init(&encoder->private_->threadtask[t]->mutex_this_task, FLAC__mtx_plain) != FLAC__thrd_success) { ------------------ | | 93| 13.4k|#define FLAC__thrd_success 0 ------------------ | Branch (1195:7): [True: 0, False: 13.4k] ------------------ 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| 13.4k| if(FLAC__cnd_init(&encoder->private_->threadtask[t]->cond_task_done) != FLAC__thrd_success) { ------------------ | | 110| 13.4k|#define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 93| 13.4k|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__cnd_init(cv) ((pthread_cond_init(cv, NULL) == 0) ? FLAC__thrd_success : FLAC__thrd_nomem) | | ------------------ | | | | 95| 13.4k|#define FLAC__thrd_nomem ENOMEM | | ------------------ | | | Branch (110:47): [True: 13.4k, False: 0] | | ------------------ ------------------ if(FLAC__cnd_init(&encoder->private_->threadtask[t]->cond_task_done) != FLAC__thrd_success) { ------------------ | | 93| 13.4k|#define FLAC__thrd_success 0 ------------------ | Branch (1202:7): [True: 0, False: 13.4k] ------------------ 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| 120k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 120k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (1211:15): [True: 107k, False: 13.4k] ------------------ 1212| 107k| encoder->private_->threadtask[t]->subframe_workspace_ptr[i][0] = &encoder->private_->threadtask[t]->subframe_workspace[i][0]; 1213| 107k| encoder->private_->threadtask[t]->subframe_workspace_ptr[i][1] = &encoder->private_->threadtask[t]->subframe_workspace[i][1]; 1214| 107k| } 1215| 40.2k| for(i = 0; i < 2; i++) { ------------------ | Branch (1215:15): [True: 26.8k, False: 13.4k] ------------------ 1216| 26.8k| encoder->private_->threadtask[t]->subframe_workspace_ptr_mid_side[i][0] = &encoder->private_->threadtask[t]->subframe_workspace_mid_side[i][0]; 1217| 26.8k| encoder->private_->threadtask[t]->subframe_workspace_ptr_mid_side[i][1] = &encoder->private_->threadtask[t]->subframe_workspace_mid_side[i][1]; 1218| 26.8k| } 1219| 120k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 120k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (1219:15): [True: 107k, False: 13.4k] ------------------ 1220| 107k| encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_ptr[i][0] = &encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][0]; 1221| 107k| encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_ptr[i][1] = &encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][1]; 1222| 107k| } 1223| 40.2k| for(i = 0; i < 2; i++) { ------------------ | Branch (1223:15): [True: 26.8k, False: 13.4k] ------------------ 1224| 26.8k| 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| 26.8k| 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| 26.8k| } 1227| | 1228| 120k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 120k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (1228:15): [True: 107k, False: 13.4k] ------------------ 1229| 107k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][0]); 1230| 107k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][1]); 1231| 107k| } 1232| 40.2k| for(i = 0; i < 2; i++) { ------------------ | Branch (1232:15): [True: 26.8k, False: 13.4k] ------------------ 1233| 26.8k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[i][0]); 1234| 26.8k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[i][1]); 1235| 26.8k| } 1236| 40.2k| for(i = 0; i < 2; i++) ------------------ | Branch (1236:15): [True: 26.8k, False: 13.4k] ------------------ 1237| 26.8k| FLAC__format_entropy_coding_method_partitioned_rice_contents_init(&encoder->private_->threadtask[t]->partitioned_rice_contents_extra[i]); 1238| 13.4k| } 1239| |#else 1240| | FLAC__ASSERT(0); 1241| |#endif 1242| 796| } 1243| | 1244| 9.82k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 1245| 32.5k| for(i = 0; i < encoder->protected_->num_apodizations; i++) ------------------ | Branch (1245:13): [True: 22.7k, False: 9.82k] ------------------ 1246| 22.7k| encoder->private_->window_unaligned[i] = encoder->private_->window[i] = 0; 1247| 9.82k|#endif 1248| 33.0k| for(t = 0; t < encoder->private_->num_threadtasks; t++) { ------------------ | Branch (1248:13): [True: 23.2k, False: 9.82k] ------------------ 1249| 61.2k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (1249:14): [True: 37.9k, False: 23.2k] ------------------ 1250| 37.9k| encoder->private_->threadtask[t]->integer_signal_unaligned[i] = encoder->private_->threadtask[t]->integer_signal[i] = 0; 1251| 37.9k| } 1252| 69.7k| for(i = 0; i < 2; i++) { ------------------ | Branch (1252:14): [True: 46.4k, False: 23.2k] ------------------ 1253| 46.4k| encoder->private_->threadtask[t]->integer_signal_mid_side_unaligned[i] = encoder->private_->threadtask[t]->integer_signal_mid_side[i] = 0; 1254| 46.4k| } 1255| 23.2k| encoder->private_->threadtask[t]->integer_signal_33bit_side_unaligned = encoder->private_->threadtask[t]->integer_signal_33bit_side = 0; 1256| 23.2k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 1257| 23.2k| encoder->private_->threadtask[t]->windowed_signal_unaligned = encoder->private_->threadtask[t]->windowed_signal = 0; 1258| 23.2k|#endif 1259| 61.2k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (1259:14): [True: 37.9k, False: 23.2k] ------------------ 1260| 37.9k| encoder->private_->threadtask[t]->residual_workspace_unaligned[i][0] = encoder->private_->threadtask[t]->residual_workspace[i][0] = 0; 1261| 37.9k| encoder->private_->threadtask[t]->residual_workspace_unaligned[i][1] = encoder->private_->threadtask[t]->residual_workspace[i][1] = 0; 1262| 37.9k| encoder->private_->threadtask[t]->best_subframe[i] = 0; 1263| 37.9k| } 1264| 69.7k| for(i = 0; i < 2; i++) { ------------------ | Branch (1264:14): [True: 46.4k, False: 23.2k] ------------------ 1265| 46.4k| encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[i][0] = encoder->private_->threadtask[t]->residual_workspace_mid_side[i][0] = 0; 1266| 46.4k| encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[i][1] = encoder->private_->threadtask[t]->residual_workspace_mid_side[i][1] = 0; 1267| 46.4k| encoder->private_->threadtask[t]->best_subframe_mid_side[i] = 0; 1268| 46.4k| } 1269| 23.2k| encoder->private_->threadtask[t]->abs_residual_partition_sums_unaligned = encoder->private_->threadtask[t]->abs_residual_partition_sums = 0; 1270| 23.2k| encoder->private_->threadtask[t]->raw_bits_per_partition_unaligned = encoder->private_->threadtask[t]->raw_bits_per_partition = 0; 1271| 23.2k| } 1272| | 1273| | 1274| 9.82k| if(!resize_buffers_(encoder, encoder->protected_->blocksize)) { ------------------ | Branch (1274:5): [True: 0, False: 9.82k] ------------------ 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| 33.0k| for(t = 0; t < encoder->private_->num_threadtasks; t++) { ------------------ | Branch (1279:13): [True: 23.2k, False: 9.82k] ------------------ 1280| 23.2k| if(!FLAC__bitwriter_init(encoder->private_->threadtask[t]->frame)) { ------------------ | Branch (1280:6): [True: 0, False: 23.2k] ------------------ 1281| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 1282| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1283| 0| } 1284| 23.2k| } 1285| | 1286| | /* 1287| | * Set up the verify stuff if necessary 1288| | */ 1289| 9.82k| if(encoder->protected_->verify) { ------------------ | Branch (1289:5): [True: 8.73k, False: 1.08k] ------------------ 1290| | /* 1291| | * First, set up the fifo which will hold the 1292| | * original signal to compare against 1293| | */ 1294| 8.73k| encoder->private_->verify.input_fifo.size = (encoder->protected_->blocksize+OVERREAD_) * encoder->private_->num_threadtasks; 1295| 23.6k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (1295:14): [True: 14.9k, False: 8.73k] ------------------ 1296| 14.9k| 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.9k] ------------------ 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.9k| } 1301| 8.73k| encoder->private_->verify.input_fifo.tail = 0; 1302| | 1303| | /* 1304| | * Now set up a stream decoder for verification 1305| | */ 1306| 8.73k| if(0 == encoder->private_->verify.decoder) { ------------------ | Branch (1306:6): [True: 8.73k, False: 0] ------------------ 1307| 8.73k| encoder->private_->verify.decoder = FLAC__stream_decoder_new(); 1308| 8.73k| if(0 == encoder->private_->verify.decoder) { ------------------ | Branch (1308:7): [True: 0, False: 8.73k] ------------------ 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.73k| } 1313| | 1314| 8.73k| 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.73k] ------------------ 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.73k| } 1319| 9.82k| encoder->private_->verify.error_stats.absolute_sample = 0; 1320| 9.82k| encoder->private_->verify.error_stats.frame_number = 0; 1321| 9.82k| encoder->private_->verify.error_stats.channel = 0; 1322| 9.82k| encoder->private_->verify.error_stats.sample = 0; 1323| 9.82k| encoder->private_->verify.error_stats.expected = 0; 1324| 9.82k| 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.82k| encoder->private_->first_seekpoint_to_check = 0; 1331| 9.82k| encoder->private_->samples_written = 0; 1332| 9.82k| encoder->protected_->streaminfo_offset = 0; 1333| 9.82k| encoder->protected_->seektable_offset = 0; 1334| 9.82k| encoder->protected_->audio_offset = 0; 1335| | 1336| | /* 1337| | * write the stream header 1338| | */ 1339| 9.82k| if(encoder->protected_->verify) ------------------ | Branch (1339:5): [True: 8.73k, False: 1.08k] ------------------ 1340| 8.73k| encoder->private_->verify.state_hint = ENCODER_IN_MAGIC; 1341| 9.82k| 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.82k] ------------------ 1342| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1343| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1344| 0| } 1345| 9.82k| if(!write_bitbuffer_(encoder, encoder->private_->threadtask[0], 0, /*is_last_block=*/false)) { ------------------ | Branch (1345:5): [True: 0, False: 9.82k] ------------------ 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.82k| if(encoder->protected_->verify) ------------------ | Branch (1353:5): [True: 8.73k, False: 1.08k] ------------------ 1354| 8.73k| encoder->private_->verify.state_hint = ENCODER_IN_METADATA; 1355| 9.82k| encoder->private_->streaminfo.type = FLAC__METADATA_TYPE_STREAMINFO; 1356| 9.82k| encoder->private_->streaminfo.is_last = false; /* we will have at a minimum a VORBIS_COMMENT afterwards */ 1357| 9.82k| encoder->private_->streaminfo.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH; ------------------ | | 557| 9.82k|#define FLAC__STREAM_METADATA_STREAMINFO_LENGTH (34u) ------------------ 1358| 9.82k| encoder->private_->streaminfo.data.stream_info.min_blocksize = encoder->protected_->blocksize; /* this encoder uses the same blocksize for the whole stream */ 1359| 9.82k| encoder->private_->streaminfo.data.stream_info.max_blocksize = encoder->protected_->blocksize; 1360| 9.82k| encoder->private_->streaminfo.data.stream_info.min_framesize = 0; /* we don't know this yet; have to fill it in later */ 1361| 9.82k| encoder->private_->streaminfo.data.stream_info.max_framesize = 0; /* we don't know this yet; have to fill it in later */ 1362| 9.82k| encoder->private_->streaminfo.data.stream_info.sample_rate = encoder->protected_->sample_rate; 1363| 9.82k| encoder->private_->streaminfo.data.stream_info.channels = encoder->protected_->channels; 1364| 9.82k| encoder->private_->streaminfo.data.stream_info.bits_per_sample = encoder->protected_->bits_per_sample; 1365| 9.82k| encoder->private_->streaminfo.data.stream_info.total_samples = encoder->protected_->total_samples_estimate; /* we will replace this later with the real total */ 1366| 9.82k| memset(encoder->private_->streaminfo.data.stream_info.md5sum, 0, 16); /* we don't know this yet; have to fill it in later */ 1367| 9.82k| if(encoder->protected_->do_md5) ------------------ | Branch (1367:5): [True: 9.82k, False: 0] ------------------ 1368| 9.82k| FLAC__MD5Init(&encoder->private_->md5context); 1369| 9.82k| if(!FLAC__add_metadata_block(&encoder->private_->streaminfo, encoder->private_->threadtask[0]->frame, true)) { ------------------ | Branch (1369:5): [True: 0, False: 9.82k] ------------------ 1370| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1371| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1372| 0| } 1373| 9.82k| if(!write_bitbuffer_(encoder, encoder->private_->threadtask[0], 0, /*is_last_block=*/false)) { ------------------ | Branch (1373:5): [True: 0, False: 9.82k] ------------------ 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.82k| 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.82k| 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.82k| if(!metadata_has_vorbis_comment) { ------------------ | Branch (1396:5): [True: 9.82k, False: 0] ------------------ 1397| 9.82k| FLAC__StreamMetadata vorbis_comment; 1398| 9.82k| vorbis_comment.type = FLAC__METADATA_TYPE_VORBIS_COMMENT; 1399| 9.82k| vorbis_comment.is_last = (encoder->protected_->num_metadata_blocks == 0); 1400| 9.82k| vorbis_comment.length = 4 + 4; /* MAGIC NUMBER */ 1401| 9.82k| vorbis_comment.data.vorbis_comment.vendor_string.length = 0; 1402| 9.82k| vorbis_comment.data.vorbis_comment.vendor_string.entry = 0; 1403| 9.82k| vorbis_comment.data.vorbis_comment.num_comments = 0; 1404| 9.82k| vorbis_comment.data.vorbis_comment.comments = 0; 1405| 9.82k| if(!FLAC__add_metadata_block(&vorbis_comment, encoder->private_->threadtask[0]->frame, true)) { ------------------ | Branch (1405:6): [True: 0, False: 9.82k] ------------------ 1406| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 1407| 0| return FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR; 1408| 0| } 1409| 9.82k| if(!write_bitbuffer_(encoder, encoder->private_->threadtask[0], 0, /*is_last_block=*/false)) { ------------------ | Branch (1409:6): [True: 0, False: 9.82k] ------------------ 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.82k| } 1414| | 1415| | /* 1416| | * write the user's metadata blocks 1417| | */ 1418| 9.82k| for(i = 0; i < encoder->protected_->num_metadata_blocks; i++) { ------------------ | Branch (1418:13): [True: 0, False: 9.82k] ------------------ 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.82k| 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.82k, False: 0] | Branch (1431:41): [True: 0, False: 9.82k] ------------------ 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.82k| if(encoder->protected_->verify) ------------------ | Branch (1436:5): [True: 8.73k, False: 1.08k] ------------------ 1437| 8.73k| encoder->private_->verify.state_hint = ENCODER_IN_AUDIO; 1438| | 1439| 9.82k| return FLAC__STREAM_ENCODER_INIT_STATUS_OK; 1440| 9.82k|} stream_encoder.c:verify_read_callback_: 5156| 250k|{ 5157| 250k| FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder*)client_data; 5158| 250k| const size_t encoded_bytes = encoder->private_->verify.output.bytes; 5159| 250k| (void)decoder; 5160| | 5161| 250k| if(encoder->private_->verify.needs_magic_hack) { ------------------ | Branch (5161:5): [True: 8.73k, False: 241k] ------------------ 5162| 8.73k| FLAC__ASSERT(*bytes >= FLAC__STREAM_SYNC_LENGTH); ------------------ | | 38| 8.73k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 8.73k] | | ------------------ ------------------ 5163| 8.73k| *bytes = FLAC__STREAM_SYNC_LENGTH; ------------------ | | 179| 8.73k|#define FLAC__STREAM_SYNC_LENGTH (4u) ------------------ 5164| 8.73k| memcpy(buffer, FLAC__STREAM_SYNC_STRING, *bytes); 5165| 8.73k| encoder->private_->verify.needs_magic_hack = false; 5166| 8.73k| } 5167| 241k| else { 5168| 241k| if(encoded_bytes == 0) { ------------------ | Branch (5168:6): [True: 0, False: 241k] ------------------ 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| 241k| else if(encoded_bytes < *bytes) ------------------ | Branch (5176:11): [True: 233k, False: 7.61k] ------------------ 5177| 233k| *bytes = encoded_bytes; 5178| 241k| memcpy(buffer, encoder->private_->verify.output.data, *bytes); 5179| 241k| encoder->private_->verify.output.data += *bytes; 5180| 241k| encoder->private_->verify.output.bytes -= *bytes; 5181| 241k| } 5182| | 5183| 250k| return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; 5184| 250k|} stream_encoder.c:verify_write_callback_: 5187| 216k|{ 5188| 216k| FLAC__StreamEncoder *encoder = (FLAC__StreamEncoder *)client_data; 5189| 216k| uint32_t channel; 5190| 216k| const uint32_t channels = frame->header.channels; 5191| 216k| const uint32_t blocksize = frame->header.blocksize; 5192| 216k| const uint32_t bytes_per_block = sizeof(FLAC__int32) * blocksize; 5193| | 5194| 216k| (void)decoder; 5195| | 5196| 216k| if(encoder->protected_->state == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) { ------------------ | Branch (5196:5): [True: 0, False: 216k] ------------------ 5197| | /* This is set when verify_error_callback_ was called */ 5198| 0| return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; 5199| 0| } 5200| | 5201| 500k| for(channel = 0; channel < channels; channel++) { ------------------ | Branch (5201:19): [True: 284k, False: 216k] ------------------ 5202| 284k| if(0 != memcmp(buffer[channel], encoder->private_->verify.input_fifo.data[channel], bytes_per_block)) { ------------------ | Branch (5202:6): [True: 0, False: 284k] ------------------ 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| 284k| } 5226| | /* dequeue the frame from the fifo */ 5227| 216k| encoder->private_->verify.input_fifo.tail -= blocksize; 5228| 500k| for(channel = 0; channel < channels; channel++) ------------------ | Branch (5228:19): [True: 284k, False: 216k] ------------------ 5229| 284k| 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| 216k| return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; 5231| 216k|} stream_encoder.c:verify_metadata_callback_: 5234| 8.73k|{ 5235| 8.73k| (void)decoder, (void)metadata, (void)client_data; 5236| 8.73k|} stream_encoder.c:set_defaults_: 2629| 21.9k|{ 2630| 21.9k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 21.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 21.9k] | | ------------------ ------------------ 2631| | 2632| |#ifdef FLAC__MANDATORY_VERIFY_WHILE_ENCODING 2633| | encoder->protected_->verify = true; 2634| |#else 2635| 21.9k| encoder->protected_->verify = false; 2636| 21.9k|#endif 2637| 21.9k| encoder->protected_->streamable_subset = true; 2638| 21.9k| encoder->protected_->do_md5 = true; 2639| 21.9k| encoder->protected_->do_mid_side_stereo = false; 2640| 21.9k| encoder->protected_->loose_mid_side_stereo = false; 2641| 21.9k| encoder->protected_->channels = 2; 2642| 21.9k| encoder->protected_->bits_per_sample = 16; 2643| 21.9k| encoder->protected_->sample_rate = 44100; 2644| 21.9k| encoder->protected_->blocksize = 0; 2645| 21.9k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2646| 21.9k| encoder->protected_->num_apodizations = 1; 2647| 21.9k| encoder->protected_->apodizations[0].type = FLAC__APODIZATION_TUKEY; 2648| 21.9k| encoder->protected_->apodizations[0].parameters.tukey.p = 0.5; 2649| 21.9k|#endif 2650| 21.9k| encoder->protected_->max_lpc_order = 0; 2651| 21.9k| encoder->protected_->qlp_coeff_precision = 0; 2652| 21.9k| encoder->protected_->do_qlp_coeff_prec_search = false; 2653| 21.9k| encoder->protected_->do_exhaustive_model_search = false; 2654| 21.9k| encoder->protected_->do_escape_coding = false; 2655| 21.9k| encoder->protected_->min_residual_partition_order = 0; 2656| 21.9k| encoder->protected_->max_residual_partition_order = 0; 2657| 21.9k| encoder->protected_->rice_parameter_search_dist = 0; 2658| 21.9k| encoder->protected_->total_samples_estimate = 0; 2659| 21.9k| encoder->protected_->limit_min_bitrate = false; 2660| 21.9k| encoder->protected_->metadata = 0; 2661| 21.9k| encoder->protected_->num_metadata_blocks = 0; 2662| 21.9k| encoder->protected_->num_threads = 1; 2663| | 2664| 21.9k| encoder->private_->seek_table = 0; 2665| 21.9k| encoder->private_->disable_mmx = false; 2666| 21.9k| encoder->private_->disable_sse2 = false; 2667| 21.9k| encoder->private_->disable_ssse3 = false; 2668| 21.9k| encoder->private_->disable_sse41 = false; 2669| 21.9k| encoder->private_->disable_sse42 = false; 2670| 21.9k| encoder->private_->disable_avx2 = false; 2671| 21.9k| encoder->private_->disable_constant_subframes = false; 2672| 21.9k| encoder->private_->disable_fixed_subframes = false; 2673| 21.9k| encoder->private_->disable_verbatim_subframes = false; 2674| 21.9k| encoder->private_->is_ogg = false; 2675| 21.9k| encoder->private_->read_callback = 0; 2676| 21.9k| encoder->private_->write_callback = 0; 2677| 21.9k| encoder->private_->seek_callback = 0; 2678| 21.9k| encoder->private_->tell_callback = 0; 2679| 21.9k| encoder->private_->metadata_callback = 0; 2680| 21.9k| encoder->private_->progress_callback = 0; 2681| 21.9k| encoder->private_->client_data = 0; 2682| 21.9k| encoder->private_->num_threadtasks = 1; 2683| 21.9k|#ifdef FLAC__USE_THREADS 2684| 21.9k| encoder->private_->num_created_threads = 1; 2685| 21.9k| encoder->private_->next_thread = 1; 2686| 21.9k| encoder->private_->num_running_threads = 1; 2687| 21.9k| encoder->private_->num_started_threadtasks = 1; 2688| 21.9k| encoder->private_->num_available_threadtasks = 0; 2689| 21.9k| encoder->private_->overcommitted_indicator = 0; 2690| 21.9k| encoder->private_->next_threadtask = 1; 2691| 21.9k| encoder->private_->md5_active = false; 2692| 21.9k| encoder->private_->finish_work_threads = false; 2693| 21.9k|#endif 2694| | 2695| 21.9k|#if FLAC__HAS_OGG 2696| 21.9k| FLAC__ogg_encoder_aspect_set_defaults(&encoder->protected_->ogg_encoder_aspect); 2697| 21.9k|#endif 2698| | 2699| 21.9k| FLAC__stream_encoder_set_compression_level(encoder, 5); 2700| 21.9k|} stream_encoder.c:free_: 2703| 9.82k|{ 2704| 9.82k| uint32_t i, t, channel; 2705| | 2706| 9.82k| FLAC__ASSERT(0 != encoder); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 2707| 9.82k| if(encoder->protected_->metadata) { ------------------ | Branch (2707:5): [True: 0, False: 9.82k] ------------------ 2708| 0| free(encoder->protected_->metadata); 2709| 0| encoder->protected_->metadata = 0; 2710| 0| encoder->protected_->num_metadata_blocks = 0; 2711| 0| } 2712| 9.82k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2713| 32.5k| for(i = 0; i < encoder->protected_->num_apodizations; i++) { ------------------ | Branch (2713:13): [True: 22.7k, False: 9.82k] ------------------ 2714| 22.7k| if(0 != encoder->private_->window_unaligned[i]) { ------------------ | Branch (2714:6): [True: 21.2k, False: 1.48k] ------------------ 2715| 21.2k| free(encoder->private_->window_unaligned[i]); 2716| 21.2k| encoder->private_->window_unaligned[i] = 0; 2717| 21.2k| } 2718| 22.7k| } 2719| 9.82k|#endif 2720| 33.0k| for(t = 0; t < encoder->private_->num_threadtasks; t++) { ------------------ | Branch (2720:13): [True: 23.2k, False: 9.82k] ------------------ 2721| 23.2k| if(0 == encoder->private_->threadtask[t]) ------------------ | Branch (2721:6): [True: 0, False: 23.2k] ------------------ 2722| 0| continue; 2723| 61.2k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (2723:14): [True: 37.9k, False: 23.2k] ------------------ 2724| 37.9k| if(0 != encoder->private_->threadtask[t]->integer_signal_unaligned[i]) { ------------------ | Branch (2724:7): [True: 37.9k, False: 0] ------------------ 2725| 37.9k| free(encoder->private_->threadtask[t]->integer_signal_unaligned[i]); 2726| 37.9k| encoder->private_->threadtask[t]->integer_signal_unaligned[i] = 0; 2727| 37.9k| } 2728| 37.9k| } 2729| 69.7k| for(i = 0; i < 2; i++) { ------------------ | Branch (2729:14): [True: 46.4k, False: 23.2k] ------------------ 2730| 46.4k| if(0 != encoder->private_->threadtask[t]->integer_signal_mid_side_unaligned[i]) { ------------------ | Branch (2730:7): [True: 46.4k, False: 0] ------------------ 2731| 46.4k| free(encoder->private_->threadtask[t]->integer_signal_mid_side_unaligned[i]); 2732| 46.4k| encoder->private_->threadtask[t]->integer_signal_mid_side_unaligned[i] = 0; 2733| 46.4k| } 2734| 46.4k| } 2735| 23.2k| if(0 != encoder->private_->threadtask[t]->integer_signal_33bit_side_unaligned){ ------------------ | Branch (2735:6): [True: 23.2k, False: 0] ------------------ 2736| 23.2k| free(encoder->private_->threadtask[t]->integer_signal_33bit_side_unaligned); 2737| 23.2k| encoder->private_->threadtask[t]->integer_signal_33bit_side_unaligned = 0; 2738| 23.2k| } 2739| 23.2k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2740| 23.2k| if(0 != encoder->private_->threadtask[t]->windowed_signal_unaligned) { ------------------ | Branch (2740:6): [True: 15.5k, False: 7.73k] ------------------ 2741| 15.5k| free(encoder->private_->threadtask[t]->windowed_signal_unaligned); 2742| 15.5k| encoder->private_->threadtask[t]->windowed_signal_unaligned = 0; 2743| 15.5k| } 2744| 23.2k|#endif 2745| 61.2k| for(channel = 0; channel < encoder->protected_->channels; channel++) { ------------------ | Branch (2745:20): [True: 37.9k, False: 23.2k] ------------------ 2746| 113k| for(i = 0; i < 2; i++) { ------------------ | Branch (2746:15): [True: 75.9k, False: 37.9k] ------------------ 2747| 75.9k| if(0 != encoder->private_->threadtask[t]->residual_workspace_unaligned[channel][i]) { ------------------ | Branch (2747:8): [True: 75.9k, False: 0] ------------------ 2748| 75.9k| free(encoder->private_->threadtask[t]->residual_workspace_unaligned[channel][i]); 2749| 75.9k| encoder->private_->threadtask[t]->residual_workspace_unaligned[channel][i] = 0; 2750| 75.9k| } 2751| 75.9k| } 2752| 37.9k| } 2753| 69.7k| for(channel = 0; channel < 2; channel++) { ------------------ | Branch (2753:20): [True: 46.4k, False: 23.2k] ------------------ 2754| 139k| for(i = 0; i < 2; i++) { ------------------ | Branch (2754:15): [True: 92.9k, False: 46.4k] ------------------ 2755| 92.9k| if(0 != encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[channel][i]) { ------------------ | Branch (2755:8): [True: 92.9k, False: 0] ------------------ 2756| 92.9k| free(encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[channel][i]); 2757| 92.9k| encoder->private_->threadtask[t]->residual_workspace_mid_side_unaligned[channel][i] = 0; 2758| 92.9k| } 2759| 92.9k| } 2760| 46.4k| } 2761| 23.2k| if(0 != encoder->private_->threadtask[t]->abs_residual_partition_sums_unaligned) { ------------------ | Branch (2761:6): [True: 23.2k, False: 0] ------------------ 2762| 23.2k| free(encoder->private_->threadtask[t]->abs_residual_partition_sums_unaligned); 2763| 23.2k| encoder->private_->threadtask[t]->abs_residual_partition_sums_unaligned = 0; 2764| 23.2k| } 2765| 23.2k| if(0 != encoder->private_->threadtask[t]->raw_bits_per_partition_unaligned) { ------------------ | Branch (2765:6): [True: 15.4k, False: 7.79k] ------------------ 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| 209k| for(i = 0; i < FLAC__MAX_CHANNELS; i++) { ------------------ | | 106| 209k|#define FLAC__MAX_CHANNELS (8u) ------------------ | Branch (2769:14): [True: 185k, False: 23.2k] ------------------ 2770| 185k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][0]); 2771| 185k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace[i][1]); 2772| 185k| } 2773| 69.7k| for(i = 0; i < 2; i++) { ------------------ | Branch (2773:14): [True: 46.4k, False: 23.2k] ------------------ 2774| 46.4k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[i][0]); 2775| 46.4k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[t]->partitioned_rice_contents_workspace_mid_side[i][1]); 2776| 46.4k| } 2777| 69.7k| for(i = 0; i < 2; i++) ------------------ | Branch (2777:14): [True: 46.4k, False: 23.2k] ------------------ 2778| 46.4k| FLAC__format_entropy_coding_method_partitioned_rice_contents_clear(&encoder->private_->threadtask[t]->partitioned_rice_contents_extra[i]); 2779| 23.2k| if(t > 0) { ------------------ | Branch (2779:6): [True: 13.4k, False: 9.82k] ------------------ 2780| 13.4k|#ifdef FLAC__USE_THREADS 2781| 13.4k| FLAC__bitwriter_delete(encoder->private_->threadtask[t]->frame); 2782| 13.4k| FLAC__mtx_destroy(&encoder->private_->threadtask[t]->mutex_this_task); ------------------ | | 107| 13.4k|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 2783| 13.4k| FLAC__cnd_destroy(&encoder->private_->threadtask[t]->cond_task_done); ------------------ | | 114| 13.4k|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 2784| 13.4k| free(encoder->private_->threadtask[t]); 2785| 13.4k| encoder->private_->threadtask[t] = 0; 2786| |#else 2787| | FLAC__ASSERT(0); 2788| |#endif 2789| 13.4k| } 2790| | 2791| 23.2k| } 2792| 9.82k|#ifdef FLAC__USE_THREADS 2793| 9.82k| if(encoder->protected_->num_threads > 1) { ------------------ | Branch (2793:5): [True: 796, False: 9.03k] ------------------ 2794| 796| FLAC__mtx_destroy(&encoder->private_->mutex_md5_fifo); ------------------ | | 107| 796|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 2795| 796| FLAC__mtx_destroy(&encoder->private_->mutex_work_queue); ------------------ | | 107| 796|#define FLAC__mtx_destroy(mutex) pthread_mutex_destroy(mutex) ------------------ 2796| 796| FLAC__cnd_destroy(&encoder->private_->cond_md5_emptied); ------------------ | | 114| 796|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 2797| 796| FLAC__cnd_destroy(&encoder->private_->cond_work_available); ------------------ | | 114| 796|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 2798| 796| FLAC__cnd_destroy(&encoder->private_->cond_wake_up_thread); ------------------ | | 114| 796|#define FLAC__cnd_destroy(cv) pthread_cond_destroy(cv) ------------------ 2799| 796| if(encoder->protected_->do_md5) { ------------------ | Branch (2799:6): [True: 796, False: 0] ------------------ 2800| 1.99k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (2800:15): [True: 1.19k, False: 796] ------------------ 2801| 1.19k| if(0 != encoder->private_->md5_fifo.data[i]) { ------------------ | Branch (2801:8): [True: 1.19k, False: 0] ------------------ 2802| 1.19k| free(encoder->private_->md5_fifo.data[i]); 2803| 1.19k| encoder->private_->md5_fifo.data[i] = 0; 2804| 1.19k| } 2805| 1.19k| } 2806| 796| } 2807| | 2808| 796| } 2809| 9.82k|#endif 2810| 9.82k| if(encoder->protected_->verify) { ------------------ | Branch (2810:5): [True: 8.73k, False: 1.08k] ------------------ 2811| 23.6k| for(i = 0; i < encoder->protected_->channels; i++) { ------------------ | Branch (2811:14): [True: 14.9k, False: 8.73k] ------------------ 2812| 14.9k| if(0 != encoder->private_->verify.input_fifo.data[i]) { ------------------ | Branch (2812:7): [True: 14.9k, False: 0] ------------------ 2813| 14.9k| free(encoder->private_->verify.input_fifo.data[i]); 2814| 14.9k| encoder->private_->verify.input_fifo.data[i] = 0; 2815| 14.9k| } 2816| 14.9k| } 2817| 8.73k| } 2818| 9.82k|} stream_encoder.c:resize_buffers_: 2821| 18.7k|{ 2822| 18.7k| FLAC__bool ok; 2823| 18.7k| uint32_t i, t, channel; 2824| | 2825| 18.7k| FLAC__ASSERT(new_blocksize > 0); ------------------ | | 38| 18.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.7k] | | ------------------ ------------------ 2826| 18.7k| FLAC__ASSERT(encoder->protected_->state == FLAC__STREAM_ENCODER_OK); ------------------ | | 38| 18.7k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 18.7k] | | ------------------ ------------------ 2827| | 2828| 18.7k| ok = true; 2829| | 2830| | /* To avoid excessive malloc'ing, we only grow the buffer; no shrinking. */ 2831| 18.7k| if(new_blocksize > encoder->private_->input_capacity) { ------------------ | Branch (2831:5): [True: 9.82k, False: 8.95k] ------------------ 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.82k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2839| 9.82k| if(ok && encoder->protected_->max_lpc_order > 0) { ------------------ | Branch (2839:6): [True: 9.82k, False: 0] | Branch (2839:12): [True: 8.42k, False: 1.40k] ------------------ 2840| 29.6k| for(i = 0; ok && i < encoder->protected_->num_apodizations; i++) ------------------ | Branch (2840:15): [True: 29.6k, False: 0] | Branch (2840:21): [True: 21.2k, False: 8.42k] ------------------ 2841| 21.2k| ok = ok && FLAC__memory_alloc_aligned_real_array(new_blocksize, &encoder->private_->window_unaligned[i], &encoder->private_->window[i]); ------------------ | Branch (2841:10): [True: 21.2k, False: 0] | Branch (2841:16): [True: 21.2k, False: 0] ------------------ 2842| 8.42k| } 2843| 9.82k|#endif 2844| 33.0k| for(t = 0; t < encoder->private_->num_threadtasks; t++) { ------------------ | Branch (2844:14): [True: 23.2k, False: 9.82k] ------------------ 2845| 61.2k| for(i = 0; ok && i < encoder->protected_->channels; i++) { ------------------ | Branch (2845:15): [True: 61.2k, False: 0] | Branch (2845:21): [True: 37.9k, False: 23.2k] ------------------ 2846| 37.9k| 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: 37.9k, False: 0] | Branch (2846:16): [True: 37.9k, False: 0] ------------------ 2847| 37.9k| if(ok) { ------------------ | Branch (2847:8): [True: 37.9k, False: 0] ------------------ 2848| 37.9k| memset(encoder->private_->threadtask[t]->integer_signal[i], 0, sizeof(FLAC__int32)*4); 2849| 37.9k| encoder->private_->threadtask[t]->integer_signal[i] += 4; 2850| 37.9k| } 2851| 37.9k| } 2852| 69.7k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2852:15): [True: 69.7k, False: 0] | Branch (2852:21): [True: 46.4k, False: 23.2k] ------------------ 2853| 46.4k| 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: 46.4k, False: 0] | Branch (2853:16): [True: 46.4k, False: 0] ------------------ 2854| 46.4k| if(ok) { ------------------ | Branch (2854:8): [True: 46.4k, False: 0] ------------------ 2855| 46.4k| memset(encoder->private_->threadtask[t]->integer_signal_mid_side[i], 0, sizeof(FLAC__int32)*4); 2856| 46.4k| encoder->private_->threadtask[t]->integer_signal_mid_side[i] += 4; 2857| 46.4k| } 2858| 46.4k| } 2859| 23.2k| 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: 23.2k, False: 0] | Branch (2859:15): [True: 23.2k, False: 0] ------------------ 2860| 23.2k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2861| 23.2k| if(ok && encoder->protected_->max_lpc_order > 0) { ------------------ | Branch (2861:7): [True: 23.2k, False: 0] | Branch (2861:13): [True: 15.5k, False: 7.73k] ------------------ 2862| 15.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: 15.5k, False: 0] | Branch (2862:16): [True: 15.5k, False: 0] ------------------ 2863| 15.5k| } 2864| 23.2k|#endif 2865| 61.2k| for(channel = 0; ok && channel < encoder->protected_->channels; channel++) { ------------------ | Branch (2865:21): [True: 61.2k, False: 0] | Branch (2865:27): [True: 37.9k, False: 23.2k] ------------------ 2866| 113k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2866:16): [True: 113k, False: 0] | Branch (2866:22): [True: 75.9k, False: 37.9k] ------------------ 2867| 75.9k| 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: 75.9k, False: 0] | Branch (2867:17): [True: 75.9k, False: 0] ------------------ 2868| 75.9k| } 2869| 37.9k| } 2870| | 2871| | 2872| 61.2k| for(channel = 0; ok && channel < encoder->protected_->channels; channel++) { ------------------ | Branch (2872:21): [True: 61.2k, False: 0] | Branch (2872:27): [True: 37.9k, False: 23.2k] ------------------ 2873| 113k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2873:16): [True: 113k, False: 0] | Branch (2873:22): [True: 75.9k, False: 37.9k] ------------------ 2874| 75.9k| 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: 75.9k, False: 0] | Branch (2874:17): [True: 75.9k, False: 0] ------------------ 2875| 75.9k| 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: 75.9k, False: 0] | Branch (2875:17): [True: 75.9k, False: 0] ------------------ 2876| 75.9k| } 2877| 37.9k| } 2878| | 2879| 69.7k| for(channel = 0; ok && channel < 2; channel++) { ------------------ | Branch (2879:21): [True: 69.7k, False: 0] | Branch (2879:27): [True: 46.4k, False: 23.2k] ------------------ 2880| 139k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2880:16): [True: 139k, False: 0] | Branch (2880:22): [True: 92.9k, False: 46.4k] ------------------ 2881| 92.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: 92.9k, False: 0] | Branch (2881:17): [True: 92.9k, False: 0] ------------------ 2882| 92.9k| } 2883| 46.4k| } 2884| | 2885| 69.7k| for(channel = 0; ok && channel < 2; channel++) { ------------------ | Branch (2885:21): [True: 69.7k, False: 0] | Branch (2885:27): [True: 46.4k, False: 23.2k] ------------------ 2886| 139k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2886:16): [True: 139k, False: 0] | Branch (2886:22): [True: 92.9k, False: 46.4k] ------------------ 2887| 92.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: 92.9k, False: 0] | Branch (2887:17): [True: 92.9k, False: 0] ------------------ 2888| 92.9k| } 2889| 46.4k| } 2890| | 2891| 69.7k| for(i = 0; ok && i < 2; i++) { ------------------ | Branch (2891:15): [True: 69.7k, False: 0] | Branch (2891:21): [True: 46.4k, False: 23.2k] ------------------ 2892| 46.4k| 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: 46.4k, False: 0] | Branch (2892:16): [True: 46.4k, False: 0] ------------------ 2893| 46.4k| } 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| 23.2k| 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: 23.2k, False: 0] | Branch (2898:15): [True: 23.2k, False: 0] ------------------ 2899| 23.2k| if(encoder->protected_->do_escape_coding) ------------------ | Branch (2899:7): [True: 15.4k, False: 7.79k] ------------------ 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| 23.2k| } 2902| 9.82k|} 2903| 18.7k| if(ok) ------------------ | Branch (2903:5): [True: 18.7k, False: 0] ------------------ 2904| 18.7k| 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| 18.7k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 2913| 18.7k| if(encoder->protected_->max_lpc_order > 0 && new_blocksize > 1) { ------------------ | Branch (2913:5): [True: 16.0k, False: 2.68k] | Branch (2913:47): [True: 15.2k, False: 820] ------------------ 2914| 54.2k| for(i = 0; i < encoder->protected_->num_apodizations; i++) { ------------------ | Branch (2914:14): [True: 38.9k, False: 15.2k] ------------------ 2915| 38.9k| switch(encoder->protected_->apodizations[i].type) { 2916| 765| case FLAC__APODIZATION_BARTLETT: ------------------ | Branch (2916:5): [True: 765, False: 38.2k] ------------------ 2917| 765| FLAC__window_bartlett(encoder->private_->window[i], new_blocksize); 2918| 765| break; 2919| 93| case FLAC__APODIZATION_BARTLETT_HANN: ------------------ | Branch (2919:5): [True: 93, False: 38.8k] ------------------ 2920| 93| FLAC__window_bartlett_hann(encoder->private_->window[i], new_blocksize); 2921| 93| break; 2922| 115| case FLAC__APODIZATION_BLACKMAN: ------------------ | Branch (2922:5): [True: 115, False: 38.8k] ------------------ 2923| 115| FLAC__window_blackman(encoder->private_->window[i], new_blocksize); 2924| 115| break; 2925| 91| case FLAC__APODIZATION_BLACKMAN_HARRIS_4TERM_92DB_SIDELOBE: ------------------ | Branch (2925:5): [True: 91, False: 38.8k] ------------------ 2926| 91| FLAC__window_blackman_harris_4term_92db_sidelobe(encoder->private_->window[i], new_blocksize); 2927| 91| break; 2928| 220| case FLAC__APODIZATION_CONNES: ------------------ | Branch (2928:5): [True: 220, False: 38.7k] ------------------ 2929| 220| FLAC__window_connes(encoder->private_->window[i], new_blocksize); 2930| 220| break; 2931| 143| case FLAC__APODIZATION_FLATTOP: ------------------ | Branch (2931:5): [True: 143, False: 38.8k] ------------------ 2932| 143| FLAC__window_flattop(encoder->private_->window[i], new_blocksize); 2933| 143| break; 2934| 192| case FLAC__APODIZATION_GAUSS: ------------------ | Branch (2934:5): [True: 192, False: 38.7k] ------------------ 2935| 192| FLAC__window_gauss(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.gauss.stddev); 2936| 192| break; 2937| 310| case FLAC__APODIZATION_HAMMING: ------------------ | Branch (2937:5): [True: 310, False: 38.6k] ------------------ 2938| 310| FLAC__window_hamming(encoder->private_->window[i], new_blocksize); 2939| 310| break; 2940| 580| case FLAC__APODIZATION_HANN: ------------------ | Branch (2940:5): [True: 580, False: 38.3k] ------------------ 2941| 580| FLAC__window_hann(encoder->private_->window[i], new_blocksize); 2942| 580| break; 2943| 107| case FLAC__APODIZATION_KAISER_BESSEL: ------------------ | Branch (2943:5): [True: 107, False: 38.8k] ------------------ 2944| 107| FLAC__window_kaiser_bessel(encoder->private_->window[i], new_blocksize); 2945| 107| break; 2946| 111| case FLAC__APODIZATION_NUTTALL: ------------------ | Branch (2946:5): [True: 111, False: 38.8k] ------------------ 2947| 111| FLAC__window_nuttall(encoder->private_->window[i], new_blocksize); 2948| 111| break; 2949| 229| case FLAC__APODIZATION_RECTANGLE: ------------------ | Branch (2949:5): [True: 229, False: 38.7k] ------------------ 2950| 229| FLAC__window_rectangle(encoder->private_->window[i], new_blocksize); 2951| 229| break; 2952| 756| case FLAC__APODIZATION_TRIANGLE: ------------------ | Branch (2952:5): [True: 756, False: 38.2k] ------------------ 2953| 756| FLAC__window_triangle(encoder->private_->window[i], new_blocksize); 2954| 756| break; 2955| 12.8k| case FLAC__APODIZATION_TUKEY: ------------------ | Branch (2955:5): [True: 12.8k, False: 26.1k] ------------------ 2956| 12.8k| FLAC__window_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.tukey.p); 2957| 12.8k| break; 2958| 8.60k| case FLAC__APODIZATION_PARTIAL_TUKEY: ------------------ | Branch (2958:5): [True: 8.60k, False: 30.3k] ------------------ 2959| 8.60k| 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| 8.60k| break; 2961| 10.1k| case FLAC__APODIZATION_PUNCHOUT_TUKEY: ------------------ | Branch (2961:5): [True: 10.1k, False: 28.7k] ------------------ 2962| 10.1k| 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| 10.1k| break; 2964| 3.41k| case FLAC__APODIZATION_SUBDIVIDE_TUKEY: ------------------ | Branch (2964:5): [True: 3.41k, False: 35.5k] ------------------ 2965| 3.41k| FLAC__window_tukey(encoder->private_->window[i], new_blocksize, encoder->protected_->apodizations[i].parameters.tukey.p); 2966| 3.41k| break; 2967| 251| case FLAC__APODIZATION_WELCH: ------------------ | Branch (2967:5): [True: 251, False: 38.7k] ------------------ 2968| 251| FLAC__window_welch(encoder->private_->window[i], new_blocksize); 2969| 251| break; 2970| 0| default: ------------------ | Branch (2970:5): [True: 0, False: 38.9k] ------------------ 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| 38.9k| } 2976| 38.9k| } 2977| 15.2k| } 2978| 18.7k| if (new_blocksize <= FLAC__MAX_LPC_ORDER) { ------------------ | | 128| 18.7k|#define FLAC__MAX_LPC_ORDER (32u) ------------------ | Branch (2978:6): [True: 8.66k, False: 10.1k] ------------------ 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.66k| encoder->private_->local_lpc_compute_autocorrelation = FLAC__lpc_compute_autocorrelation; 2982| 8.66k| } 2983| 18.7k|#endif 2984| | 2985| | return true; 2986| 18.7k|} stream_encoder.c:write_bitbuffer_: 2989| 296k|{ 2990| 296k| const FLAC__byte *buffer; 2991| 296k| size_t bytes; 2992| | 2993| 296k| FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(threadtask->frame)); ------------------ | | 38| 296k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 296k] | | ------------------ ------------------ 2994| | 2995| 296k| if(!FLAC__bitwriter_get_buffer(threadtask->frame, &buffer, &bytes)) { ------------------ | Branch (2995:5): [True: 0, False: 296k] ------------------ 2996| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR; 2997| 0| return false; 2998| 0| } 2999| | 3000| 296k| if(encoder->protected_->verify) { ------------------ | Branch (3000:5): [True: 242k, False: 54.5k] ------------------ 3001| 242k| encoder->private_->verify.output.data = buffer; 3002| 242k| encoder->private_->verify.output.bytes = bytes; 3003| 242k| if(encoder->private_->verify.state_hint == ENCODER_IN_MAGIC) { ------------------ | Branch (3003:6): [True: 8.73k, False: 233k] ------------------ 3004| 8.73k| encoder->private_->verify.needs_magic_hack = true; 3005| 8.73k| } 3006| 233k| else { 3007| 233k| if(!FLAC__stream_decoder_process_single(encoder->private_->verify.decoder) ------------------ | Branch (3007:7): [True: 0, False: 233k] ------------------ 3008| 233k| || (!is_last_block ------------------ | Branch (3008:12): [True: 225k, False: 8.21k] ------------------ 3009| 225k| && (FLAC__stream_encoder_get_verify_decoder_state(encoder) == FLAC__STREAM_DECODER_END_OF_STREAM)) ------------------ | Branch (3009:12): [True: 0, False: 225k] ------------------ 3010| 233k| || encoder->protected_->state == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR /* Happens when error callback was used */) { ------------------ | Branch (3010:11): [True: 0, False: 233k] ------------------ 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| 233k| } 3018| 242k| } 3019| | 3020| 296k| if(write_frame_(encoder, buffer, bytes, samples, is_last_block) != FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { ------------------ | Branch (3020:5): [True: 0, False: 296k] ------------------ 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| 296k| FLAC__bitwriter_release_buffer(threadtask->frame); 3028| 296k| FLAC__bitwriter_clear(threadtask->frame); 3029| | 3030| 296k| if(samples > 0) { ------------------ | Branch (3030:5): [True: 267k, False: 29.4k] ------------------ 3031| 267k| encoder->private_->streaminfo.data.stream_info.min_framesize = flac_min(bytes, encoder->private_->streaminfo.data.stream_info.min_framesize); ------------------ | | 56| 267k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (3031:66): [True: 12.7k, False: 254k] ------------------ 3032| 267k| encoder->private_->streaminfo.data.stream_info.max_framesize = flac_max(bytes, encoder->private_->streaminfo.data.stream_info.max_framesize); ------------------ | | 55| 267k|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (3032:66): [True: 10.9k, False: 256k] ------------------ 3033| 267k| } 3034| | 3035| | return true; 3036| 296k|} stream_encoder.c:write_frame_: 3039| 296k|{ 3040| 296k| FLAC__StreamEncoderWriteStatus status; 3041| 296k| 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| 296k| if(samples == 0) { ------------------ | Branch (3050:5): [True: 29.4k, False: 267k] ------------------ 3051| 29.4k| 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| 29.4k| 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: 29.4k, False: 0] | Branch (3054:42): [True: 0, False: 29.4k] ------------------ 3055| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3056| 0| return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; 3057| 0| } 3058| | 3059| 29.4k| if(type == FLAC__METADATA_TYPE_STREAMINFO) ------------------ | Branch (3059:6): [True: 9.82k, False: 19.6k] ------------------ 3060| 9.82k| encoder->protected_->streaminfo_offset = output_position; 3061| 19.6k| else if(type == FLAC__METADATA_TYPE_SEEKTABLE && encoder->protected_->seektable_offset == 0) ------------------ | Branch (3061:11): [True: 0, False: 19.6k] | Branch (3061:52): [True: 0, False: 0] ------------------ 3062| 0| encoder->protected_->seektable_offset = output_position; 3063| 29.4k| } 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| 296k| if(0 != encoder->private_->seek_table && encoder->protected_->audio_offset > 0 && encoder->private_->seek_table->num_points > 0) { ------------------ | Branch (3070:5): [True: 0, False: 296k] | 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| 296k|#if FLAC__HAS_OGG 3106| 296k| if(encoder->private_->is_ogg) { ------------------ | Branch (3106:5): [True: 170k, False: 126k] ------------------ 3107| 170k| status = FLAC__ogg_encoder_aspect_write_callback_wrapper( 3108| 170k| &encoder->protected_->ogg_encoder_aspect, 3109| 170k| buffer, 3110| 170k| bytes, 3111| 170k| samples, 3112| 170k| encoder->private_->current_frame_number, 3113| 170k| is_last_block, 3114| 170k| (FLAC__OggEncoderAspectWriteCallbackProxy)encoder->private_->write_callback, 3115| 170k| encoder, 3116| 170k| encoder->private_->client_data 3117| 170k| ); 3118| 170k| } 3119| 126k| else 3120| 126k|#endif 3121| 126k| status = encoder->private_->write_callback(encoder, buffer, bytes, samples, encoder->private_->current_frame_number, encoder->private_->client_data); 3122| | 3123| 296k| if(status == FLAC__STREAM_ENCODER_WRITE_STATUS_OK) { ------------------ | Branch (3123:5): [True: 296k, False: 0] ------------------ 3124| 296k| encoder->private_->bytes_written += bytes; 3125| 296k| 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| 296k| encoder->private_->frames_written = flac_max(encoder->private_->frames_written, encoder->private_->current_frame_number+1); ------------------ | | 55| 296k|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (3130:39): [True: 0, False: 296k] ------------------ 3131| 296k| } 3132| 0| else 3133| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3134| | 3135| 296k| return status; 3136| 296k|} stream_encoder.c:update_metadata_: 3140| 6.67k|{ 3141| 6.67k| FLAC__byte b[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)]; 3142| 6.67k| const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo; 3143| 6.67k| FLAC__uint64 samples = metadata->data.stream_info.total_samples; 3144| 6.67k| const uint32_t min_framesize = metadata->data.stream_info.min_framesize; 3145| 6.67k| const uint32_t max_framesize = metadata->data.stream_info.max_framesize; 3146| 6.67k| const uint32_t bps = metadata->data.stream_info.bits_per_sample; 3147| 6.67k| FLAC__StreamEncoderSeekStatus seek_status; 3148| | 3149| 6.67k| FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO); ------------------ | | 38| 6.67k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.67k] | | ------------------ ------------------ 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.67k| { 3160| 6.67k| const uint32_t md5_offset = 3161| 6.67k| FLAC__STREAM_METADATA_HEADER_LENGTH + ------------------ | | 872| 6.67k|#define FLAC__STREAM_METADATA_HEADER_LENGTH (4u) ------------------ 3162| 6.67k| ( 3163| 6.67k| FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN + 3164| 6.67k| FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN + 3165| 6.67k| FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN + 3166| 6.67k| FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN + 3167| 6.67k| FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN + 3168| 6.67k| FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN + 3169| 6.67k| FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN + 3170| 6.67k| FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN 3171| 6.67k| ) / 8; 3172| | 3173| 6.67k| 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.67k, False: 0] ------------------ 3174| 6.67k| if(seek_status == FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR) ------------------ | Branch (3174:7): [True: 0, False: 6.67k] ------------------ 3175| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_CLIENT_ERROR; 3176| 6.67k| return; 3177| 6.67k| } 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| 3.09k|{ 3305| | /* the # of bytes in the 1st packet that precede the STREAMINFO */ 3306| 3.09k| static const uint32_t FIRST_OGG_PACKET_STREAMINFO_PREFIX_LENGTH = 3307| 3.09k| FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH + ------------------ | | 39| 3.09k|#define FLAC__OGG_MAPPING_PACKET_TYPE_LENGTH (1u) ------------------ 3308| 3.09k| FLAC__OGG_MAPPING_MAGIC_LENGTH + ------------------ | | 46| 3.09k|#define FLAC__OGG_MAPPING_MAGIC_LENGTH (4u) ------------------ 3309| 3.09k| FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH + ------------------ | | 54| 3.09k|#define FLAC__OGG_MAPPING_VERSION_MAJOR_LENGTH (1u) ------------------ 3310| 3.09k| FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH + ------------------ | | 57| 3.09k|#define FLAC__OGG_MAPPING_VERSION_MINOR_LENGTH (1u) ------------------ 3311| 3.09k| FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH + ------------------ | | 62| 3.09k|#define FLAC__OGG_MAPPING_NUM_HEADERS_LENGTH (2u) ------------------ 3312| 3.09k| FLAC__STREAM_SYNC_LENGTH ------------------ | | 179| 3.09k|#define FLAC__STREAM_SYNC_LENGTH (4u) ------------------ 3313| 3.09k| ; 3314| 3.09k| FLAC__byte b[flac_max(6u, FLAC__STREAM_METADATA_SEEKPOINT_LENGTH)]; 3315| 3.09k| const FLAC__StreamMetadata *metadata = &encoder->private_->streaminfo; 3316| 3.09k| const FLAC__uint64 samples = metadata->data.stream_info.total_samples; 3317| 3.09k| const uint32_t min_framesize = metadata->data.stream_info.min_framesize; 3318| 3.09k| const uint32_t max_framesize = metadata->data.stream_info.max_framesize; 3319| 3.09k| ogg_page page; 3320| | 3321| 3.09k| FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO); ------------------ | | 38| 3.09k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.09k] | | ------------------ ------------------ 3322| 3.09k| FLAC__ASSERT(0 != encoder->private_->seek_callback); ------------------ | | 38| 3.09k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 3.09k] | | ------------------ ------------------ 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| 3.09k| if(encoder->private_->seek_callback(encoder, 0, encoder->private_->client_data) == FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED) ------------------ | Branch (3327:5): [True: 3.09k, False: 0] ------------------ 3328| 3.09k| 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| 267k|{ 3437| 267k| FLAC__uint16 crc; 3438| 267k|#ifdef FLAC__USE_THREADS 3439| 267k| uint32_t i; 3440| 267k|#endif 3441| 267k| if(encoder->protected_->num_threads < 2 || is_last_block) { ------------------ | Branch (3441:5): [True: 138k, False: 129k] | Branch (3441:45): [True: 729, False: 128k] ------------------ 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| 128k| else { 3491| 128k|#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| 128k| if(encoder->private_->num_created_threads < encoder->protected_->num_threads) { ------------------ | Branch (3524:6): [True: 2.85k, False: 125k] ------------------ 3525| | /* Create a new thread */ 3526| 2.85k| FLAC__thrd_create(&encoder->private_->thread[encoder->private_->next_thread], ------------------ | | 98| 2.85k|#define FLAC__thrd_create(thread, func, arg) pthread_create(thread, NULL, func, arg) ------------------ 3527| 2.85k| process_frame_thread_, encoder); 3528| 2.85k| encoder->private_->num_created_threads++; 3529| 2.85k| } 3530| 125k| else if(encoder->private_->num_started_threadtasks == encoder->private_->num_threadtasks) { ------------------ | Branch (3530:11): [True: 122k, False: 2.93k] ------------------ 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| 122k| int mutex_result = (FLAC__mtx_trylock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task) == FLAC__thrd_success) ? 0 : 1; ------------------ | | 104| 122k|#define FLAC__mtx_trylock(mutex) ((pthread_mutex_trylock(mutex) == 0) ? FLAC__thrd_success : FLAC__thrd_busy) | | ------------------ | | | | 93| 115k|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__mtx_trylock(mutex) ((pthread_mutex_trylock(mutex) == 0) ? FLAC__thrd_success : FLAC__thrd_busy) | | ------------------ | | | | 94| 122k|#define FLAC__thrd_busy EBUSY | | ------------------ | | | Branch (104:47): [True: 115k, False: 7.06k] | | ------------------ ------------------ int mutex_result = (FLAC__mtx_trylock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task) == FLAC__thrd_success) ? 0 : 1; ------------------ | | 93| 122k|#define FLAC__thrd_success 0 ------------------ | Branch (3537:23): [True: 115k, False: 7.06k] ------------------ 3538| 138k| while(mutex_result || !encoder->private_->threadtask[encoder->private_->next_thread]->task_done) { ------------------ | Branch (3538:10): [True: 9.31k, False: 129k] | Branch (3538:26): [True: 6.81k, False: 122k] ------------------ 3539| 16.1k| if(!mutex_result) ------------------ | Branch (3539:8): [True: 6.81k, False: 9.31k] ------------------ 3540| 6.81k| FLAC__mtx_unlock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 106| 6.81k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3541| | 3542| 16.1k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 16.1k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3543| 16.1k| if(encoder->private_->num_available_threadtasks > (encoder->protected_->num_threads - 1)) { ------------------ | Branch (3543:8): [True: 15.4k, False: 710] ------------------ 3544| 15.4k| FLAC__StreamEncoderThreadTask * task = NULL; 3545| 15.4k| task = encoder->private_->threadtask[encoder->private_->next_threadtask]; 3546| 15.4k| encoder->private_->num_available_threadtasks--; 3547| 15.4k| encoder->private_->next_threadtask++; 3548| 15.4k| if(encoder->private_->next_threadtask == encoder->private_->num_threadtasks) ------------------ | Branch (3548:9): [True: 2.51k, False: 12.9k] ------------------ 3549| 2.51k| encoder->private_->next_threadtask = 1; 3550| 15.4k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 15.4k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3551| 15.4k| FLAC__mtx_lock(&task->mutex_this_task); ------------------ | | 105| 15.4k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3552| 15.4k| process_frame_thread_inner_(encoder, task); 3553| 15.4k| mutex_result = (FLAC__mtx_trylock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task) == FLAC__thrd_success) ? 0 : 1; ------------------ | | 104| 15.4k|#define FLAC__mtx_trylock(mutex) ((pthread_mutex_trylock(mutex) == 0) ? FLAC__thrd_success : FLAC__thrd_busy) | | ------------------ | | | | 93| 13.1k|#define FLAC__thrd_success 0 | | ------------------ | | #define FLAC__mtx_trylock(mutex) ((pthread_mutex_trylock(mutex) == 0) ? FLAC__thrd_success : FLAC__thrd_busy) | | ------------------ | | | | 94| 15.4k|#define FLAC__thrd_busy EBUSY | | ------------------ | | | Branch (104:47): [True: 13.1k, False: 2.25k] | | ------------------ ------------------ mutex_result = (FLAC__mtx_trylock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task) == FLAC__thrd_success) ? 0 : 1; ------------------ | | 93| 15.4k|#define FLAC__thrd_success 0 ------------------ | Branch (3553:21): [True: 13.1k, False: 2.25k] ------------------ 3554| 15.4k| } 3555| 710| else { 3556| 710| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 710|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3557| 710| FLAC__mtx_lock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 105| 710|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3558| 714| while(!encoder->private_->threadtask[encoder->private_->next_thread]->task_done) ------------------ | Branch (3558:12): [True: 4, False: 710] ------------------ 3559| 4| FLAC__cnd_wait(&encoder->private_->threadtask[encoder->private_->next_thread]->cond_task_done,&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 113| 4|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 3560| 710| mutex_result = 0; 3561| 710| } 3562| 16.1k| } 3563| | /* Task is finished, write bitbuffer */ 3564| 122k| if(!encoder->private_->threadtask[encoder->private_->next_thread]->returnvalue) { ------------------ | Branch (3564:7): [True: 0, False: 122k] ------------------ 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| 122k| if(!write_bitbuffer_(encoder, encoder->private_->threadtask[encoder->private_->next_thread], encoder->protected_->blocksize, is_last_block)) { ------------------ | Branch (3568:7): [True: 0, False: 122k] ------------------ 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| 122k| FLAC__mtx_unlock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 106| 122k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3574| 122k| } 3575| | /* Copy input data for MD5 calculation */ 3576| 128k| if(encoder->protected_->do_md5) { ------------------ | Branch (3576:6): [True: 128k, False: 0] ------------------ 3577| 128k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 128k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3578| 129k| while(encoder->private_->md5_fifo.tail + encoder->protected_->blocksize > encoder->private_->md5_fifo.size) { ------------------ | Branch (3578:10): [True: 484, False: 128k] ------------------ 3579| 484| FLAC__cnd_wait(&encoder->private_->cond_md5_emptied,&encoder->private_->mutex_work_queue); ------------------ | | 113| 484|#define FLAC__cnd_wait(cv, mutex) pthread_cond_wait(cv, mutex) ------------------ 3580| 484| } 3581| 128k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 128k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3582| 128k| FLAC__mtx_lock(&encoder->private_->mutex_md5_fifo); ------------------ | | 105| 128k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3583| 263k| for(i = 0; i < encoder->protected_->channels; i++) ------------------ | Branch (3583:15): [True: 134k, False: 128k] ------------------ 3584| 134k| 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| 128k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 128k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3586| 128k| encoder->private_->md5_fifo.tail += encoder->protected_->blocksize; 3587| 128k| FLAC__cnd_signal(&encoder->private_->cond_work_available); ------------------ | | 112| 128k|#define FLAC__cnd_signal(cv) pthread_cond_signal(cv) ------------------ 3588| 128k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 128k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3589| 128k| FLAC__mtx_unlock(&encoder->private_->mutex_md5_fifo); ------------------ | | 106| 128k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3590| 128k| } 3591| | 3592| | /* Copy input data for frame creation */ 3593| 128k| FLAC__mtx_lock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 105| 128k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3594| 263k| for(i = 0; i < encoder->protected_->channels; i++) ------------------ | Branch (3594:14): [True: 134k, False: 128k] ------------------ 3595| 134k| 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| 128k| encoder->private_->threadtask[encoder->private_->next_thread]->current_frame_number = encoder->private_->current_frame_number; 3598| 128k| FLAC__mtx_unlock(&encoder->private_->threadtask[encoder->private_->next_thread]->mutex_this_task); ------------------ | | 106| 128k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3599| | 3600| 128k| FLAC__mtx_lock(&encoder->private_->mutex_work_queue); ------------------ | | 105| 128k|#define FLAC__mtx_lock(mutex) pthread_mutex_lock(mutex) ------------------ 3601| 128k| if(encoder->private_->num_started_threadtasks < encoder->private_->num_threadtasks) ------------------ | Branch (3601:6): [True: 5.79k, False: 122k] ------------------ 3602| 5.79k| encoder->private_->num_started_threadtasks++; 3603| 128k| encoder->private_->num_available_threadtasks++; 3604| 128k| encoder->private_->threadtask[encoder->private_->next_thread]->task_done = false; 3605| 128k| FLAC__cnd_signal(&encoder->private_->cond_work_available); ------------------ | | 112| 128k|#define FLAC__cnd_signal(cv) pthread_cond_signal(cv) ------------------ 3606| 128k| FLAC__mtx_unlock(&encoder->private_->mutex_work_queue); ------------------ | | 106| 128k|#define FLAC__mtx_unlock(mutex) pthread_mutex_unlock(mutex) ------------------ 3607| | 3608| 128k| encoder->private_->next_thread++; 3609| 128k| if(encoder->private_->next_thread == encoder->private_->num_threadtasks) ------------------ | Branch (3609:6): [True: 14.5k, False: 114k] ------------------ 3610| 14.5k| encoder->private_->next_thread = 1; 3611| |#else 3612| | FLAC__ASSERT(0); 3613| |#endif 3614| 128k| } 3615| | 3616| | /* 3617| | * Get ready for the next frame 3618| | */ 3619| 267k| encoder->private_->current_sample_number = 0; 3620| 267k| encoder->private_->current_frame_number++; 3621| 267k| encoder->private_->streaminfo.data.stream_info.total_samples += (FLAC__uint64)encoder->protected_->blocksize; 3622| | 3623| | return true; 3624| 267k|} stream_encoder.c:process_subframes_: 3748| 267k|{ 3749| 267k| FLAC__FrameHeader frame_header; 3750| 267k| uint32_t channel, min_partition_order = encoder->protected_->min_residual_partition_order, max_partition_order; 3751| 267k| FLAC__bool do_independent, do_mid_side, all_subframes_constant = true; 3752| | 3753| 267k| threadtask->disable_constant_subframes = encoder->private_->disable_constant_subframes; 3754| | 3755| | /* 3756| | * Calculate the min,max Rice partition orders 3757| | */ 3758| | 3759| 267k| max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize(encoder->protected_->blocksize); 3760| 267k| max_partition_order = flac_min(max_partition_order, encoder->protected_->max_residual_partition_order); ------------------ | | 56| 267k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (3760:24): [True: 179k, False: 88.0k] ------------------ 3761| 267k| min_partition_order = flac_min(min_partition_order, max_partition_order); ------------------ | | 56| 267k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (3761:24): [True: 46.9k, False: 220k] ------------------ 3762| | 3763| | /* 3764| | * Setup the frame 3765| | */ 3766| 267k| frame_header.blocksize = encoder->protected_->blocksize; 3767| 267k| frame_header.sample_rate = encoder->protected_->sample_rate; 3768| 267k| frame_header.channels = encoder->protected_->channels; 3769| 267k| frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; /* the default unless the encoder determines otherwise */ 3770| 267k| frame_header.bits_per_sample = encoder->protected_->bits_per_sample; 3771| 267k| frame_header.number_type = FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER; 3772| 267k| frame_header.number.frame_number = threadtask->current_frame_number; 3773| | 3774| | /* 3775| | * Figure out what channel assignments to try 3776| | */ 3777| 267k| if(encoder->protected_->do_mid_side_stereo) { ------------------ | Branch (3777:5): [True: 44.2k, False: 223k] ------------------ 3778| 44.2k| if(encoder->protected_->loose_mid_side_stereo) { ------------------ | Branch (3778:6): [True: 3.05k, False: 41.2k] ------------------ 3779| 3.05k| uint64_t sumAbsLR = 0, sumAbsMS = 0; 3780| 3.05k| uint32_t i; 3781| 3.05k| if(encoder->protected_->bits_per_sample < 25) { ------------------ | Branch (3781:7): [True: 1.13k, False: 1.91k] ------------------ 3782| 66.3k| for(i = 1; i < encoder->protected_->blocksize; i++) { ------------------ | Branch (3782:16): [True: 65.1k, False: 1.13k] ------------------ 3783| 65.1k| int32_t predictionLeft = threadtask->integer_signal[0][i] - threadtask->integer_signal[0][i-1]; 3784| 65.1k| int32_t predictionRight = threadtask->integer_signal[1][i] - threadtask->integer_signal[1][i-1]; 3785| 65.1k| sumAbsLR += abs(predictionLeft) + abs(predictionRight); 3786| 65.1k| sumAbsMS += abs((predictionLeft + predictionRight) >> 1) + abs(predictionLeft - predictionRight); 3787| 65.1k| } 3788| 1.13k| } 3789| 1.91k| else { /* bps 25 or higher */ 3790| 1.74M| for(i = 1; i < encoder->protected_->blocksize; i++) { ------------------ | Branch (3790:16): [True: 1.73M, False: 1.91k] ------------------ 3791| 1.73M| int64_t predictionLeft = (int64_t)threadtask->integer_signal[0][i] - (int64_t)threadtask->integer_signal[0][i-1]; 3792| 1.73M| int64_t predictionRight = (int64_t)threadtask->integer_signal[1][i] - (int64_t)threadtask->integer_signal[1][i-1]; 3793| 1.73M| sumAbsLR += local_abs64(predictionLeft) + local_abs64(predictionRight); ------------------ | | 87| 1.73M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (87:36): [True: 60.3k, False: 1.67M] | | ------------------ ------------------ sumAbsLR += local_abs64(predictionLeft) + local_abs64(predictionRight); ------------------ | | 87| 1.73M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (87:36): [True: 60.9k, False: 1.67M] | | ------------------ ------------------ 3794| 1.73M| sumAbsMS += local_abs64((predictionLeft + predictionRight) >> 1) + local_abs64(predictionLeft - predictionRight); ------------------ | | 87| 1.73M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (87:36): [True: 69.0k, False: 1.66M] | | ------------------ ------------------ sumAbsMS += local_abs64((predictionLeft + predictionRight) >> 1) + local_abs64(predictionLeft - predictionRight); ------------------ | | 87| 1.73M|#define local_abs64(x) ((uint64_t)((x)<0? -(x) : (x))) | | ------------------ | | | Branch (87:36): [True: 66.5k, False: 1.67M] | | ------------------ ------------------ 3795| 1.73M| } 3796| 1.91k| } 3797| 3.05k| if(sumAbsLR < sumAbsMS) { ------------------ | Branch (3797:7): [True: 814, False: 2.23k] ------------------ 3798| 814| do_independent = true; 3799| 814| do_mid_side = false; 3800| 814| frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; 3801| 814| } 3802| 2.23k| else { 3803| 2.23k| do_independent = false; 3804| 2.23k| do_mid_side = true; 3805| 2.23k| frame_header.channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE; 3806| 2.23k| } 3807| 3.05k| } 3808| 41.2k| else { 3809| 41.2k| do_independent = true; 3810| 41.2k| do_mid_side = true; 3811| 41.2k| } 3812| 44.2k| } 3813| 223k| else { 3814| 223k| do_independent = true; 3815| 223k| do_mid_side = false; 3816| 223k| } 3817| | 3818| 267k| FLAC__ASSERT(do_independent || do_mid_side); ------------------ | | 38| 269k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 265k, False: 2.23k] | | | Branch (38:30): [True: 2.23k, False: 0] | | ------------------ ------------------ 3819| | 3820| | /* 3821| | * Prepare mid-side signals if applicable 3822| | */ 3823| 267k| if(do_mid_side) { ------------------ | Branch (3823:5): [True: 43.4k, False: 224k] ------------------ 3824| 43.4k| uint32_t i; 3825| 43.4k| FLAC__ASSERT(encoder->protected_->channels == 2); ------------------ | | 38| 43.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.4k] | | ------------------ ------------------ 3826| 43.4k| if(encoder->protected_->bits_per_sample < 32) ------------------ | Branch (3826:6): [True: 12.2k, False: 31.2k] ------------------ 3827| 364k| for(i = 0; i < encoder->protected_->blocksize; i++) { ------------------ | Branch (3827:15): [True: 352k, False: 12.2k] ------------------ 3828| 352k| threadtask->integer_signal_mid_side[1][i] = threadtask->integer_signal[0][i] - threadtask->integer_signal[1][i]; 3829| 352k| 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| 352k| } 3831| 31.2k| else 3832| 4.33M| for(i = 0; i <= encoder->protected_->blocksize; i++) { ------------------ | Branch (3832:15): [True: 4.30M, False: 31.2k] ------------------ 3833| 4.30M| threadtask->integer_signal_33bit_side[i] = (FLAC__int64)threadtask->integer_signal[0][i] - (FLAC__int64)threadtask->integer_signal[1][i]; 3834| 4.30M| 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.30M| } 3836| 43.4k| } 3837| | 3838| | 3839| | /* 3840| | * Check for wasted bits; set effective bps for each subframe 3841| | */ 3842| 267k| if(do_independent) { ------------------ | Branch (3842:5): [True: 265k, False: 2.35k] ------------------ 3843| 598k| for(channel = 0; channel < encoder->protected_->channels; channel++) { ------------------ | Branch (3843:20): [True: 332k, False: 265k] ------------------ 3844| 332k| uint32_t w = get_wasted_bits_(threadtask->integer_signal[channel], encoder->protected_->blocksize); 3845| 332k| if (w > encoder->protected_->bits_per_sample) { ------------------ | Branch (3845:8): [True: 0, False: 332k] ------------------ 3846| 0| w = encoder->protected_->bits_per_sample; 3847| 0| } 3848| 332k| threadtask->subframe_workspace[channel][0].wasted_bits = threadtask->subframe_workspace[channel][1].wasted_bits = w; 3849| 332k| threadtask->subframe_bps[channel] = encoder->protected_->bits_per_sample - w; 3850| 332k| } 3851| 265k| } 3852| 267k| if(do_mid_side) { ------------------ | Branch (3852:5): [True: 43.4k, False: 224k] ------------------ 3853| 43.4k| FLAC__ASSERT(encoder->protected_->channels == 2); ------------------ | | 38| 43.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.4k] | | ------------------ ------------------ 3854| 130k| for(channel = 0; channel < 2; channel++) { ------------------ | Branch (3854:20): [True: 86.8k, False: 43.4k] ------------------ 3855| 86.8k| uint32_t w; 3856| 86.8k| if(encoder->protected_->bits_per_sample < 32 || channel == 0) ------------------ | Branch (3856:7): [True: 24.4k, False: 62.4k] | Branch (3856:52): [True: 31.2k, False: 31.2k] ------------------ 3857| 55.6k| w = get_wasted_bits_(threadtask->integer_signal_mid_side[channel], encoder->protected_->blocksize); 3858| 31.2k| else 3859| 31.2k| w = get_wasted_bits_wide_(threadtask->integer_signal_33bit_side, threadtask->integer_signal_mid_side[channel], encoder->protected_->blocksize); 3860| | 3861| 86.8k| if (w > encoder->protected_->bits_per_sample) { ------------------ | Branch (3861:8): [True: 0, False: 86.8k] ------------------ 3862| 0| w = encoder->protected_->bits_per_sample; 3863| 0| } 3864| 86.8k| threadtask->subframe_workspace_mid_side[channel][0].wasted_bits = threadtask->subframe_workspace_mid_side[channel][1].wasted_bits = w; 3865| 86.8k| threadtask->subframe_bps_mid_side[channel] = encoder->protected_->bits_per_sample - w + (channel==0? 0:1); ------------------ | Branch (3865:93): [True: 43.4k, False: 43.4k] ------------------ 3866| 86.8k| } 3867| 43.4k| } 3868| | 3869| | /* 3870| | * First do a normal encoding pass of each independent channel 3871| | */ 3872| 267k| if(do_independent) { ------------------ | Branch (3872:5): [True: 264k, False: 3.04k] ------------------ 3873| 596k| for(channel = 0; channel < encoder->protected_->channels; channel++) { ------------------ | Branch (3873:20): [True: 332k, False: 264k] ------------------ 3874| 332k| if(encoder->protected_->limit_min_bitrate && all_subframes_constant && (channel + 1) == encoder->protected_->channels){ ------------------ | Branch (3874:7): [True: 137k, False: 195k] | Branch (3874:49): [True: 116k, False: 21.0k] | Branch (3874:75): [True: 94.3k, False: 21.8k] ------------------ 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| 94.3k| threadtask->disable_constant_subframes = true; 3879| 94.3k| } 3880| 332k| if(! ------------------ | Branch (3880:7): [True: 0, False: 332k] ------------------ 3881| 332k| process_subframe_( 3882| 332k| encoder, 3883| 332k| threadtask, 3884| 332k| min_partition_order, 3885| 332k| max_partition_order, 3886| 332k| &frame_header, 3887| 332k| threadtask->subframe_bps[channel], 3888| 332k| threadtask->integer_signal[channel], 3889| 332k| threadtask->subframe_workspace_ptr[channel], 3890| 332k| threadtask->partitioned_rice_contents_workspace_ptr[channel], 3891| 332k| threadtask->residual_workspace[channel], 3892| 332k| threadtask->best_subframe+channel, 3893| 332k| threadtask->best_subframe_bits+channel 3894| 332k| ) 3895| 332k| ) 3896| 0| return false; 3897| 332k| if(threadtask->subframe_workspace[channel][threadtask->best_subframe[channel]].type != FLAC__SUBFRAME_TYPE_CONSTANT) ------------------ | Branch (3897:7): [True: 232k, False: 100k] ------------------ 3898| 232k| all_subframes_constant = false; 3899| 332k| } 3900| 264k| } 3901| | 3902| | /* 3903| | * Now do mid and side channels if requested 3904| | */ 3905| 267k| if(do_mid_side) { ------------------ | Branch (3905:5): [True: 43.4k, False: 224k] ------------------ 3906| 43.4k| FLAC__ASSERT(encoder->protected_->channels == 2); ------------------ | | 38| 43.4k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 43.4k] | | ------------------ ------------------ 3907| | 3908| 130k| for(channel = 0; channel < 2; channel++) { ------------------ | Branch (3908:20): [True: 86.8k, False: 43.4k] ------------------ 3909| 86.8k| void *integer_signal_; 3910| 86.8k| if(threadtask->subframe_bps_mid_side[channel] <= 32) ------------------ | Branch (3910:7): [True: 73.8k, False: 13.0k] ------------------ 3911| 73.8k| integer_signal_ = threadtask->integer_signal_mid_side[channel]; 3912| 13.0k| else 3913| 13.0k| integer_signal_ = threadtask->integer_signal_33bit_side; 3914| 86.8k| if(! ------------------ | Branch (3914:7): [True: 0, False: 86.8k] ------------------ 3915| 86.8k| process_subframe_( 3916| 86.8k| encoder, 3917| 86.8k| threadtask, 3918| 86.8k| min_partition_order, 3919| 86.8k| max_partition_order, 3920| 86.8k| &frame_header, 3921| 86.8k| threadtask->subframe_bps_mid_side[channel], 3922| 86.8k| integer_signal_, 3923| 86.8k| threadtask->subframe_workspace_ptr_mid_side[channel], 3924| 86.8k| threadtask->partitioned_rice_contents_workspace_ptr_mid_side[channel], 3925| 86.8k| threadtask->residual_workspace_mid_side[channel], 3926| 86.8k| threadtask->best_subframe_mid_side+channel, 3927| 86.8k| threadtask->best_subframe_bits_mid_side+channel 3928| 86.8k| ) 3929| 86.8k| ) 3930| 0| return false; 3931| 86.8k| } 3932| 43.4k| } 3933| | 3934| | /* 3935| | * Compose the frame bitbuffer 3936| | */ 3937| 267k| if((do_independent && do_mid_side) || encoder->protected_->loose_mid_side_stereo) { ------------------ | Branch (3937:6): [True: 264k, False: 2.79k] | Branch (3937:24): [True: 41.2k, False: 223k] | Branch (3937:40): [True: 3.04k, False: 222k] ------------------ 3938| 44.2k| uint32_t left_bps = 0, right_bps = 0; /* initialized only to prevent superfluous compiler warning */ 3939| 44.2k| FLAC__Subframe *left_subframe = 0, *right_subframe = 0; /* initialized only to prevent superfluous compiler warning */ 3940| 44.2k| FLAC__ChannelAssignment channel_assignment; 3941| | 3942| 44.2k| FLAC__ASSERT(encoder->protected_->channels == 2); ------------------ | | 38| 44.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 44.2k] | | ------------------ ------------------ 3943| | 3944| 44.2k| if(!encoder->protected_->loose_mid_side_stereo) { ------------------ | Branch (3944:6): [True: 41.2k, False: 3.05k] ------------------ 3945| 41.2k| uint32_t bits[4]; /* WATCHOUT - indexed by FLAC__ChannelAssignment */ 3946| 41.2k| uint32_t min_bits; 3947| 41.2k| int ca; 3948| | 3949| 41.2k| FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT == 0); ------------------ | | 38| 41.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 41.2k] | | ------------------ ------------------ 3950| 41.2k| FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE == 1); ------------------ | | 38| 41.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 41.2k] | | ------------------ ------------------ 3951| 41.2k| FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE == 2); ------------------ | | 38| 41.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 41.2k] | | ------------------ ------------------ 3952| 41.2k| FLAC__ASSERT(FLAC__CHANNEL_ASSIGNMENT_MID_SIDE == 3); ------------------ | | 38| 41.2k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 41.2k] | | ------------------ ------------------ 3953| | 3954| | /* We have to figure out which channel assignent results in the smallest frame */ 3955| 41.2k| bits[FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT] = threadtask->best_subframe_bits [0] + threadtask->best_subframe_bits [1]; 3956| 41.2k| bits[FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE ] = threadtask->best_subframe_bits [0] + threadtask->best_subframe_bits_mid_side[1]; 3957| 41.2k| bits[FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE ] = threadtask->best_subframe_bits [1] + threadtask->best_subframe_bits_mid_side[1]; 3958| 41.2k| bits[FLAC__CHANNEL_ASSIGNMENT_MID_SIDE ] = threadtask->best_subframe_bits_mid_side[0] + threadtask->best_subframe_bits_mid_side[1]; 3959| | 3960| 41.2k| channel_assignment = FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; 3961| 41.2k| min_bits = bits[channel_assignment]; 3962| | 3963| | /* When doing loose mid-side stereo, ignore left-side 3964| | * and right-side options */ 3965| 164k| for(ca = 1; ca <= 3; ca++) { ------------------ | Branch (3965:16): [True: 123k, False: 41.2k] ------------------ 3966| 123k| if(bits[ca] < min_bits) { ------------------ | Branch (3966:8): [True: 41.0k, False: 82.5k] ------------------ 3967| 41.0k| min_bits = bits[ca]; 3968| 41.0k| channel_assignment = (FLAC__ChannelAssignment)ca; 3969| 41.0k| } 3970| 123k| } 3971| 41.2k| frame_header.channel_assignment = channel_assignment; 3972| 41.2k| } 3973| | 3974| 44.2k| if(!FLAC__frame_add_header(&frame_header, threadtask->frame)) { ------------------ | Branch (3974:6): [True: 0, False: 44.2k] ------------------ 3975| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 3976| 0| return false; 3977| 0| } 3978| | 3979| 44.2k| switch(frame_header.channel_assignment) { 3980| 12.0k| case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: ------------------ | Branch (3980:4): [True: 12.0k, False: 32.1k] ------------------ 3981| 12.0k| left_subframe = &threadtask->subframe_workspace [0][threadtask->best_subframe [0]]; 3982| 12.0k| right_subframe = &threadtask->subframe_workspace [1][threadtask->best_subframe [1]]; 3983| 12.0k| break; 3984| 14.3k| case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: ------------------ | Branch (3984:4): [True: 14.3k, False: 29.9k] ------------------ 3985| 14.3k| left_subframe = &threadtask->subframe_workspace [0][threadtask->best_subframe [0]]; 3986| 14.3k| right_subframe = &threadtask->subframe_workspace_mid_side[1][threadtask->best_subframe_mid_side[1]]; 3987| 14.3k| break; 3988| 6.83k| case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: ------------------ | Branch (3988:4): [True: 6.83k, False: 37.4k] ------------------ 3989| 6.83k| left_subframe = &threadtask->subframe_workspace_mid_side[1][threadtask->best_subframe_mid_side[1]]; 3990| 6.83k| right_subframe = &threadtask->subframe_workspace [1][threadtask->best_subframe [1]]; 3991| 6.83k| break; 3992| 10.9k| case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: ------------------ | Branch (3992:4): [True: 10.9k, False: 33.2k] ------------------ 3993| 10.9k| left_subframe = &threadtask->subframe_workspace_mid_side[0][threadtask->best_subframe_mid_side[0]]; 3994| 10.9k| right_subframe = &threadtask->subframe_workspace_mid_side[1][threadtask->best_subframe_mid_side[1]]; 3995| 10.9k| break; 3996| 0| default: ------------------ | Branch (3996:4): [True: 0, False: 44.2k] ------------------ 3997| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 3998| 44.2k| } 3999| | 4000| 44.2k| switch(frame_header.channel_assignment) { 4001| 12.0k| case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: ------------------ | Branch (4001:4): [True: 12.0k, False: 32.1k] ------------------ 4002| 12.0k| left_bps = threadtask->subframe_bps [0]; 4003| 12.0k| right_bps = threadtask->subframe_bps [1]; 4004| 12.0k| break; 4005| 14.3k| case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: ------------------ | Branch (4005:4): [True: 14.3k, False: 29.9k] ------------------ 4006| 14.3k| left_bps = threadtask->subframe_bps [0]; 4007| 14.3k| right_bps = threadtask->subframe_bps_mid_side[1]; 4008| 14.3k| break; 4009| 6.83k| case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: ------------------ | Branch (4009:4): [True: 6.83k, False: 37.4k] ------------------ 4010| 6.83k| left_bps = threadtask->subframe_bps_mid_side[1]; 4011| 6.83k| right_bps = threadtask->subframe_bps [1]; 4012| 6.83k| break; 4013| 10.9k| case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: ------------------ | Branch (4013:4): [True: 10.9k, False: 33.2k] ------------------ 4014| 10.9k| left_bps = threadtask->subframe_bps_mid_side[0]; 4015| 10.9k| right_bps = threadtask->subframe_bps_mid_side[1]; 4016| 10.9k| break; 4017| 0| default: ------------------ | Branch (4017:4): [True: 0, False: 44.2k] ------------------ 4018| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 4019| 44.2k| } 4020| | 4021| | /* note that encoder_add_subframe_ sets the state for us in case of an error */ 4022| 44.2k| if(!add_subframe_(encoder, frame_header.blocksize, left_bps , left_subframe , threadtask->frame)) ------------------ | Branch (4022:6): [True: 0, False: 44.2k] ------------------ 4023| 0| return false; 4024| 44.2k| if(!add_subframe_(encoder, frame_header.blocksize, right_bps, right_subframe, threadtask->frame)) ------------------ | Branch (4024:6): [True: 0, False: 44.2k] ------------------ 4025| 0| return false; 4026| 44.2k| } 4027| 223k| else { 4028| 223k| FLAC__ASSERT(do_independent); ------------------ | | 38| 223k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 223k] | | ------------------ ------------------ 4029| 223k| if(!FLAC__frame_add_header(&frame_header, threadtask->frame)) { ------------------ | Branch (4029:6): [True: 0, False: 223k] ------------------ 4030| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 4031| 0| return false; 4032| 0| } 4033| | 4034| 471k| for(channel = 0; channel < encoder->protected_->channels; channel++) { ------------------ | Branch (4034:20): [True: 248k, False: 223k] ------------------ 4035| 248k| 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: 248k] ------------------ 4036| | /* the above function sets the state for us in case of an error */ 4037| 0| return false; 4038| 0| } 4039| 248k| } 4040| 223k| } 4041| | 4042| 267k| return true; 4043| 267k|} stream_encoder.c:get_wasted_bits_: 5078| 388k|{ 5079| 388k| uint32_t i, shift; 5080| 388k| FLAC__int32 x = 0; 5081| | 5082| 1.16M| for(i = 0; i < samples && !(x&1); i++) ------------------ | Branch (5082:13): [True: 1.14M, False: 21.7k] | Branch (5082:28): [True: 777k, False: 366k] ------------------ 5083| 777k| x |= signal[i]; 5084| | 5085| 388k| if(x == 0) { ------------------ | Branch (5085:5): [True: 3.15k, False: 385k] ------------------ 5086| 3.15k| shift = 0; 5087| 3.15k| } 5088| 385k| else { 5089| 469k| for(shift = 0; !(x&1); shift++) ------------------ | Branch (5089:18): [True: 84.1k, False: 385k] ------------------ 5090| 84.1k| x >>= 1; 5091| 385k| } 5092| | 5093| 388k| if(shift > 0) { ------------------ | Branch (5093:5): [True: 15.3k, False: 373k] ------------------ 5094| 295k| for(i = 0; i < samples; i++) ------------------ | Branch (5094:14): [True: 279k, False: 15.3k] ------------------ 5095| 279k| signal[i] >>= shift; 5096| 15.3k| } 5097| | 5098| 388k| return shift; 5099| 388k|} stream_encoder.c:get_wasted_bits_wide_: 5102| 31.2k|{ 5103| 31.2k| uint32_t i, shift; 5104| 31.2k| FLAC__int64 x = 0; 5105| | 5106| 912k| for(i = 0; i < samples && !(x&1); i++) ------------------ | Branch (5106:13): [True: 893k, False: 18.6k] | Branch (5106:28): [True: 880k, False: 12.6k] ------------------ 5107| 880k| x |= signal_wide[i]; 5108| | 5109| 31.2k| if(x == 0) { ------------------ | Branch (5109:5): [True: 5.54k, False: 25.6k] ------------------ 5110| 5.54k| shift = 1; 5111| 5.54k| } 5112| 25.6k| else { 5113| 96.0k| for(shift = 0; !(x&1); shift++) ------------------ | Branch (5113:18): [True: 70.3k, False: 25.6k] ------------------ 5114| 70.3k| x >>= 1; 5115| 25.6k| } 5116| | 5117| 31.2k| if(shift > 0) { ------------------ | Branch (5117:5): [True: 18.1k, False: 13.0k] ------------------ 5118| 543k| for(i = 0; i < samples; i++) ------------------ | Branch (5118:14): [True: 524k, False: 18.1k] ------------------ 5119| 524k| signal[i] = (FLAC__int32)(signal_wide[i] >> shift); 5120| 18.1k| } 5121| | 5122| 31.2k| return shift; 5123| 31.2k|} stream_encoder.c:process_subframe_: 4059| 419k|{ 4060| 419k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 4061| 419k| 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| 419k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 4066| 419k| double lpc_residual_bits_per_sample; 4067| 419k| apply_apodization_state_struct apply_apodization_state; 4068| 419k| double lpc_error[FLAC__MAX_LPC_ORDER]; 4069| 419k| uint32_t min_lpc_order, max_lpc_order, lpc_order, guess_lpc_order; 4070| 419k| uint32_t min_qlp_coeff_precision, max_qlp_coeff_precision, qlp_coeff_precision; 4071| 419k|#endif 4072| 419k| uint32_t min_fixed_order, max_fixed_order, guess_fixed_order, fixed_order; 4073| 419k| uint32_t _candidate_bits, _best_bits; 4074| 419k| uint32_t _best_subframe; 4075| | /* only use RICE2 partitions if stream bps > 16 */ 4076| 419k| 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: 387k, False: 31.8k] ------------------ 4077| | 4078| 419k| FLAC__ASSERT(frame_header->blocksize > 0); ------------------ | | 38| 419k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 419k] | | ------------------ ------------------ 4079| | 4080| | /* verbatim subframe is the baseline against which we measure other compressed subframes */ 4081| 419k| _best_subframe = 0; 4082| 419k| 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: 419k] | Branch (4082:54): [True: 0, False: 0] ------------------ 4083| 0| _best_bits = UINT32_MAX; 4084| 419k| else 4085| 419k| _best_bits = evaluate_verbatim_subframe_(encoder, integer_signal, frame_header->blocksize, subframe_bps, subframe[_best_subframe]); 4086| 419k| *best_bits = _best_bits; 4087| | 4088| 419k| if(frame_header->blocksize > FLAC__MAX_FIXED_ORDER) { ------------------ | | 145| 419k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ | Branch (4088:5): [True: 414k, False: 4.69k] ------------------ 4089| 414k| 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| 414k| if(subframe_bps < 28){ ------------------ | Branch (4098:6): [True: 80.2k, False: 334k] ------------------ 4099| 80.2k| if(subframe_bps + FLAC__bitmath_ilog2((frame_header->blocksize-FLAC__MAX_FIXED_ORDER)*17) < 32) ------------------ | | 145| 80.2k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ | Branch (4099:7): [True: 53.6k, False: 26.5k] ------------------ 4100| 53.6k| 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| 53.6k|#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| 53.6k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ 4101| 26.5k| else 4102| 26.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| 26.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| 26.5k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ 4103| 80.2k| } 4104| 334k| else 4105| 334k| if(subframe_bps <= 32) ------------------ | Branch (4105:7): [True: 321k, False: 12.9k] ------------------ 4106| 321k| 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| 321k|#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| 321k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ 4107| 12.9k| else 4108| 12.9k| 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| 12.9k|#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| 12.9k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ 4109| | 4110| | /* check for constant subframe */ 4111| 414k| if( 4112| 414k| !threadtask->disable_constant_subframes && ------------------ | Branch (4112:4): [True: 317k, False: 96.7k] ------------------ 4113| 317k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 4114| 317k| fixed_residual_bits_per_sample[1] == 0.0 ------------------ | Branch (4114:4): [True: 117k, False: 200k] ------------------ 4115| |#else 4116| | fixed_residual_bits_per_sample[1] == FLAC__FP_ZERO 4117| |#endif 4118| 414k| ) { 4119| | /* the above means it's possible all samples are the same value; now double-check it: */ 4120| 117k| uint32_t i; 4121| 117k| signal_is_constant = true; 4122| 117k| if(subframe_bps <= 32){ ------------------ | Branch (4122:7): [True: 116k, False: 807] ------------------ 4123| 116k| const FLAC__int32 *integer_signal_ = integer_signal; 4124| 2.00M| for(i = 1; i < frame_header->blocksize; i++) { ------------------ | Branch (4124:16): [True: 1.88M, False: 113k] ------------------ 4125| 1.88M| if(integer_signal_[0] != integer_signal_[i]) { ------------------ | Branch (4125:9): [True: 2.97k, False: 1.88M] ------------------ 4126| 2.97k| signal_is_constant = false; 4127| 2.97k| break; 4128| 2.97k| } 4129| 1.88M| } 4130| 116k| } 4131| 807| else { 4132| 807| const FLAC__int64 *integer_signal_ = integer_signal; 4133| 14.0k| for(i = 1; i < frame_header->blocksize; i++) { ------------------ | Branch (4133:16): [True: 13.2k, False: 807] ------------------ 4134| 13.2k| if(integer_signal_[0] != integer_signal_[i]) { ------------------ | Branch (4134:9): [True: 0, False: 13.2k] ------------------ 4135| 0| signal_is_constant = false; 4136| 0| break; 4137| 0| } 4138| 13.2k| } 4139| 807| } 4140| 117k| } 4141| 414k| if(signal_is_constant) { ------------------ | Branch (4141:6): [True: 114k, False: 300k] ------------------ 4142| 114k| if(subframe_bps <= 32) ------------------ | Branch (4142:7): [True: 113k, False: 813] ------------------ 4143| 113k| _candidate_bits = evaluate_constant_subframe_(encoder, ((FLAC__int32 *)integer_signal)[0], frame_header->blocksize, subframe_bps, subframe[!_best_subframe]); 4144| 813| else 4145| 813| _candidate_bits = evaluate_constant_subframe_(encoder, ((FLAC__int64 *)integer_signal)[0], frame_header->blocksize, subframe_bps, subframe[!_best_subframe]); 4146| | 4147| 114k| if(_candidate_bits < _best_bits) { ------------------ | Branch (4147:7): [True: 114k, False: 32] ------------------ 4148| 114k| _best_subframe = !_best_subframe; 4149| 114k| _best_bits = _candidate_bits; 4150| 114k| } 4151| 114k| } 4152| 300k| else { 4153| 300k| if(!encoder->private_->disable_fixed_subframes || (encoder->protected_->max_lpc_order == 0 && _best_bits == UINT_MAX)) { ------------------ | Branch (4153:7): [True: 300k, False: 0] | Branch (4153:55): [True: 0, False: 0] | Branch (4153:98): [True: 0, False: 0] ------------------ 4154| | /* encode fixed */ 4155| 300k| if(encoder->protected_->do_exhaustive_model_search) { ------------------ | Branch (4155:8): [True: 205k, False: 95.1k] ------------------ 4156| 205k| min_fixed_order = 0; 4157| 205k| max_fixed_order = FLAC__MAX_FIXED_ORDER; ------------------ | | 145| 205k|#define FLAC__MAX_FIXED_ORDER (4u) ------------------ 4158| 205k| } 4159| 95.1k| else { 4160| 95.1k| min_fixed_order = max_fixed_order = guess_fixed_order; 4161| 95.1k| } 4162| 300k| if(max_fixed_order >= frame_header->blocksize) ------------------ | Branch (4162:8): [True: 0, False: 300k] ------------------ 4163| 0| max_fixed_order = frame_header->blocksize - 1; 4164| 1.42M| for(fixed_order = min_fixed_order; fixed_order <= max_fixed_order; fixed_order++) { ------------------ | Branch (4164:40): [True: 1.12M, False: 300k] ------------------ 4165| 1.12M|#ifndef FLAC__INTEGER_ONLY_LIBRARY 4166| 1.12M| if(fixed_residual_bits_per_sample[fixed_order] >= (float)subframe_bps) ------------------ | Branch (4166:9): [True: 284k, False: 837k] ------------------ 4167| 284k| 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| 837k| _candidate_bits = 4173| 837k| evaluate_fixed_subframe_( 4174| 837k| encoder, 4175| 837k| threadtask, 4176| 837k| integer_signal, 4177| 837k| residual[!_best_subframe], 4178| 837k| threadtask->abs_residual_partition_sums, 4179| 837k| threadtask->raw_bits_per_partition, 4180| 837k| frame_header->blocksize, 4181| 837k| subframe_bps, 4182| 837k| fixed_order, 4183| 837k| rice_parameter_limit, 4184| 837k| min_partition_order, 4185| 837k| max_partition_order, 4186| 837k| encoder->protected_->do_escape_coding, 4187| 837k| encoder->protected_->rice_parameter_search_dist, 4188| 837k| subframe[!_best_subframe], 4189| 837k| partitioned_rice_contents[!_best_subframe] 4190| 837k| ); 4191| 837k| if(_candidate_bits < _best_bits) { ------------------ | Branch (4191:9): [True: 271k, False: 565k] ------------------ 4192| 271k| _best_subframe = !_best_subframe; 4193| 271k| _best_bits = _candidate_bits; 4194| 271k| } 4195| 837k| } 4196| 300k| } 4197| | 4198| 300k|#ifndef FLAC__INTEGER_ONLY_LIBRARY 4199| | /* encode lpc */ 4200| 300k| if(encoder->protected_->max_lpc_order > 0) { ------------------ | Branch (4200:7): [True: 216k, False: 83.1k] ------------------ 4201| 216k| if(encoder->protected_->max_lpc_order >= frame_header->blocksize) ------------------ | Branch (4201:8): [True: 13.0k, False: 203k] ------------------ 4202| 13.0k| max_lpc_order = frame_header->blocksize-1; 4203| 203k| else 4204| 203k| max_lpc_order = encoder->protected_->max_lpc_order; 4205| 216k| if(max_lpc_order > 0) { ------------------ | Branch (4205:8): [True: 216k, False: 2] ------------------ 4206| 216k| apply_apodization_state.a = 0; 4207| 216k| apply_apodization_state.b = 1; 4208| 216k| apply_apodization_state.c = 0; 4209| 73.0M| while (apply_apodization_state.a < encoder->protected_->num_apodizations) { ------------------ | Branch (4209:13): [True: 72.8M, False: 216k] ------------------ 4210| 72.8M| uint32_t max_lpc_order_this_apodization = max_lpc_order; 4211| | 4212| 72.8M| if(!apply_apodization_(encoder, threadtask, &apply_apodization_state, ------------------ | Branch (4212:10): [True: 72.5M, False: 306k] ------------------ 4213| 72.8M| frame_header->blocksize, lpc_error, 4214| 72.8M| &max_lpc_order_this_apodization, 4215| 72.8M| subframe_bps, integer_signal, 4216| 72.8M| &guess_lpc_order)) 4217| | /* If apply_apodization_ fails, try next apodization */ 4218| 72.5M| continue; 4219| | 4220| 306k| if(encoder->protected_->do_exhaustive_model_search) { ------------------ | Branch (4220:10): [True: 218k, False: 88.1k] ------------------ 4221| 218k| min_lpc_order = 1; 4222| 218k| } 4223| 88.1k| else { 4224| 88.1k| min_lpc_order = max_lpc_order_this_apodization = guess_lpc_order; 4225| 88.1k| } 4226| 3.03M| for(lpc_order = min_lpc_order; lpc_order <= max_lpc_order_this_apodization; lpc_order++) { ------------------ | Branch (4226:38): [True: 2.73M, False: 306k] ------------------ 4227| 2.73M| lpc_residual_bits_per_sample = FLAC__lpc_compute_expected_bits_per_residual_sample(lpc_error[lpc_order-1], frame_header->blocksize-lpc_order); 4228| 2.73M| if(lpc_residual_bits_per_sample >= (double)subframe_bps) ------------------ | Branch (4228:11): [True: 16.3k, False: 2.71M] ------------------ 4229| 16.3k| continue; /* don't even try */ 4230| 2.71M| if(encoder->protected_->do_qlp_coeff_prec_search) { ------------------ | Branch (4230:11): [True: 1.58M, False: 1.13M] ------------------ 4231| 1.58M| min_qlp_coeff_precision = FLAC__MIN_QLP_COEFF_PRECISION; ------------------ | | 137| 1.58M|#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.58M| if(subframe_bps <= 17) { ------------------ | Branch (4233:12): [True: 188k, False: 1.39M] ------------------ 4234| 188k| max_qlp_coeff_precision = flac_min(32 - subframe_bps - FLAC__bitmath_ilog2(lpc_order), FLAC__MAX_QLP_COEFF_PRECISION); ------------------ | | 56| 188k|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (4234:36): [True: 89.6k, False: 98.3k] ------------------ 4235| 188k| max_qlp_coeff_precision = flac_max(max_qlp_coeff_precision, min_qlp_coeff_precision); ------------------ | | 55| 188k|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (4235:36): [True: 188k, False: 0] ------------------ 4236| 188k| } 4237| 1.39M| else 4238| 1.39M| max_qlp_coeff_precision = FLAC__MAX_QLP_COEFF_PRECISION; ------------------ | | 142| 1.39M|#define FLAC__MAX_QLP_COEFF_PRECISION (15u) ------------------ 4239| 1.58M| } 4240| 1.13M| else { 4241| 1.13M| min_qlp_coeff_precision = max_qlp_coeff_precision = encoder->protected_->qlp_coeff_precision; 4242| 1.13M| } 4243| 20.8M| for(qlp_coeff_precision = min_qlp_coeff_precision; qlp_coeff_precision <= max_qlp_coeff_precision; qlp_coeff_precision++) { ------------------ | Branch (4243:59): [True: 18.1M, False: 2.71M] ------------------ 4244| 18.1M| _candidate_bits = 4245| 18.1M| evaluate_lpc_subframe_( 4246| 18.1M| encoder, 4247| 18.1M| threadtask, 4248| 18.1M| integer_signal, 4249| 18.1M| residual[!_best_subframe], 4250| 18.1M| threadtask->abs_residual_partition_sums, 4251| 18.1M| threadtask->raw_bits_per_partition, 4252| 18.1M| threadtask->lp_coeff[lpc_order-1], 4253| 18.1M| frame_header->blocksize, 4254| 18.1M| subframe_bps, 4255| 18.1M| lpc_order, 4256| 18.1M| qlp_coeff_precision, 4257| 18.1M| rice_parameter_limit, 4258| 18.1M| min_partition_order, 4259| 18.1M| max_partition_order, 4260| 18.1M| encoder->protected_->do_escape_coding, 4261| 18.1M| encoder->protected_->rice_parameter_search_dist, 4262| 18.1M| subframe[!_best_subframe], 4263| 18.1M| partitioned_rice_contents[!_best_subframe] 4264| 18.1M| ); 4265| 18.1M| if(_candidate_bits > 0) { /* if == 0, there was a problem quantizing the lpcoeffs */ ------------------ | Branch (4265:12): [True: 15.5M, False: 2.57M] ------------------ 4266| 15.5M| if(_candidate_bits < _best_bits) { ------------------ | Branch (4266:13): [True: 40.4k, False: 15.5M] ------------------ 4267| 40.4k| _best_subframe = !_best_subframe; 4268| 40.4k| _best_bits = _candidate_bits; 4269| 40.4k| } 4270| 15.5M| } 4271| 18.1M| } 4272| 2.71M| } 4273| 306k| } 4274| 216k| } 4275| 216k| } 4276| 300k|#endif /* !defined FLAC__INTEGER_ONLY_LIBRARY */ 4277| 300k| } 4278| 414k| } 4279| | 4280| | /* under rare circumstances this can happen when all but lpc subframe types are disabled: */ 4281| 419k| if(_best_bits == UINT32_MAX) { ------------------ | Branch (4281:5): [True: 0, False: 419k] ------------------ 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| 419k| *best_subframe = _best_subframe; 4287| 419k| *best_bits = _best_bits; 4288| | 4289| | return true; 4290| 419k|} stream_encoder.c:evaluate_verbatim_subframe_: 4676| 419k|{ 4677| 419k| uint32_t estimate; 4678| | 4679| 419k| subframe->type = FLAC__SUBFRAME_TYPE_VERBATIM; 4680| | 4681| 419k| if(subframe_bps <= 32){ ------------------ | Branch (4681:5): [True: 406k, False: 13.4k] ------------------ 4682| 406k| subframe->data.verbatim.data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32; 4683| 406k| subframe->data.verbatim.data.int32 = signal; 4684| 406k| } 4685| 13.4k| else { 4686| 13.4k| subframe->data.verbatim.data_type = FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT64; 4687| 13.4k| subframe->data.verbatim.data.int64 = signal; 4688| 13.4k| } 4689| | 4690| 419k| 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| 419k| (void)encoder; 4696| 419k|#endif 4697| | 4698| 419k| return estimate; 4699| 419k|} stream_encoder.c:evaluate_constant_subframe_: 4473| 114k|{ 4474| 114k| uint32_t estimate; 4475| 114k| subframe->type = FLAC__SUBFRAME_TYPE_CONSTANT; 4476| 114k| subframe->data.constant.value = signal; 4477| | 4478| 114k| 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| 114k| (void)encoder, (void)blocksize; 4484| 114k|#endif 4485| | 4486| 114k| return estimate; 4487| 114k|} stream_encoder.c:evaluate_fixed_subframe_: 4507| 837k|{ 4508| 837k| uint32_t i, residual_bits, estimate; 4509| 837k| const uint32_t residual_samples = blocksize - order; 4510| | 4511| 837k| if((subframe_bps + order) <= 32) ------------------ | Branch (4511:5): [True: 460k, False: 376k] ------------------ 4512| 460k| FLAC__fixed_compute_residual(((FLAC__int32 *)signal)+order, residual_samples, order, residual); 4513| 376k| else if(subframe_bps <= 32) ------------------ | Branch (4513:10): [True: 364k, False: 12.7k] ------------------ 4514| 364k| FLAC__fixed_compute_residual_wide(((FLAC__int32 *)signal)+order, residual_samples, order, residual); 4515| 12.7k| else 4516| 12.7k| FLAC__fixed_compute_residual_wide_33bit(((FLAC__int64 *)signal)+order, residual_samples, order, residual); 4517| | 4518| 837k| subframe->type = FLAC__SUBFRAME_TYPE_FIXED; 4519| | 4520| 837k| subframe->data.fixed.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE; 4521| 837k| subframe->data.fixed.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents; 4522| 837k| subframe->data.fixed.residual = residual; 4523| | 4524| 837k| residual_bits = 4525| 837k| find_best_partition_order_( 4526| 837k| encoder->private_, 4527| 837k| threadtask, 4528| 837k| residual, 4529| 837k| abs_residual_partition_sums, 4530| 837k| raw_bits_per_partition, 4531| 837k| residual_samples, 4532| 837k| order, 4533| 837k| rice_parameter_limit, 4534| 837k| min_partition_order, 4535| 837k| max_partition_order, 4536| 837k| subframe_bps, 4537| 837k| do_escape_coding, 4538| 837k| rice_parameter_search_dist, 4539| 837k| &subframe->data.fixed.entropy_coding_method 4540| 837k| ); 4541| | 4542| 837k| subframe->data.fixed.order = order; 4543| 837k| if(subframe_bps <= 32) ------------------ | Branch (4543:5): [True: 823k, False: 13.7k] ------------------ 4544| 2.16M| for(i = 0; i < order; i++) ------------------ | Branch (4544:14): [True: 1.34M, False: 823k] ------------------ 4545| 1.34M| subframe->data.fixed.warmup[i] = ((FLAC__int32 *)signal)[i]; 4546| 13.7k| else 4547| 27.0k| for(i = 0; i < order; i++) ------------------ | Branch (4547:14): [True: 13.3k, False: 13.7k] ------------------ 4548| 13.3k| subframe->data.fixed.warmup[i] = ((FLAC__int64 *)signal)[i]; 4549| | 4550| 837k| estimate = FLAC__SUBFRAME_ZERO_PAD_LEN + FLAC__SUBFRAME_TYPE_LEN + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN + subframe->wasted_bits + (order * subframe_bps); 4551| 837k| if(residual_bits < UINT32_MAX - estimate) // To make sure estimate doesn't overflow ------------------ | Branch (4551:5): [True: 836k, False: 499] ------------------ 4552| 836k| estimate += residual_bits; 4553| 499| else 4554| 499| estimate = UINT32_MAX; 4555| | 4556| |#if SPOTCHECK_ESTIMATE 4557| | spotcheck_subframe_estimate_(encoder, blocksize, subframe_bps, subframe, estimate); 4558| |#endif 4559| | 4560| 837k| return estimate; 4561| 837k|} stream_encoder.c:find_best_partition_order_: 4717| 16.2M|{ 4718| 16.2M| uint32_t residual_bits, best_residual_bits = 0; 4719| 16.2M| uint32_t best_parameters_index = 0; 4720| 16.2M| uint32_t best_partition_order = 0; 4721| 16.2M| const uint32_t blocksize = residual_samples + predictor_order; 4722| | 4723| 16.2M| max_partition_order = FLAC__format_get_max_rice_partition_order_from_blocksize_limited_max_and_predictor_order(max_partition_order, blocksize, predictor_order); 4724| 16.2M| min_partition_order = flac_min(min_partition_order, max_partition_order); ------------------ | | 56| 16.2M|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (4724:24): [True: 555k, False: 15.6M] ------------------ 4725| | 4726| 16.2M| private_->local_precompute_partition_info_sums(residual, abs_residual_partition_sums, residual_samples, predictor_order, min_partition_order, max_partition_order, bps); 4727| | 4728| 16.2M| if(do_escape_coding) ------------------ | Branch (4728:5): [True: 12.8M, False: 3.36M] ------------------ 4729| 12.8M| precompute_partition_info_escapes_(residual, raw_bits_per_partition, residual_samples, predictor_order, min_partition_order, max_partition_order); 4730| | 4731| 16.2M| { 4732| 16.2M| int partition_order; 4733| 16.2M| uint32_t sum; 4734| | 4735| 33.0M| for(partition_order = (int)max_partition_order, sum = 0; partition_order >= (int)min_partition_order; partition_order--) { ------------------ | Branch (4735:60): [True: 16.8M, False: 16.2M] ------------------ 4736| 16.8M| FLAC__ASSERT(do_escape_coding != /* XOR */ (raw_bits_per_partition == NULL)); ------------------ | | 38| 16.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.8M] | | ------------------ ------------------ 4737| 16.8M| if(! ------------------ | Branch (4737:7): [True: 0, False: 16.8M] ------------------ 4738| 16.8M| set_partitioned_rice_( 4739| |#ifdef EXACT_RICE_BITS_CALCULATION 4740| | residual, 4741| |#endif 4742| 16.8M| abs_residual_partition_sums+sum, 4743| 16.8M| do_escape_coding ? raw_bits_per_partition+sum : NULL, ------------------ | Branch (4743:6): [True: 13.1M, False: 3.70M] ------------------ 4744| 16.8M| residual_samples, 4745| 16.8M| predictor_order, 4746| 16.8M| rice_parameter_limit, 4747| 16.8M| rice_parameter_search_dist, 4748| 16.8M| (uint32_t)partition_order, 4749| 16.8M| do_escape_coding, 4750| 16.8M| &threadtask->partitioned_rice_contents_extra[!best_parameters_index], 4751| 16.8M| &residual_bits 4752| 16.8M| ) 4753| 16.8M| ) 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| 16.8M| sum += 1u << partition_order; 4759| 16.8M| if(best_residual_bits == 0 || residual_bits < best_residual_bits) { ------------------ | Branch (4759:7): [True: 15.8M, False: 983k] | Branch (4759:34): [True: 614k, False: 368k] ------------------ 4760| 16.7M| best_residual_bits = residual_bits; 4761| 16.7M| best_parameters_index = !best_parameters_index; 4762| 16.7M| best_partition_order = partition_order; 4763| 16.7M| } 4764| 16.8M| } 4765| 16.2M| } 4766| | 4767| 16.2M| best_ecm->data.partitioned_rice.order = best_partition_order; 4768| | 4769| 16.2M| { 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| 16.2M| FLAC__EntropyCodingMethod_PartitionedRiceContents* prc = (FLAC__EntropyCodingMethod_PartitionedRiceContents*)best_ecm->data.partitioned_rice.contents; 4775| 16.2M| uint32_t partition; 4776| | 4777| | /* save best parameters and raw_bits */ 4778| 16.2M| memcpy(prc->parameters, threadtask->partitioned_rice_contents_extra[best_parameters_index].parameters, (uint32_t)sizeof(uint32_t)*(1<<(best_partition_order))); 4779| 16.2M| if(do_escape_coding) ------------------ | Branch (4779:6): [True: 12.7M, False: 3.49M] ------------------ 4780| 12.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| 25.6M| for(partition = 0; partition < (1u<parameters[partition] >= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER) { ------------------ | Branch (4787:7): [True: 12.0M, False: 9.48M] ------------------ 4788| 12.0M| best_ecm->type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2; 4789| 12.0M| break; 4790| 12.0M| } 4791| 21.5M| } 4792| 16.2M| } 4793| | 4794| 16.2M| return best_residual_bits; 4795| 16.2M|} stream_encoder.c:precompute_partition_info_escapes_: 4862| 12.8M|{ 4863| 12.8M| int partition_order; 4864| 12.8M| uint32_t from_partition, to_partition = 0; 4865| 12.8M| const uint32_t blocksize = residual_samples + predictor_order; 4866| | 4867| | /* first do max_partition_order */ 4868| 12.8M| for(partition_order = (int)max_partition_order; partition_order >= 0; partition_order--) { ------------------ | Branch (4868:50): [True: 12.8M, False: 17.0k] ------------------ 4869| 12.8M| FLAC__int32 r; 4870| 12.8M| FLAC__uint32 rmax; 4871| 12.8M| uint32_t partition, partition_sample, partition_samples, residual_sample; 4872| 12.8M| const uint32_t partitions = 1u << partition_order; 4873| 12.8M| const uint32_t default_partition_samples = blocksize >> partition_order; 4874| | 4875| 12.8M| FLAC__ASSERT(default_partition_samples > predictor_order); ------------------ | | 38| 12.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 12.8M] | | ------------------ ------------------ 4876| | 4877| 44.8M| for(partition = residual_sample = 0; partition < partitions; partition++) { ------------------ | Branch (4877:40): [True: 32.0M, False: 12.8M] ------------------ 4878| 32.0M| partition_samples = default_partition_samples; 4879| 32.0M| if(partition == 0) ------------------ | Branch (4879:7): [True: 12.8M, False: 19.2M] ------------------ 4880| 12.8M| partition_samples -= predictor_order; 4881| 32.0M| rmax = 0; 4882| 1.72G| for(partition_sample = 0; partition_sample < partition_samples; partition_sample++) { ------------------ | Branch (4882:30): [True: 1.69G, False: 32.0M] ------------------ 4883| 1.69G| r = residual[residual_sample++]; 4884| | /* OPT: maybe faster: rmax |= r ^ (r>>31) */ 4885| 1.69G| if(r < 0) ------------------ | Branch (4885:8): [True: 493M, False: 1.19G] ------------------ 4886| 493M| rmax |= ~r; 4887| 1.19G| else 4888| 1.19G| rmax |= r; 4889| 1.69G| } 4890| | /* now we know all residual values are in the range [-rmax-1,rmax] */ 4891| 32.0M| raw_bits_per_partition[partition] = rmax? FLAC__bitmath_ilog2(rmax) + 2 : 1; ------------------ | Branch (4891:40): [True: 22.8M, False: 9.16M] ------------------ 4892| 32.0M| } 4893| 12.8M| to_partition = partitions; 4894| 12.8M| break; /*@@@ yuck, should remove the 'for' loop instead */ 4895| 12.8M| } 4896| | 4897| | /* now merge partitions for lower orders */ 4898| 13.6M| for(from_partition = 0, --partition_order; partition_order >= (int)min_partition_order; partition_order--) { ------------------ | Branch (4898:45): [True: 790k, False: 12.8M] ------------------ 4899| 790k| uint32_t m; 4900| 790k| uint32_t i; 4901| 790k| const uint32_t partitions = 1u << partition_order; 4902| 2.70M| for(i = 0; i < partitions; i++) { ------------------ | Branch (4902:14): [True: 1.91M, False: 790k] ------------------ 4903| 1.91M| m = raw_bits_per_partition[from_partition]; 4904| 1.91M| from_partition++; 4905| | raw_bits_per_partition[to_partition] = flac_max(m, raw_bits_per_partition[from_partition]); ------------------ | | 55| 1.91M|#define flac_max(a,b) MAX(a,b) ------------------ | Branch (4905:43): [True: 381k, False: 1.53M] ------------------ 4906| 1.91M| from_partition++; 4907| 1.91M| to_partition++; 4908| 1.91M| } 4909| 790k| } 4910| 12.8M|} stream_encoder.c:set_partitioned_rice_: 4969| 16.8M|{ 4970| 16.8M| uint32_t rice_parameter, partition_bits; 4971| 16.8M| uint32_t best_partition_bits, best_rice_parameter = 0; 4972| 16.8M| uint32_t bits_ = FLAC__ENTROPY_CODING_METHOD_TYPE_LEN + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; 4973| 16.8M| uint32_t *parameters, *raw_bits; 4974| 16.8M| uint32_t partition, residual_sample; 4975| 16.8M| uint32_t partition_samples, partition_samples_base; 4976| 16.8M| uint32_t partition_samples_fixed_point_divisor, partition_samples_fixed_point_divisor_base; 4977| 16.8M| const uint32_t partitions = 1u << partition_order; 4978| 16.8M| FLAC__uint64 mean; 4979| |#ifdef ENABLE_RICE_PARAMETER_SEARCH 4980| | uint32_t min_rice_parameter, max_rice_parameter; 4981| |#else 4982| 16.8M| (void)rice_parameter_search_dist; 4983| 16.8M|#endif 4984| | 4985| 16.8M| FLAC__ASSERT(rice_parameter_limit <= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER); ------------------ | | 38| 16.8M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.8M] | | ------------------ ------------------ 4986| | 4987| 16.8M| parameters = partitioned_rice_contents->parameters; 4988| 16.8M| raw_bits = partitioned_rice_contents->raw_bits; 4989| | 4990| 16.8M| 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| 16.8M| partition_samples_fixed_point_divisor_base = 0x40000 / partition_samples_base; 4998| | 4999| 59.4M| for(partition = residual_sample = 0; partition < partitions; partition++) { ------------------ | Branch (4999:39): [True: 42.5M, False: 16.8M] ------------------ 5000| 42.5M| partition_samples = partition_samples_base; 5001| 42.5M| if(partition > 0) { ------------------ | Branch (5001:6): [True: 26.1M, False: 16.4M] ------------------ 5002| 26.1M| partition_samples_fixed_point_divisor = partition_samples_fixed_point_divisor_base; 5003| 26.1M| } 5004| 16.4M| else { 5005| 16.4M| if(partition_samples <= predictor_order) ------------------ | Branch (5005:7): [True: 0, False: 16.4M] ------------------ 5006| 0| return false; 5007| 16.4M| else 5008| 16.4M| partition_samples -= predictor_order; 5009| 16.4M| partition_samples_fixed_point_divisor = 0x40000 / partition_samples; 5010| 16.4M| } 5011| 42.5M| 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.5M| if(mean < 2 || (((mean - 1)*partition_samples_fixed_point_divisor)>>18) == 0) ------------------ | Branch (5017:6): [True: 7.95M, False: 34.6M] | Branch (5017:18): [True: 4.47M, False: 30.1M] ------------------ 5018| 12.6M| rice_parameter = 0; 5019| 29.9M| else 5020| 29.9M| rice_parameter = FLAC__bitmath_ilog2_wide(((mean - 1)*partition_samples_fixed_point_divisor)>>18) + 1; 5021| | 5022| 42.5M| if(rice_parameter >= rice_parameter_limit) { ------------------ | Branch (5022:6): [True: 2.13M, False: 40.4M] ------------------ 5023| 2.13M| rice_parameter = rice_parameter_limit - 1; 5024| 2.13M| } 5025| | 5026| 42.5M| 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.5M| partition_bits = count_rice_bits_in_partition_(rice_parameter, partition_samples, abs_residual_partition_sums[partition]); 5047| 42.5M|#endif 5048| 42.8M| if(partition_bits < best_partition_bits) { ------------------ | Branch (5048:7): [True: 42.8M, False: 18.4E] ------------------ 5049| 42.8M| best_rice_parameter = rice_parameter; 5050| 42.8M| best_partition_bits = partition_bits; 5051| 42.8M| } 5052| |#ifdef ENABLE_RICE_PARAMETER_SEARCH 5053| | } 5054| |#endif 5055| 42.5M| if(search_for_escapes) { ------------------ | Branch (5055:6): [True: 33.9M, False: 8.66M] ------------------ 5056| 33.9M| 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.9M| if(partition_bits <= best_partition_bits && raw_bits_per_partition[partition] < 32) { ------------------ | Branch (5057:7): [True: 4.71M, False: 29.1M] | Branch (5057:48): [True: 4.54M, False: 160k] ------------------ 5058| 4.54M| raw_bits[partition] = raw_bits_per_partition[partition]; 5059| 4.54M| best_rice_parameter = 0; /* will be converted to appropriate escape parameter later */ 5060| 4.54M| best_partition_bits = partition_bits; 5061| 4.54M| } 5062| 29.3M| else 5063| 29.3M| raw_bits[partition] = 0; 5064| 33.9M| } 5065| 42.5M| parameters[partition] = best_rice_parameter; 5066| 42.5M| if(best_partition_bits < UINT32_MAX - bits_) // To make sure _bits doesn't overflow ------------------ | Branch (5066:6): [True: 42.8M, False: 18.4E] ------------------ 5067| 42.8M| bits_ += best_partition_bits; 5068| 18.4E| else 5069| 18.4E| bits_ = UINT32_MAX; 5070| 42.5M| residual_sample += partition_samples; 5071| 42.5M| } 5072| | 5073| 16.8M| *bits = bits_; 5074| | return true; 5075| 16.8M|} 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: 30.1M, False: 12.5M] | Branch (4935:20): [True: 30.2M, False: 12.5M] | Branch (4935:20): [True: 42.7M, False: 18.4E] ------------------ 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| 72.8M|{ 4328| 72.8M| apply_apodization_state->current_apodization = &encoder->protected_->apodizations[apply_apodization_state->a]; 4329| | 4330| 72.8M| if(apply_apodization_state->b == 1) { ------------------ | Branch (4330:5): [True: 245k, False: 72.6M] ------------------ 4331| | /* window full subblock */ 4332| 245k| if(subframe_bps <= 32) ------------------ | Branch (4332:6): [True: 230k, False: 14.5k] ------------------ 4333| 230k| FLAC__lpc_window_data(integer_signal, encoder->private_->window[apply_apodization_state->a], threadtask->windowed_signal, blocksize); 4334| 14.5k| else 4335| 14.5k| FLAC__lpc_window_data_wide(integer_signal, encoder->private_->window[apply_apodization_state->a], threadtask->windowed_signal, blocksize); 4336| 245k| encoder->private_->local_lpc_compute_autocorrelation(threadtask->windowed_signal, blocksize, (*max_lpc_order_this_apodization)+1, apply_apodization_state->autoc); 4337| 245k| if(apply_apodization_state->current_apodization->type == FLAC__APODIZATION_SUBDIVIDE_TUKEY){ ------------------ | Branch (4337:6): [True: 3.39k, False: 241k] ------------------ 4338| 3.39k| uint32_t i; 4339| 29.5k| for(i = 0; i < *max_lpc_order_this_apodization; i++) ------------------ | Branch (4339:15): [True: 26.1k, False: 3.39k] ------------------ 4340| 26.1k| memcpy(apply_apodization_state->autoc_root, apply_apodization_state->autoc, *max_lpc_order_this_apodization*sizeof(apply_apodization_state->autoc[0])); 4341| | 4342| 3.39k| (apply_apodization_state->b)++; 4343| 241k| }else{ 4344| 241k| (apply_apodization_state->a)++; 4345| 241k| } 4346| 245k| } 4347| 72.6M| else { 4348| | /* window part of subblock */ 4349| 72.6M| if(blocksize/apply_apodization_state->b <= FLAC__MAX_LPC_ORDER) { ------------------ | | 128| 72.6M|#define FLAC__MAX_LPC_ORDER (32u) ------------------ | Branch (4349:6): [True: 72.5M, False: 64.4k] ------------------ 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| 72.5M| 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| 72.5M| return false; 4357| 72.5M| } 4358| 64.4k| if(!(apply_apodization_state->c % 2)) { ------------------ | Branch (4358:6): [True: 34.9k, False: 29.5k] ------------------ 4359| | /* on even c, evaluate the (c/2)th partial window of size blocksize/b */ 4360| 34.9k| if(subframe_bps <= 32) ------------------ | Branch (4360:7): [True: 31.2k, False: 3.70k] ------------------ 4361| 31.2k| 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.70k| else 4363| 3.70k| 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| 34.9k| 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| 34.9k| } 4366| 29.5k| 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| 29.5k| uint32_t i; 4370| 343k| for(i = 0; i < *max_lpc_order_this_apodization; i++) ------------------ | Branch (4370:15): [True: 313k, False: 29.5k] ------------------ 4371| 313k| apply_apodization_state->autoc[i] = apply_apodization_state->autoc_root[i] - apply_apodization_state->autoc[i]; 4372| 29.5k| } 4373| | /* Next function sets a, b and c appropriate for next iteration */ 4374| 64.4k| 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| 64.4k| } 4376| | 4377| 309k| 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.34k, False: 306k] ------------------ 4378| 3.34k| return false; 4379| 306k| FLAC__lpc_compute_lp_coefficients(apply_apodization_state->autoc, max_lpc_order_this_apodization, threadtask->lp_coeff, lpc_error); 4380| 306k| *guess_lpc_order = 4381| 306k| FLAC__lpc_compute_best_order( 4382| 306k| lpc_error, 4383| 306k| *max_lpc_order_this_apodization, 4384| 306k| blocksize, 4385| 306k| subframe_bps + ( 4386| 306k| encoder->protected_->do_qlp_coeff_prec_search? ------------------ | Branch (4386:4): [True: 164k, False: 141k] ------------------ 4387| 164k| FLAC__MIN_QLP_COEFF_PRECISION : /* have to guess; use the min possible size to avoid accidentally favoring lower orders */ ------------------ | | 137| 164k|#define FLAC__MIN_QLP_COEFF_PRECISION (5u) ------------------ 4388| 306k| encoder->protected_->qlp_coeff_precision 4389| 306k| ) 4390| 306k| ); 4391| | return true; 4392| 309k|} stream_encoder.c:set_next_subdivide_tukey: 4293| 72.6M|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| 72.6M| if(*current_depth == 2){ ------------------ | Branch (4295:5): [True: 6.78k, False: 72.6M] ------------------ 4296| | // For depth 2, we only do partial, no punchout as that is almost redundant 4297| 6.78k| if(*current_part == 0){ ------------------ | Branch (4297:6): [True: 3.39k, False: 3.39k] ------------------ 4298| 3.39k| *current_part = 2; 4299| 3.39k| }else{ /* *current_path == 2 */ 4300| 3.39k| *current_part = 0; 4301| 3.39k| (*current_depth)++; 4302| 3.39k| } 4303| 72.6M| }else if((*current_part) < (2*(*current_depth)-1)){ ------------------ | Branch (4303:11): [True: 72.5M, False: 30.7k] ------------------ 4304| 72.5M| (*current_part)++; 4305| 72.5M| }else{ /* (*current_part) >= (2*(*current_depth)-1) */ 4306| 30.7k| *current_part = 0; 4307| 30.7k| (*current_depth)++; 4308| 30.7k| } 4309| | 4310| | /* Now check if we are done with this SUBDIVIDE_TUKEY apodization */ 4311| 72.6M| if(*current_depth > (uint32_t) parts){ ------------------ | Branch (4311:5): [True: 3.39k, False: 72.6M] ------------------ 4312| 3.39k| (*apodizations)++; 4313| 3.39k| *current_depth = 1; 4314| 3.39k| *current_part = 0; 4315| 3.39k| } 4316| 72.6M|} stream_encoder.c:evaluate_lpc_subframe_: 4584| 18.1M|{ 4585| 18.1M| FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER]; /* WATCHOUT: the size is important; some x86 intrinsic routines need more than lpc order elements */ 4586| 18.1M| uint32_t i, residual_bits, estimate; 4587| 18.1M| int quantization, ret; 4588| 18.1M| 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| 18.1M| if(subframe_bps <= 17) { ------------------ | Branch (4591:5): [True: 1.95M, False: 16.2M] ------------------ 4592| 1.95M| FLAC__ASSERT(order > 0); ------------------ | | 38| 1.95M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.95M] | | ------------------ ------------------ 4593| 1.95M| FLAC__ASSERT(order <= FLAC__MAX_LPC_ORDER); ------------------ | | 38| 1.95M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 1.95M] | | ------------------ ------------------ 4594| 1.95M| qlp_coeff_precision = flac_min(qlp_coeff_precision, 32 - subframe_bps - FLAC__bitmath_ilog2(order)); ------------------ | | 56| 1.95M|#define flac_min(a,b) MIN(a,b) ------------------ | Branch (4594:25): [True: 1.84M, False: 108k] ------------------ 4595| 1.95M| } 4596| | 4597| 18.1M| ret = FLAC__lpc_quantize_coefficients(lp_coeff, order, qlp_coeff_precision, qlp_coeff, &quantization); 4598| 18.1M| if(ret != 0) ------------------ | Branch (4598:5): [True: 656k, False: 17.5M] ------------------ 4599| 656k| 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| 17.5M| if(FLAC__lpc_max_residual_bps(subframe_bps, qlp_coeff, order, quantization) > 32) { ------------------ | Branch (4601:5): [True: 11.6M, False: 5.87M] ------------------ 4602| 11.6M| if(subframe_bps <= 32){ ------------------ | Branch (4602:6): [True: 10.5M, False: 1.05M] ------------------ 4603| 10.5M| 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.57M, False: 9.00M] ------------------ 4604| 1.57M| return 0; 4605| 10.5M| } 4606| 1.05M| else 4607| 1.05M| 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: 383k, False: 676k] ------------------ 4608| 383k| return 0; 4609| 11.6M| } 4610| 5.87M| else 4611| 5.87M| if(FLAC__lpc_max_prediction_before_shift_bps(subframe_bps, qlp_coeff, order) <= 32) ------------------ | Branch (4611:6): [True: 3.33M, False: 2.54M] ------------------ 4612| 3.33M| if(subframe_bps <= 16 && qlp_coeff_precision <= 16) ------------------ | Branch (4612:7): [True: 1.68M, False: 1.64M] | Branch (4612:29): [True: 1.68M, False: 0] ------------------ 4613| 1.68M| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_16bit(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual); 4614| 1.64M| else 4615| 1.64M| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual); 4616| 2.54M| else 4617| 2.54M| encoder->private_->local_lpc_compute_residual_from_qlp_coefficients_64bit(((FLAC__int32 *)signal)+order, residual_samples, qlp_coeff, order, quantization, residual); 4618| | 4619| 15.5M| subframe->type = FLAC__SUBFRAME_TYPE_LPC; 4620| | 4621| 15.5M| subframe->data.lpc.entropy_coding_method.type = FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE; 4622| 15.5M| subframe->data.lpc.entropy_coding_method.data.partitioned_rice.contents = partitioned_rice_contents; 4623| 15.5M| subframe->data.lpc.residual = residual; 4624| | 4625| 15.5M| residual_bits = 4626| 15.5M| find_best_partition_order_( 4627| 15.5M| encoder->private_, 4628| 15.5M| threadtask, 4629| 15.5M| residual, 4630| 15.5M| abs_residual_partition_sums, 4631| 15.5M| raw_bits_per_partition, 4632| 15.5M| residual_samples, 4633| 15.5M| order, 4634| 15.5M| rice_parameter_limit, 4635| 15.5M| min_partition_order, 4636| 15.5M| max_partition_order, 4637| 15.5M| subframe_bps, 4638| 15.5M| do_escape_coding, 4639| 15.5M| rice_parameter_search_dist, 4640| 15.5M| &subframe->data.lpc.entropy_coding_method 4641| 15.5M| ); 4642| | 4643| 15.5M| subframe->data.lpc.order = order; 4644| 15.5M| subframe->data.lpc.qlp_coeff_precision = qlp_coeff_precision; 4645| 15.5M| subframe->data.lpc.quantization_level = quantization; 4646| 15.5M| memcpy(subframe->data.lpc.qlp_coeff, qlp_coeff, sizeof(FLAC__int32)*FLAC__MAX_LPC_ORDER); ------------------ | | 128| 15.5M|#define FLAC__MAX_LPC_ORDER (32u) ------------------ 4647| 15.5M| if(subframe_bps <= 32) ------------------ | Branch (4647:5): [True: 14.7M, False: 815k] ------------------ 4648| 132M| for(i = 0; i < order; i++) ------------------ | Branch (4648:14): [True: 117M, False: 14.7M] ------------------ 4649| 117M| subframe->data.lpc.warmup[i] = ((FLAC__int32 *)signal)[i]; 4650| 815k| else 4651| 7.16M| for(i = 0; i < order; i++) ------------------ | Branch (4651:14): [True: 6.35M, False: 815k] ------------------ 4652| 6.35M| subframe->data.lpc.warmup[i] = ((FLAC__int64 *)signal)[i]; 4653| | 4654| | 4655| 15.5M| 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| 15.5M| if(residual_bits < UINT32_MAX - estimate) // To make sure estimate doesn't overflow ------------------ | Branch (4656:5): [True: 15.5M, False: 18.4E] ------------------ 4657| 15.5M| 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| 15.5M| return estimate; 4666| 17.5M|} stream_encoder.c:add_subframe_: 4402| 336k|{ 4403| 336k| switch(subframe->type) { 4404| 104k| case FLAC__SUBFRAME_TYPE_CONSTANT: ------------------ | Branch (4404:3): [True: 104k, False: 232k] ------------------ 4405| 104k| if(!FLAC__subframe_add_constant(&(subframe->data.constant), subframe_bps, subframe->wasted_bits, frame)) { ------------------ | Branch (4405:7): [True: 0, False: 104k] ------------------ 4406| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 4407| 0| return false; 4408| 0| } 4409| 104k| break; 4410| 168k| case FLAC__SUBFRAME_TYPE_FIXED: ------------------ | Branch (4410:3): [True: 168k, False: 168k] ------------------ 4411| 168k| 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: 168k] ------------------ 4412| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 4413| 0| return false; 4414| 0| } 4415| 168k| break; 4416| 168k| case FLAC__SUBFRAME_TYPE_LPC: ------------------ | Branch (4416:3): [True: 20.2k, False: 316k] ------------------ 4417| 20.2k| 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: 20.2k] ------------------ 4418| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 4419| 0| return false; 4420| 0| } 4421| 20.2k| break; 4422| 43.7k| case FLAC__SUBFRAME_TYPE_VERBATIM: ------------------ | Branch (4422:3): [True: 43.7k, False: 293k] ------------------ 4423| 43.7k| if(!FLAC__subframe_add_verbatim(&(subframe->data.verbatim), blocksize, subframe_bps, subframe->wasted_bits, frame)) { ------------------ | Branch (4423:7): [True: 0, False: 43.7k] ------------------ 4424| 0| encoder->protected_->state = FLAC__STREAM_ENCODER_FRAMING_ERROR; 4425| 0| return false; 4426| 0| } 4427| 43.7k| break; 4428| 43.7k| default: ------------------ | Branch (4428:3): [True: 0, False: 336k] ------------------ 4429| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 4430| 336k| } 4431| | 4432| 337k| return true; 4433| 336k|} stream_encoder.c:append_to_verify_fifo_interleaved_: 5139| 351k|{ 5140| 351k| uint32_t channel; 5141| 351k| uint32_t sample, wide_sample; 5142| 351k| uint32_t tail = fifo->tail; 5143| | 5144| 351k| sample = input_offset * channels; 5145| 22.5M| for(wide_sample = 0; wide_sample < wide_samples; wide_sample++) { ------------------ | Branch (5145:23): [True: 22.2M, False: 351k] ------------------ 5146| 50.3M| for(channel = 0; channel < channels; channel++) ------------------ | Branch (5146:20): [True: 28.1M, False: 22.2M] ------------------ 5147| 28.1M| fifo->data[channel][tail] = input[sample++]; 5148| 22.2M| tail++; 5149| 22.2M| } 5150| 351k| fifo->tail = tail; 5151| | 5152| 351k| FLAC__ASSERT(fifo->tail <= fifo->size); ------------------ | | 38| 351k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 351k] | | ------------------ ------------------ 5153| 351k|} FLAC__add_metadata_block: 48| 19.6k|{ 49| 19.6k| uint32_t i, j, metadata_length; 50| 19.6k| const uint32_t vendor_string_length = (uint32_t)strlen(FLAC__VENDOR_STRING); 51| 19.6k| const uint32_t start_bits = FLAC__bitwriter_get_input_bits_unconsumed(bw); 52| | 53| 19.6k| FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw)); ------------------ | | 38| 19.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.6k] | | ------------------ ------------------ 54| | 55| 19.6k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->is_last, FLAC__STREAM_METADATA_IS_LAST_LEN)) ------------------ | Branch (55:5): [True: 0, False: 19.6k] ------------------ 56| 0| return false; 57| | 58| 19.6k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata->type, FLAC__STREAM_METADATA_TYPE_LEN)) ------------------ | Branch (58:5): [True: 0, False: 19.6k] ------------------ 59| 0| return false; 60| | 61| | /* 62| | * First, for VORBIS_COMMENTs, adjust the length to reflect our vendor string 63| | */ 64| 19.6k| metadata_length = metadata->length; 65| 19.6k| if(metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT && update_vendor_string) { ------------------ | Branch (65:5): [True: 9.82k, False: 9.82k] | Branch (65:61): [True: 9.82k, False: 0] ------------------ 66| 9.82k| FLAC__ASSERT(metadata->data.vorbis_comment.vendor_string.length == 0 || 0 != metadata->data.vorbis_comment.vendor_string.entry); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 9.82k, False: 0] | | | Branch (38:30): [True: 0, False: 0] | | ------------------ ------------------ 67| 9.82k| metadata_length -= metadata->data.vorbis_comment.vendor_string.length; 68| 9.82k| metadata_length += vendor_string_length; 69| 9.82k| } 70| 19.6k| FLAC__ASSERT(metadata_length < (1u << FLAC__STREAM_METADATA_LENGTH_LEN)); ------------------ | | 38| 19.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.6k] | | ------------------ ------------------ 71| | /* double protection */ 72| 19.6k| if(metadata_length >= (1u << FLAC__STREAM_METADATA_LENGTH_LEN)) ------------------ | Branch (72:5): [True: 0, False: 19.6k] ------------------ 73| 0| return false; 74| 19.6k| if(!FLAC__bitwriter_write_raw_uint32(bw, metadata_length, FLAC__STREAM_METADATA_LENGTH_LEN)) ------------------ | Branch (74:5): [True: 0, False: 19.6k] ------------------ 75| 0| return false; 76| | 77| 19.6k| switch(metadata->type) { 78| 9.82k| case FLAC__METADATA_TYPE_STREAMINFO: ------------------ | Branch (78:3): [True: 9.82k, False: 9.82k] ------------------ 79| 9.82k| FLAC__ASSERT(metadata->data.stream_info.min_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN)); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 80| 9.82k| 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.82k] ------------------ 81| 0| return false; 82| 9.82k| FLAC__ASSERT(metadata->data.stream_info.max_blocksize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN)); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 83| 9.82k| 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.82k] ------------------ 84| 0| return false; 85| 9.82k| FLAC__ASSERT(metadata->data.stream_info.min_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 86| 9.82k| 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.82k] ------------------ 87| 0| return false; 88| 9.82k| FLAC__ASSERT(metadata->data.stream_info.max_framesize < (1u << FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 89| 9.82k| 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.82k] ------------------ 90| 0| return false; 91| 9.82k| FLAC__ASSERT(FLAC__format_sample_rate_is_valid(metadata->data.stream_info.sample_rate)); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 92| 9.82k| 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.82k] ------------------ 93| 0| return false; 94| 9.82k| FLAC__ASSERT(metadata->data.stream_info.channels > 0); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 95| 9.82k| FLAC__ASSERT(metadata->data.stream_info.channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN)); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 96| 9.82k| 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.82k] ------------------ 97| 0| return false; 98| 9.82k| FLAC__ASSERT(metadata->data.stream_info.bits_per_sample > 0); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 99| 9.82k| FLAC__ASSERT(metadata->data.stream_info.bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)); ------------------ | | 38| 9.82k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.82k] | | ------------------ ------------------ 100| 9.82k| 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.82k] ------------------ 101| 0| return false; 102| 9.82k| if(metadata->data.stream_info.total_samples >= (FLAC__U64L(1) << FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)){ ------------------ | | 102| 9.82k|#define FLAC__U64L(x) x##ULL ------------------ | Branch (102:7): [True: 0, False: 9.82k] ------------------ 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.82k| }else{ 106| 9.82k| 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.82k] ------------------ 107| 0| return false; 108| 9.82k| } 109| 9.82k| if(!FLAC__bitwriter_write_byte_block(bw, metadata->data.stream_info.md5sum, 16)) ------------------ | Branch (109:7): [True: 0, False: 9.82k] ------------------ 110| 0| return false; 111| 9.82k| break; 112| 9.82k| case FLAC__METADATA_TYPE_PADDING: ------------------ | Branch (112:3): [True: 0, False: 19.6k] ------------------ 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: 19.6k] ------------------ 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: 19.6k] ------------------ 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.82k| case FLAC__METADATA_TYPE_VORBIS_COMMENT: ------------------ | Branch (132:3): [True: 9.82k, False: 9.82k] ------------------ 133| 9.82k| if(update_vendor_string) { ------------------ | Branch (133:7): [True: 9.82k, False: 0] ------------------ 134| 9.82k| if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, vendor_string_length)) ------------------ | Branch (134:8): [True: 0, False: 9.82k] ------------------ 135| 0| return false; 136| 9.82k| if(!FLAC__bitwriter_write_byte_block(bw, (const FLAC__byte*)FLAC__VENDOR_STRING, vendor_string_length)) ------------------ | Branch (136:8): [True: 0, False: 9.82k] ------------------ 137| 0| return false; 138| 9.82k| } 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.82k| if(!FLAC__bitwriter_write_raw_uint32_little_endian(bw, metadata->data.vorbis_comment.num_comments)) ------------------ | Branch (145:7): [True: 0, False: 9.82k] ------------------ 146| 0| return false; 147| 9.82k| for(i = 0; i < metadata->data.vorbis_comment.num_comments; i++) { ------------------ | Branch (147:15): [True: 0, False: 9.82k] ------------------ 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.82k| break; 154| 9.82k| case FLAC__METADATA_TYPE_CUESHEET: ------------------ | Branch (154:3): [True: 0, False: 19.6k] ------------------ 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: 19.6k] ------------------ 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: 19.6k] ------------------ 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| 19.6k| } 230| | 231| | /* Now check whether metadata block length was correct */ 232| 19.6k| { 233| 19.6k| uint32_t length_in_bits = FLAC__bitwriter_get_input_bits_unconsumed(bw); 234| 19.6k| if(length_in_bits < start_bits) ------------------ | Branch (234:6): [True: 0, False: 19.6k] ------------------ 235| 0| return false; 236| 19.6k| length_in_bits -= start_bits; 237| 19.6k| if(length_in_bits % 8 != 0 || length_in_bits != (metadata_length*8+32)) ------------------ | Branch (237:6): [True: 0, False: 19.6k] | Branch (237:33): [True: 0, False: 19.6k] ------------------ 238| 0| return false; 239| 19.6k| } 240| | 241| 19.6k| FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw)); ------------------ | | 38| 19.6k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 19.6k] | | ------------------ ------------------ 242| | return true; 243| 19.6k|} FLAC__frame_add_header: 246| 266k|{ 247| 266k| uint32_t u, blocksize_hint, sample_rate_hint; 248| 266k| FLAC__byte crc; 249| | 250| 266k| FLAC__ASSERT(FLAC__bitwriter_is_byte_aligned(bw)); ------------------ | | 38| 266k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 266k] | | ------------------ ------------------ 251| | 252| 266k| if(!FLAC__bitwriter_write_raw_uint32(bw, FLAC__FRAME_HEADER_SYNC, FLAC__FRAME_HEADER_SYNC_LEN)) ------------------ | Branch (252:5): [True: 0, False: 266k] ------------------ 253| 0| return false; 254| | 255| 266k| if(!FLAC__bitwriter_write_raw_uint32(bw, 0, FLAC__FRAME_HEADER_RESERVED_LEN)) ------------------ | Branch (255:5): [True: 0, False: 266k] ------------------ 256| 0| return false; 257| | 258| 266k| 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: 266k] | Branch (258:43): [True: 266k, False: 75] ------------------ 259| 0| return false; 260| | 261| 266k| FLAC__ASSERT(header->blocksize > 0 && header->blocksize <= FLAC__MAX_BLOCK_SIZE); ------------------ | | 38| 533k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 266k, False: 22] | | | Branch (38:30): [True: 266k, False: 18.4E] | | ------------------ ------------------ 262| | /* when this assertion holds true, any legal blocksize can be expressed in the frame header */ 263| 266k| FLAC__ASSERT(FLAC__MAX_BLOCK_SIZE <= 65535u); ------------------ | | 38| 266k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [Folded, False: 266k] | | ------------------ ------------------ 264| 266k| blocksize_hint = 0; 265| 266k| switch(header->blocksize) { 266| 196| case 192: u = 1; break; ------------------ | Branch (266:3): [True: 196, False: 266k] ------------------ 267| 195| case 576: u = 2; break; ------------------ | Branch (267:3): [True: 195, False: 266k] ------------------ 268| 133| case 1152: u = 3; break; ------------------ | Branch (268:3): [True: 133, False: 266k] ------------------ 269| 67| case 2304: u = 4; break; ------------------ | Branch (269:3): [True: 67, False: 266k] ------------------ 270| 51| case 4608: u = 5; break; ------------------ | Branch (270:3): [True: 51, False: 266k] ------------------ 271| 218| case 256: u = 8; break; ------------------ | Branch (271:3): [True: 218, False: 266k] ------------------ 272| 223| case 512: u = 9; break; ------------------ | Branch (272:3): [True: 223, False: 266k] ------------------ 273| 152| case 1024: u = 10; break; ------------------ | Branch (273:3): [True: 152, False: 266k] ------------------ 274| 109| case 2048: u = 11; break; ------------------ | Branch (274:3): [True: 109, False: 266k] ------------------ 275| 195| case 4096: u = 12; break; ------------------ | Branch (275:3): [True: 195, False: 266k] ------------------ 276| 33| case 8192: u = 13; break; ------------------ | Branch (276:3): [True: 33, False: 266k] ------------------ 277| 36| case 16384: u = 14; break; ------------------ | Branch (277:3): [True: 36, False: 266k] ------------------ 278| 18| case 32768: u = 15; break; ------------------ | Branch (278:3): [True: 18, False: 266k] ------------------ 279| 265k| default: ------------------ | Branch (279:3): [True: 265k, False: 1.66k] ------------------ 280| 265k| if(header->blocksize <= 0x100) ------------------ | Branch (280:7): [True: 263k, False: 1.89k] ------------------ 281| 263k| blocksize_hint = u = 6; 282| 1.89k| else 283| 1.89k| blocksize_hint = u = 7; 284| 265k| break; 285| 266k| } 286| 266k| if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_BLOCK_SIZE_LEN)) ------------------ | Branch (286:5): [True: 0, False: 266k] ------------------ 287| 0| return false; 288| | 289| 266k| FLAC__ASSERT(FLAC__format_sample_rate_is_valid(header->sample_rate)); ------------------ | | 38| 266k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 266k] | | ------------------ ------------------ 290| 266k| sample_rate_hint = 0; 291| 266k| switch(header->sample_rate) { 292| 239| case 88200: u = 1; break; ------------------ | Branch (292:3): [True: 239, False: 266k] ------------------ 293| 594| case 176400: u = 2; break; ------------------ | Branch (293:3): [True: 594, False: 266k] ------------------ 294| 2.52k| case 192000: u = 3; break; ------------------ | Branch (294:3): [True: 2.52k, False: 264k] ------------------ 295| 1.61k| case 8000: u = 4; break; ------------------ | Branch (295:3): [True: 1.61k, False: 265k] ------------------ 296| 234| case 16000: u = 5; break; ------------------ | Branch (296:3): [True: 234, False: 266k] ------------------ 297| 6.58k| case 22050: u = 6; break; ------------------ | Branch (297:3): [True: 6.58k, False: 260k] ------------------ 298| 387| case 24000: u = 7; break; ------------------ | Branch (298:3): [True: 387, False: 266k] ------------------ 299| 9.62k| case 32000: u = 8; break; ------------------ | Branch (299:3): [True: 9.62k, False: 257k] ------------------ 300| 33.2k| case 44100: u = 9; break; ------------------ | Branch (300:3): [True: 33.2k, False: 233k] ------------------ 301| 251| case 48000: u = 10; break; ------------------ | Branch (301:3): [True: 251, False: 266k] ------------------ 302| 19.7k| case 96000: u = 11; break; ------------------ | Branch (302:3): [True: 19.7k, False: 247k] ------------------ 303| 191k| default: ------------------ | Branch (303:3): [True: 191k, False: 75.0k] ------------------ 304| 191k| if(header->sample_rate <= 255000 && header->sample_rate % 1000 == 0) ------------------ | Branch (304:7): [True: 179k, False: 11.9k] | Branch (304:40): [True: 21.6k, False: 158k] ------------------ 305| 21.6k| sample_rate_hint = u = 12; 306| 170k| else if(header->sample_rate <= 655350 && header->sample_rate % 10 == 0) ------------------ | Branch (306:12): [True: 165k, False: 4.37k] | Branch (306:45): [True: 42.0k, False: 123k] ------------------ 307| 42.0k| sample_rate_hint = u = 14; 308| 128k| else if(header->sample_rate <= 0xffff) ------------------ | Branch (308:12): [True: 100k, False: 27.7k] ------------------ 309| 100k| sample_rate_hint = u = 13; 310| 27.7k| else 311| 27.7k| u = 0; 312| 191k| break; 313| 266k| } 314| 266k| if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_SAMPLE_RATE_LEN)) ------------------ | Branch (314:5): [True: 0, False: 266k] ------------------ 315| 0| return false; 316| | 317| 266k| FLAC__ASSERT(header->channels > 0 && header->channels <= (1u << FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN) && header->channels <= FLAC__MAX_CHANNELS); ------------------ | | 38| 1.06M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 266k, False: 18.4E] | | | Branch (38:30): [True: 266k, False: 49] | | | Branch (38:30): [True: 266k, False: 18.4E] | | ------------------ ------------------ 318| 266k| switch(header->channel_assignment) { 319| 234k| case FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT: ------------------ | Branch (319:3): [True: 234k, False: 32.1k] ------------------ 320| 234k| u = header->channels - 1; 321| 234k| break; 322| 14.3k| case FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE: ------------------ | Branch (322:3): [True: 14.3k, False: 252k] ------------------ 323| 14.3k| FLAC__ASSERT(header->channels == 2); ------------------ | | 38| 14.3k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 14.3k] | | ------------------ ------------------ 324| 14.3k| u = 8; 325| 14.3k| break; 326| 6.83k| case FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE: ------------------ | Branch (326:3): [True: 6.83k, False: 260k] ------------------ 327| 6.83k| FLAC__ASSERT(header->channels == 2); ------------------ | | 38| 6.83k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 6.83k] | | ------------------ ------------------ 328| 6.83k| u = 9; 329| 6.83k| break; 330| 10.9k| case FLAC__CHANNEL_ASSIGNMENT_MID_SIDE: ------------------ | Branch (330:3): [True: 10.9k, False: 255k] ------------------ 331| 10.9k| FLAC__ASSERT(header->channels == 2); ------------------ | | 38| 10.9k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 10.9k] | | ------------------ ------------------ 332| 10.9k| u = 10; 333| 10.9k| break; 334| 0| default: ------------------ | Branch (334:3): [True: 0, False: 266k] ------------------ 335| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 336| 266k| } 337| 266k| if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN)) ------------------ | Branch (337:5): [True: 0, False: 266k] ------------------ 338| 0| return false; 339| | 340| 266k| FLAC__ASSERT(header->bits_per_sample > 0 && header->bits_per_sample <= (1u << FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN)); ------------------ | | 38| 534k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:30): [True: 267k, False: 18.4E] | | | Branch (38:30): [True: 266k, False: 142] | | ------------------ ------------------ 341| 266k| switch(header->bits_per_sample) { 342| 3.75k| case 8 : u = 1; break; ------------------ | Branch (342:3): [True: 3.75k, False: 263k] ------------------ 343| 269| case 12: u = 2; break; ------------------ | Branch (343:3): [True: 269, False: 266k] ------------------ 344| 5.25k| case 16: u = 4; break; ------------------ | Branch (344:3): [True: 5.25k, False: 261k] ------------------ 345| 550| case 20: u = 5; break; ------------------ | Branch (345:3): [True: 550, False: 266k] ------------------ 346| 10.8k| case 24: u = 6; break; ------------------ | Branch (346:3): [True: 10.8k, False: 256k] ------------------ 347| 241k| case 32: u = 7; break; ------------------ | Branch (347:3): [True: 241k, False: 25.0k] ------------------ 348| 4.44k| default: u = 0; break; ------------------ | Branch (348:3): [True: 4.44k, False: 262k] ------------------ 349| 266k| } 350| 267k| if(!FLAC__bitwriter_write_raw_uint32(bw, u, FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN)) ------------------ | Branch (350:5): [True: 0, False: 267k] ------------------ 351| 0| return false; 352| | 353| 267k| if(!FLAC__bitwriter_write_raw_uint32(bw, 0, FLAC__FRAME_HEADER_ZERO_PAD_LEN)) ------------------ | Branch (353:5): [True: 0, False: 267k] ------------------ 354| 0| return false; 355| | 356| 267k| if(header->number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER) { ------------------ | Branch (356:5): [True: 267k, False: 18.4E] ------------------ 357| 267k| if(!FLAC__bitwriter_write_utf8_uint32(bw, header->number.frame_number)) ------------------ | Branch (357:6): [True: 0, False: 267k] ------------------ 358| 0| return false; 359| 267k| } 360| 18.4E| else { 361| 18.4E| if(!FLAC__bitwriter_write_utf8_uint64(bw, header->number.sample_number)) ------------------ | Branch (361:6): [True: 0, False: 18.4E] ------------------ 362| 0| return false; 363| 18.4E| } 364| | 365| 267k| if(blocksize_hint) ------------------ | Branch (365:5): [True: 265k, False: 1.48k] ------------------ 366| 265k| if(!FLAC__bitwriter_write_raw_uint32(bw, header->blocksize-1, (blocksize_hint==6)? 8:16)) ------------------ | Branch (366:6): [True: 0, False: 265k] | Branch (366:65): [True: 263k, False: 1.83k] ------------------ 367| 0| return false; 368| | 369| 267k| switch(sample_rate_hint) { ------------------ | Branch (369:9): [True: 164k, False: 102k] ------------------ 370| 21.6k| case 12: ------------------ | Branch (370:3): [True: 21.6k, False: 245k] ------------------ 371| 21.6k| if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate / 1000, 8)) ------------------ | Branch (371:7): [True: 0, False: 21.6k] ------------------ 372| 0| return false; 373| 21.6k| break; 374| 100k| case 13: ------------------ | Branch (374:3): [True: 100k, False: 166k] ------------------ 375| 100k| if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate, 16)) ------------------ | Branch (375:7): [True: 0, False: 100k] ------------------ 376| 0| return false; 377| 100k| break; 378| 100k| case 14: ------------------ | Branch (378:3): [True: 42.0k, False: 224k] ------------------ 379| 42.0k| if(!FLAC__bitwriter_write_raw_uint32(bw, header->sample_rate / 10, 16)) ------------------ | Branch (379:7): [True: 0, False: 42.0k] ------------------ 380| 0| return false; 381| 42.0k| break; 382| 267k| } 383| | 384| | /* write the CRC */ 385| 266k| if(!FLAC__bitwriter_get_write_crc8(bw, &crc)) ------------------ | Branch (385:5): [True: 0, False: 266k] ------------------ 386| 0| return false; 387| 266k| if(!FLAC__bitwriter_write_raw_uint32(bw, crc, FLAC__FRAME_HEADER_CRC_LEN)) ------------------ | Branch (387:5): [True: 0, False: 266k] ------------------ 388| 0| return false; 389| | 390| 266k| return true; 391| 266k|} FLAC__subframe_add_constant: 394| 104k|{ 395| 104k| FLAC__bool ok; 396| | 397| 104k| ok = 398| 104k| 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: 104k, False: 18.4E] | Branch (398:90): [True: 1.34k, False: 102k] ------------------ 399| 104k| (wasted_bits? FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1) : true) && ------------------ | Branch (399:3): [True: 104k, False: 5] | Branch (399:4): [True: 1.34k, False: 102k] ------------------ 400| 104k| FLAC__bitwriter_write_raw_int64(bw, subframe->value, subframe_bps) ------------------ | Branch (400:3): [True: 104k, False: 18.4E] ------------------ 401| 104k| ; 402| | 403| 104k| return ok; 404| 104k|} FLAC__subframe_add_fixed: 407| 168k|{ 408| 168k| uint32_t i; 409| | 410| 168k| 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: 168k] | Branch (410:113): [True: 16.3k, False: 152k] ------------------ 411| 0| return false; 412| 168k| if(wasted_bits) ------------------ | Branch (412:5): [True: 16.3k, False: 152k] ------------------ 413| 16.3k| if(!FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1)) ------------------ | Branch (413:6): [True: 0, False: 16.3k] ------------------ 414| 0| return false; 415| | 416| 300k| for(i = 0; i < subframe->order; i++) ------------------ | Branch (416:13): [True: 132k, False: 168k] ------------------ 417| 132k| if(!FLAC__bitwriter_write_raw_int64(bw, subframe->warmup[i], subframe_bps)) ------------------ | Branch (417:6): [True: 0, False: 132k] ------------------ 418| 0| return false; 419| | 420| 168k| if(!add_entropy_coding_method_(bw, &subframe->entropy_coding_method)) ------------------ | Branch (420:5): [True: 0, False: 168k] ------------------ 421| 0| return false; 422| 168k| switch(subframe->entropy_coding_method.type) { 423| 88.3k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (423:3): [True: 88.3k, False: 80.2k] ------------------ 424| 168k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (424:3): [True: 80.4k, False: 88.1k] ------------------ 425| 168k| if(!add_residual_partitioned_rice_( ------------------ | Branch (425:7): [True: 0, False: 168k] ------------------ 426| 168k| bw, 427| 168k| subframe->residual, 428| 168k| residual_samples, 429| 168k| subframe->order, 430| 168k| subframe->entropy_coding_method.data.partitioned_rice.contents->parameters, 431| 168k| subframe->entropy_coding_method.data.partitioned_rice.contents->raw_bits, 432| 168k| subframe->entropy_coding_method.data.partitioned_rice.order, 433| 168k| /*is_extended=*/subframe->entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 434| 168k| )) 435| 0| return false; 436| 168k| break; 437| 168k| default: ------------------ | Branch (437:3): [True: 0, False: 168k] ------------------ 438| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 439| 168k| } 440| | 441| 168k| return true; 442| 168k|} FLAC__subframe_add_lpc: 445| 20.2k|{ 446| 20.2k| uint32_t i; 447| | 448| 20.2k| 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: 20.2k] | Branch (448:115): [True: 6.22k, False: 13.9k] ------------------ 449| 0| return false; 450| 20.2k| if(wasted_bits) ------------------ | Branch (450:5): [True: 6.22k, False: 13.9k] ------------------ 451| 6.22k| if(!FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1)) ------------------ | Branch (451:6): [True: 0, False: 6.22k] ------------------ 452| 0| return false; 453| | 454| 124k| for(i = 0; i < subframe->order; i++) ------------------ | Branch (454:13): [True: 104k, False: 20.2k] ------------------ 455| 104k| if(!FLAC__bitwriter_write_raw_int64(bw, subframe->warmup[i], subframe_bps)) ------------------ | Branch (455:6): [True: 0, False: 104k] ------------------ 456| 0| return false; 457| | 458| 20.2k| 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: 20.2k] ------------------ 459| 0| return false; 460| 20.2k| if(!FLAC__bitwriter_write_raw_int32(bw, subframe->quantization_level, FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN)) ------------------ | Branch (460:5): [True: 0, False: 20.2k] ------------------ 461| 0| return false; 462| 124k| for(i = 0; i < subframe->order; i++) ------------------ | Branch (462:13): [True: 104k, False: 20.2k] ------------------ 463| 104k| if(!FLAC__bitwriter_write_raw_int32(bw, subframe->qlp_coeff[i], subframe->qlp_coeff_precision)) ------------------ | Branch (463:6): [True: 0, False: 104k] ------------------ 464| 0| return false; 465| | 466| 20.2k| if(!add_entropy_coding_method_(bw, &subframe->entropy_coding_method)) ------------------ | Branch (466:5): [True: 0, False: 20.2k] ------------------ 467| 0| return false; 468| 20.2k| switch(subframe->entropy_coding_method.type) { 469| 13.2k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (469:3): [True: 13.2k, False: 6.99k] ------------------ 470| 20.2k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (470:3): [True: 6.99k, False: 13.2k] ------------------ 471| 20.2k| if(!add_residual_partitioned_rice_( ------------------ | Branch (471:7): [True: 0, False: 20.2k] ------------------ 472| 20.2k| bw, 473| 20.2k| subframe->residual, 474| 20.2k| residual_samples, 475| 20.2k| subframe->order, 476| 20.2k| subframe->entropy_coding_method.data.partitioned_rice.contents->parameters, 477| 20.2k| subframe->entropy_coding_method.data.partitioned_rice.contents->raw_bits, 478| 20.2k| subframe->entropy_coding_method.data.partitioned_rice.order, 479| 20.2k| /*is_extended=*/subframe->entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 480| 20.2k| )) 481| 0| return false; 482| 20.2k| break; 483| 20.2k| default: ------------------ | Branch (483:3): [True: 0, False: 20.2k] ------------------ 484| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 485| 20.2k| } 486| | 487| 20.2k| return true; 488| 20.2k|} FLAC__subframe_add_verbatim: 491| 43.7k|{ 492| 43.7k| uint32_t i; 493| | 494| 43.7k| 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: 43.7k] | Branch (494:93): [True: 2.24k, False: 41.5k] ------------------ 495| 0| return false; 496| 43.7k| if(wasted_bits) ------------------ | Branch (496:5): [True: 2.24k, False: 41.5k] ------------------ 497| 2.24k| if(!FLAC__bitwriter_write_unary_unsigned(bw, wasted_bits-1)) ------------------ | Branch (497:6): [True: 0, False: 2.24k] ------------------ 498| 0| return false; 499| | 500| 43.7k| if(subframe->data_type == FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32) { ------------------ | Branch (500:5): [True: 42.8k, False: 920] ------------------ 501| 42.8k| const FLAC__int32 *signal = subframe->data.int32; 502| | 503| 42.8k| FLAC__ASSERT(subframe_bps < 33); ------------------ | | 38| 42.8k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 42.8k] | | ------------------ ------------------ 504| | 505| 3.25M| for(i = 0; i < samples; i++) ------------------ | Branch (505:14): [True: 3.21M, False: 42.8k] ------------------ 506| 3.21M| if(!FLAC__bitwriter_write_raw_int32(bw, signal[i], subframe_bps)) ------------------ | Branch (506:7): [True: 0, False: 3.21M] ------------------ 507| 0| return false; 508| 42.8k| } 509| 920| else { 510| 920| const FLAC__int64 *signal = subframe->data.int64; 511| | 512| 920| FLAC__ASSERT(subframe_bps == 33); ------------------ | | 38| 920|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 920] | | ------------------ ------------------ 513| | 514| 1.79M| for(i = 0; i < samples; i++) ------------------ | Branch (514:14): [True: 1.79M, False: 920] ------------------ 515| 1.79M| if(!FLAC__bitwriter_write_raw_int64(bw, (FLAC__int64)signal[i], subframe_bps)) ------------------ | Branch (515:7): [True: 0, False: 1.79M] ------------------ 516| 0| return false; 517| 920| } 518| | 519| 43.7k| return true; 520| 43.7k|} stream_encoder_framing.c:add_entropy_coding_method_: 523| 189k|{ 524| 189k| if(!FLAC__bitwriter_write_raw_uint32(bw, method->type, FLAC__ENTROPY_CODING_METHOD_TYPE_LEN)) ------------------ | Branch (524:5): [True: 0, False: 189k] ------------------ 525| 0| return false; 526| 189k| switch(method->type) { 527| 101k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE: ------------------ | Branch (527:3): [True: 101k, False: 87.3k] ------------------ 528| 189k| case FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2: ------------------ | Branch (528:3): [True: 87.4k, False: 101k] ------------------ 529| 189k| 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: 189k] ------------------ 530| 0| return false; 531| 189k| break; 532| 189k| default: ------------------ | Branch (532:3): [True: 0, False: 189k] ------------------ 533| 0| FLAC__ASSERT(0); ------------------ | | 38| 0|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, Folded] | | ------------------ ------------------ 534| 189k| } 535| 188k| return true; 536| 189k|} stream_encoder_framing.c:add_residual_partitioned_rice_: 539| 188k|{ 540| 188k| 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: 87.4k, False: 101k] ------------------ 541| 188k| 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: 87.4k, False: 101k] ------------------ 542| | 543| 188k| if(partition_order == 0) { ------------------ | Branch (543:5): [True: 115k, False: 73.2k] ------------------ 544| 115k| uint32_t i; 545| | 546| 115k| if(raw_bits[0] == 0) { ------------------ | Branch (546:6): [True: 106k, False: 9.50k] ------------------ 547| 106k| if(!FLAC__bitwriter_write_raw_uint32(bw, rice_parameters[0], plen)) ------------------ | Branch (547:7): [True: 0, False: 106k] ------------------ 548| 0| return false; 549| 106k| if(!FLAC__bitwriter_write_rice_signed_block(bw, residual, residual_samples, rice_parameters[0])) ------------------ | Branch (549:7): [True: 0, False: 106k] ------------------ 550| 0| return false; 551| 106k| } 552| 9.50k| else { 553| 9.50k| FLAC__ASSERT(rice_parameters[0] == 0); ------------------ | | 38| 9.50k|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 9.50k] | | ------------------ ------------------ 554| 9.50k| if(!FLAC__bitwriter_write_raw_uint32(bw, pesc, plen)) ------------------ | Branch (554:7): [True: 0, False: 9.50k] ------------------ 555| 0| return false; 556| 9.50k| if(!FLAC__bitwriter_write_raw_uint32(bw, raw_bits[0], FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN)) ------------------ | Branch (556:7): [True: 0, False: 9.50k] ------------------ 557| 0| return false; 558| 150k| for(i = 0; i < residual_samples; i++) { ------------------ | Branch (558:15): [True: 141k, False: 9.50k] ------------------ 559| 141k| if(!FLAC__bitwriter_write_raw_int32(bw, residual[i], raw_bits[0])) ------------------ | Branch (559:8): [True: 0, False: 141k] ------------------ 560| 0| return false; 561| 141k| } 562| 9.50k| } 563| 115k| return true; 564| 115k| } 565| 73.2k| else { 566| 73.2k| uint32_t i, j, k = 0, k_last = 0; 567| 73.2k| uint32_t partition_samples; 568| 73.2k| const uint32_t default_partition_samples = (residual_samples+predictor_order) >> partition_order; 569| 1.71M| for(i = 0; i < (1u<> max_partition_order; 54| 16.2M| uint32_t partitions = 1u << max_partition_order; 55| | 56| 16.2M| FLAC__ASSERT(default_partition_samples > predictor_order); ------------------ | | 38| 16.2M|#define FLAC__ASSERT(x) if(!(x)) __builtin_abort(); | | ------------------ | | | Branch (38:28): [True: 0, False: 16.2M] | | ------------------ ------------------ 57| | 58| | /* first do max_partition_order */ 59| 16.2M| { 60| 16.2M| const uint32_t threshold = 32 - FLAC__bitmath_ilog2(default_partition_samples); 61| 16.2M| uint32_t partition, residual_sample, end = (uint32_t)(-(int32_t)predictor_order); 62| | 63| 16.2M| if(bps + FLAC__MAX_EXTRA_RESIDUAL_BPS < threshold) { ------------------ | | 44| 16.2M|#define FLAC__MAX_EXTRA_RESIDUAL_BPS 4 ------------------ | Branch (63:6): [True: 2.60M, False: 13.6M] ------------------ 64| 10.3M| for(partition = residual_sample = 0; partition < partitions; partition++) { ------------------ | Branch (64:41): [True: 7.76M, False: 2.60M] ------------------ 65| 7.76M| __m256i sum256 = _mm256_setzero_si256(); 66| 7.76M| __m128i sum128; 67| 7.76M| end += default_partition_samples; 68| | 69| 63.0M| for( ; (int)residual_sample < (int)end-7; residual_sample+=8) { ------------------ | Branch (69:12): [True: 55.2M, False: 7.76M] ------------------ 70| 55.2M| __m256i res256 = _mm256_abs_epi32(_mm256_loadu_si256((const __m256i*)(const void*)(residual+residual_sample))); 71| 55.2M| sum256 = _mm256_add_epi32(sum256, res256); 72| 55.2M| } 73| | 74| 7.76M| sum128 = _mm_add_epi32(_mm256_extracti128_si256(sum256, 1), _mm256_castsi256_si128(sum256)); 75| | 76| 10.5M| for( ; (int)residual_sample < (int)end-3; residual_sample+=4) { ------------------ | Branch (76:12): [True: 2.77M, False: 7.76M] ------------------ 77| 2.77M| __m128i res128 = _mm_abs_epi32(_mm_loadu_si128((const __m128i*)(const void*)(residual+residual_sample))); 78| 2.77M| sum128 = _mm_add_epi32(sum128, res128); 79| 2.77M| } 80| | 81| 17.2M| for( ; residual_sample < end; residual_sample++) { ------------------ | Branch (81:12): [True: 9.52M, False: 7.76M] ------------------ 82| 9.52M| __m128i res128 = _mm_abs_epi32(_mm_cvtsi32_si128(residual[residual_sample])); 83| 9.52M| sum128 = _mm_add_epi32(sum128, res128); 84| 9.52M| } 85| | 86| 7.76M| sum128 = _mm_add_epi32(sum128, _mm_shuffle_epi32(sum128, _MM_SHUFFLE(1,0,3,2))); 87| 7.76M| sum128 = _mm_add_epi32(sum128, _mm_shufflelo_epi16(sum128, _MM_SHUFFLE(1,0,3,2))); 88| 7.76M| 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| 7.76M| } 94| 2.60M| } 95| 13.6M| else { /* have to pessimistically use 64 bits for accumulator */ 96| 47.1M| for(partition = residual_sample = 0; partition < partitions; partition++) { ------------------ | Branch (96:41): [True: 33.4M, False: 13.6M] ------------------ 97| 33.4M| __m256i sum256 = _mm256_setzero_si256(); 98| 33.4M| __m128i sum128; 99| 33.4M| end += default_partition_samples; 100| | 101| 398M| for( ; (int)residual_sample < (int)end-3; residual_sample+=4) { ------------------ | Branch (101:12): [True: 364M, False: 33.4M] ------------------ 102| 364M| __m128i res128 = _mm_abs_epi32(_mm_loadu_si128((const __m128i*)(const void*)(residual+residual_sample))); 103| 364M| __m256i res256 = _mm256_cvtepu32_epi64(res128); 104| 364M| sum256 = _mm256_add_epi64(sum256, res256); 105| 364M| } 106| | 107| 33.4M| sum128 = _mm_add_epi64(_mm256_extracti128_si256(sum256, 1), _mm256_castsi256_si128(sum256)); 108| | 109| 45.3M| for( ; (int)residual_sample < (int)end-1; residual_sample+=2) { ------------------ | Branch (109:12): [True: 11.8M, False: 33.4M] ------------------ 110| 11.8M| __m128i res128 = _mm_abs_epi32(_mm_loadl_epi64((const __m128i*)(const void*)(residual+residual_sample))); 111| 11.8M| res128 = _mm_cvtepu32_epi64(res128); 112| 11.8M| sum128 = _mm_add_epi64(sum128, res128); 113| 11.8M| } 114| | 115| 47.1M| for( ; residual_sample < end; residual_sample++) { ------------------ | Branch (115:12): [True: 13.7M, False: 33.4M] ------------------ 116| 13.7M| __m128i res128 = _mm_abs_epi32(_mm_cvtsi32_si128(residual[residual_sample])); 117| 13.7M| sum128 = _mm_add_epi64(sum128, res128); 118| 13.7M| } 119| | 120| 33.4M| sum128 = _mm_add_epi64(sum128, _mm_srli_si128(sum128, 8)); 121| 33.4M| _mm_storel_epi64((__m128i*)(void*)(abs_residual_partition_sums+partition), sum128); 122| 33.4M| } 123| 13.6M| } 124| 16.2M| } 125| | 126| | /* now merge partitions for lower orders */ 127| 16.2M| { 128| 16.2M| uint32_t from_partition = 0, to_partition = partitions; 129| 16.2M| int partition_order; 130| 17.2M| for(partition_order = (int)max_partition_order - 1; partition_order >= (int)min_partition_order; partition_order--) { ------------------ | Branch (130:55): [True: 984k, False: 16.2M] ------------------ 131| 984k| uint32_t i; 132| 984k| partitions >>= 1; 133| 3.47M| for(i = 0; i < partitions; i++) { ------------------ | Branch (133:15): [True: 2.49M, False: 984k] ------------------ 134| 2.49M| abs_residual_partition_sums[to_partition++] = 135| 2.49M| abs_residual_partition_sums[from_partition ] + 136| 2.49M| abs_residual_partition_sums[from_partition+1]; 137| 2.49M| from_partition += 2; 138| 2.49M| } 139| 984k| } 140| 16.2M| } 141| 16.2M| _mm256_zeroupper(); 142| 16.2M|} FLAC__window_bartlett: 51| 765|{ 52| 765| const FLAC__int32 N = L - 1; 53| 765| FLAC__int32 n; 54| | 55| 765| if (L & 1) { ------------------ | Branch (55:6): [True: 384, False: 381] ------------------ 56| 2.74M| for (n = 0; n <= N/2; n++) ------------------ | Branch (56:15): [True: 2.74M, False: 384] ------------------ 57| 2.74M| window[n] = 2.0f * n / (float)N; 58| 2.74M| for (; n <= N; n++) ------------------ | Branch (58:10): [True: 2.74M, False: 384] ------------------ 59| 2.74M| window[n] = 2.0f - 2.0f * n / (float)N; 60| 384| } 61| 381| else { 62| 2.82M| for (n = 0; n <= L/2-1; n++) ------------------ | Branch (62:15): [True: 2.82M, False: 381] ------------------ 63| 2.82M| window[n] = 2.0f * n / (float)N; 64| 2.82M| for (; n <= N; n++) ------------------ | Branch (64:10): [True: 2.82M, False: 381] ------------------ 65| 2.82M| window[n] = 2.0f - 2.0f * n / (float)N; 66| 381| } 67| 765|} FLAC__window_bartlett_hann: 70| 93|{ 71| 93| const FLAC__int32 N = L - 1; 72| 93| FLAC__int32 n; 73| | 74| 719k| for (n = 0; n < L; n++) ------------------ | Branch (74:14): [True: 719k, False: 93] ------------------ 75| 719k| 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| 93|} FLAC__window_blackman: 79| 115|{ 80| 115| const FLAC__int32 N = L - 1; 81| 115| FLAC__int32 n; 82| | 83| 1.18M| for (n = 0; n < L; n++) ------------------ | Branch (83:14): [True: 1.18M, False: 115] ------------------ 84| 1.18M| 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| 115|} FLAC__window_blackman_harris_4term_92db_sidelobe: 89| 91|{ 90| 91| const FLAC__int32 N = L - 1; 91| 91| FLAC__int32 n; 92| | 93| 874k| for (n = 0; n <= N; n++) ------------------ | Branch (93:14): [True: 874k, False: 91] ------------------ 94| 874k| 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| 91|} FLAC__window_connes: 98| 220|{ 99| 220| const FLAC__int32 N = L - 1; 100| 220| const double N2 = (double)N / 2.; 101| 220| FLAC__int32 n; 102| | 103| 4.03M| for (n = 0; n <= N; n++) { ------------------ | Branch (103:14): [True: 4.03M, False: 220] ------------------ 104| 4.03M| double k = ((double)n - N2) / N2; 105| 4.03M| k = 1.0f - k * k; 106| 4.03M| window[n] = (FLAC__real)(k * k); 107| 4.03M| } 108| 220|} FLAC__window_flattop: 111| 143|{ 112| 143| const FLAC__int32 N = L - 1; 113| 143| FLAC__int32 n; 114| | 115| 1.71M| for (n = 0; n < L; n++) ------------------ | Branch (115:14): [True: 1.71M, False: 143] ------------------ 116| 1.71M| 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| 143|} FLAC__window_gauss: 120| 192|{ 121| 192| const FLAC__int32 N = L - 1; 122| 192| const double N2 = (double)N / 2.; 123| 192| FLAC__int32 n; 124| | 125| 192| if(!(stddev > 0.0f && stddev <= 0.5f)) ------------------ | Branch (125:7): [True: 192, False: 0] | Branch (125:24): [True: 192, 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| 192| else { 130| 3.36M| for (n = 0; n <= N; n++) { ------------------ | Branch (130:15): [True: 3.36M, False: 192] ------------------ 131| 3.36M| const double k = ((double)n - N2) / (stddev * N2); 132| 3.36M| window[n] = (FLAC__real)exp(-0.5f * k * k); 133| 3.36M| } 134| 192| } 135| 192|} FLAC__window_hamming: 138| 310|{ 139| 310| const FLAC__int32 N = L - 1; 140| 310| FLAC__int32 n; 141| | 142| 2.96M| for (n = 0; n < L; n++) ------------------ | Branch (142:14): [True: 2.96M, False: 310] ------------------ 143| 2.96M| window[n] = (FLAC__real)(0.54f - 0.46f * cosf(2.0f * M_PI * n / N)); 144| 310|} FLAC__window_hann: 147| 763|{ 148| 763| const FLAC__int32 N = L - 1; 149| 763| FLAC__int32 n; 150| | 151| 15.8M| for (n = 0; n < L; n++) ------------------ | Branch (151:14): [True: 15.8M, False: 763] ------------------ 152| 15.8M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(2.0f * M_PI * n / N)); 153| 763|} FLAC__window_kaiser_bessel: 156| 107|{ 157| 107| const FLAC__int32 N = L - 1; 158| 107| FLAC__int32 n; 159| | 160| 2.30M| for (n = 0; n < L; n++) ------------------ | Branch (160:14): [True: 2.30M, False: 107] ------------------ 161| 2.30M| 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| 107|} FLAC__window_nuttall: 165| 111|{ 166| 111| const FLAC__int32 N = L - 1; 167| 111| FLAC__int32 n; 168| | 169| 1.70M| for (n = 0; n < L; n++) ------------------ | Branch (169:14): [True: 1.70M, False: 111] ------------------ 170| 1.70M| 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| 111|} FLAC__window_rectangle: 174| 16.2k|{ 175| 16.2k| FLAC__int32 n; 176| | 177| 224M| for (n = 0; n < L; n++) ------------------ | Branch (177:14): [True: 224M, False: 16.2k] ------------------ 178| 224M| window[n] = 1.0f; 179| 16.2k|} FLAC__window_triangle: 182| 756|{ 183| 756| FLAC__int32 n; 184| | 185| 756| if (L & 1) { ------------------ | Branch (185:6): [True: 382, False: 374] ------------------ 186| 2.95M| for (n = 1; n <= (L+1)/2; n++) ------------------ | Branch (186:15): [True: 2.95M, False: 382] ------------------ 187| 2.95M| window[n-1] = 2.0f * n / ((float)L + 1.0f); 188| 2.95M| for (; n <= L; n++) ------------------ | Branch (188:10): [True: 2.95M, False: 382] ------------------ 189| 2.95M| window[n-1] = (float)(2 * (L - n + 1)) / ((float)L + 1.0f); 190| 382| } 191| 374| else { 192| 1.83M| for (n = 1; n <= L/2; n++) ------------------ | Branch (192:15): [True: 1.83M, False: 374] ------------------ 193| 1.83M| window[n-1] = 2.0f * n / ((float)L + 1.0f); 194| 1.83M| for (; n <= L; n++) ------------------ | Branch (194:10): [True: 1.83M, False: 374] ------------------ 195| 1.83M| window[n-1] = (float)(2 * (L - n + 1)) / ((float)L + 1.0f); 196| 374| } 197| 756|} FLAC__window_tukey: 200| 16.8k|{ 201| 16.8k| if (p <= 0.0) ------------------ | Branch (201:6): [True: 1.16k, False: 15.6k] ------------------ 202| 1.16k| FLAC__window_rectangle(window, L); 203| 15.6k| else if (p >= 1.0) ------------------ | Branch (203:11): [True: 183, False: 15.4k] ------------------ 204| 183| FLAC__window_hann(window, L); 205| 15.4k| else if (!(p > 0.0f && p < 1.0f)) ------------------ | Branch (205:13): [True: 14.8k, False: 599] | Branch (205:25): [True: 14.8k, False: 0] ------------------ 206| | /* p is not between 0 and 1, probably NaN. 207| | * Default to 0.5 */ 208| 599| FLAC__window_tukey(window, L, 0.5f); 209| 14.8k| else { 210| 14.8k| const FLAC__int32 Np = (FLAC__int32)(p / 2.0f * L) - 1; 211| 14.8k| FLAC__int32 n; 212| | /* start with rectangle... */ 213| 14.8k| FLAC__window_rectangle(window, L); 214| | /* ...replace ends with hann */ 215| 14.8k| if (Np > 0) { ------------------ | Branch (215:7): [True: 12.6k, False: 2.24k] ------------------ 216| 48.3M| for (n = 0; n <= Np; n++) { ------------------ | Branch (216:16): [True: 48.3M, False: 12.6k] ------------------ 217| 48.3M| 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| 48.3M| } 220| 12.6k| } 221| 14.8k| } 222| 16.8k|} FLAC__window_partial_tukey: 225| 11.0k|{ 226| 11.0k| const FLAC__int32 start_n = (FLAC__int32)(start * L); 227| 11.0k| const FLAC__int32 end_n = (FLAC__int32)(end * L); 228| 11.0k| const FLAC__int32 N = end_n - start_n; 229| 11.0k| FLAC__int32 Np, n, i; 230| | 231| 11.0k| if (p <= 0.0f) ------------------ | Branch (231:6): [True: 1.33k, False: 9.67k] ------------------ 232| 1.33k| FLAC__window_partial_tukey(window, L, 0.05f, start, end); 233| 9.67k| else if (p >= 1.0f) ------------------ | Branch (233:11): [True: 603, False: 9.07k] ------------------ 234| 603| FLAC__window_partial_tukey(window, L, 0.95f, start, end); 235| 9.07k| else if (!(p > 0.0f && p < 1.0f)) ------------------ | Branch (235:13): [True: 8.60k, False: 468] | Branch (235:25): [True: 8.60k, False: 0] ------------------ 236| | /* p is not between 0 and 1, probably NaN. 237| | * Default to 0.5 */ 238| 468| FLAC__window_partial_tukey(window, L, 0.5f, start, end); 239| 8.60k| else { 240| | 241| 8.60k| Np = (FLAC__int32)(p / 2.0f * N); 242| | 243| 39.3M| for (n = 0; n < start_n && n < L; n++) ------------------ | Branch (243:15): [True: 39.3M, False: 8.60k] | Branch (243:30): [True: 39.3M, False: 0] ------------------ 244| 39.3M| window[n] = 0.0f; 245| 2.32M| for (i = 1; n < (start_n+Np) && n < L; n++, i++) ------------------ | Branch (245:15): [True: 2.31M, False: 8.60k] | Branch (245:35): [True: 2.31M, False: 0] ------------------ 246| 2.31M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Np)); 247| 13.3M| for (; n < (end_n-Np) && n < L; n++) ------------------ | Branch (247:10): [True: 13.3M, False: 8.60k] | Branch (247:28): [True: 13.3M, False: 0] ------------------ 248| 13.3M| window[n] = 1.0f; 249| 2.32M| for (i = Np; n < end_n && n < L; n++, i--) ------------------ | Branch (249:16): [True: 2.31M, False: 8.60k] | Branch (249:29): [True: 2.31M, False: 0] ------------------ 250| 2.31M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Np)); 251| 39.3M| for (; n < L; n++) ------------------ | Branch (251:10): [True: 39.3M, False: 8.60k] ------------------ 252| 39.3M| window[n] = 0.0f; 253| 8.60k| } 254| 11.0k|} FLAC__window_punchout_tukey: 257| 10.8k|{ 258| 10.8k| const FLAC__int32 start_n = (FLAC__int32)(start * L); 259| 10.8k| const FLAC__int32 end_n = (FLAC__int32)(end * L); 260| 10.8k| FLAC__int32 Ns, Ne, n, i; 261| | 262| 10.8k| if (p <= 0.0f) ------------------ | Branch (262:6): [True: 444, False: 10.3k] ------------------ 263| 444| FLAC__window_punchout_tukey(window, L, 0.05f, start, end); 264| 10.3k| else if (p >= 1.0f) ------------------ | Branch (264:11): [True: 135, False: 10.2k] ------------------ 265| 135| FLAC__window_punchout_tukey(window, L, 0.95f, start, end); 266| 10.2k| else if (!(p > 0.0f && p < 1.0f)) ------------------ | Branch (266:13): [True: 10.1k, False: 74] | Branch (266:25): [True: 10.1k, False: 0] ------------------ 267| | /* p is not between 0 and 1, probably NaN. 268| | * Default to 0.5 */ 269| 74| FLAC__window_punchout_tukey(window, L, 0.5f, start, end); 270| 10.1k| else { 271| | 272| 10.1k| Ns = (FLAC__int32)(p / 2.0f * start_n); 273| 10.1k| Ne = (FLAC__int32)(p / 2.0f * (L - end_n)); 274| | 275| 8.90M| for (n = 0, i = 1; n < Ns && n < L; n++, i++) ------------------ | Branch (275:22): [True: 8.89M, False: 10.1k] | Branch (275:32): [True: 8.89M, False: 0] ------------------ 276| 8.89M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ns)); 277| 64.8M| for (; n < start_n-Ns && n < L; n++) ------------------ | Branch (277:10): [True: 64.8M, False: 10.1k] | Branch (277:28): [True: 64.8M, False: 0] ------------------ 278| 64.8M| window[n] = 1.0f; 279| 8.90M| for (i = Ns; n < start_n && n < L; n++, i--) ------------------ | Branch (279:16): [True: 8.89M, False: 10.1k] | Branch (279:31): [True: 8.89M, False: 0] ------------------ 280| 8.89M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ns)); 281| 13.3M| for (; n < end_n && n < L; n++) ------------------ | Branch (281:10): [True: 13.3M, False: 10.1k] | Branch (281:23): [True: 13.3M, False: 0] ------------------ 282| 13.3M| window[n] = 0.0f; 283| 8.90M| for (i = 1; n < end_n+Ne && n < L; n++, i++) ------------------ | Branch (283:15): [True: 8.89M, False: 10.1k] | Branch (283:31): [True: 8.89M, False: 0] ------------------ 284| 8.89M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ne)); 285| 64.8M| for (; n < L - (Ne) && n < L; n++) ------------------ | Branch (285:10): [True: 64.8M, False: 10.1k] | Branch (285:26): [True: 64.8M, False: 0] ------------------ 286| 64.8M| window[n] = 1.0f; 287| 8.90M| for (i = Ne; n < L; n++, i--) ------------------ | Branch (287:16): [True: 8.89M, False: 10.1k] ------------------ 288| 8.89M| window[n] = (FLAC__real)(0.5f - 0.5f * cosf(M_PI * i / Ne)); 289| 10.1k| } 290| 10.8k|} FLAC__window_welch: 293| 251|{ 294| 251| const FLAC__int32 N = L - 1; 295| 251| const double N2 = (double)N / 2.; 296| 251| FLAC__int32 n; 297| | 298| 3.50M| for (n = 0; n <= N; n++) { ------------------ | Branch (298:14): [True: 3.50M, False: 251] ------------------ 299| 3.50M| const double k = ((double)n - N2) / N2; 300| 3.50M| window[n] = (FLAC__real)(1.0f - k * k); 301| 3.50M| } 302| 251|} ogg_page_granulepos: 49| 11.0k|ogg_int64_t ogg_page_granulepos(const ogg_page *og){ 50| 11.0k| unsigned char *page=og->header; 51| 11.0k| ogg_uint64_t granulepos=page[13]&(0xff); 52| 11.0k| granulepos= (granulepos<<8)|(page[12]&0xff); 53| 11.0k| granulepos= (granulepos<<8)|(page[11]&0xff); 54| 11.0k| granulepos= (granulepos<<8)|(page[10]&0xff); 55| 11.0k| granulepos= (granulepos<<8)|(page[9]&0xff); 56| 11.0k| granulepos= (granulepos<<8)|(page[8]&0xff); 57| 11.0k| granulepos= (granulepos<<8)|(page[7]&0xff); 58| 11.0k| granulepos= (granulepos<<8)|(page[6]&0xff); 59| 11.0k| return((ogg_int64_t)granulepos); 60| 11.0k|} ogg_stream_init: 133| 3.09k|int ogg_stream_init(ogg_stream_state *os,int serialno){ 134| 3.09k| if(os){ ------------------ | Branch (134:6): [True: 3.09k, False: 0] ------------------ 135| 3.09k| memset(os,0,sizeof(*os)); 136| 3.09k| os->body_storage=16*1024; 137| 3.09k| os->lacing_storage=1024; 138| | 139| 3.09k| os->body_data=_ogg_malloc(os->body_storage*sizeof(*os->body_data)); ------------------ | | 21| 3.09k|#define _ogg_malloc malloc ------------------ 140| 3.09k| os->lacing_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals)); ------------------ | | 21| 3.09k|#define _ogg_malloc malloc ------------------ 141| 3.09k| os->granule_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals)); ------------------ | | 21| 3.09k|#define _ogg_malloc malloc ------------------ 142| | 143| 3.09k| if(!os->body_data || !os->lacing_vals || !os->granule_vals){ ------------------ | Branch (143:8): [True: 0, False: 3.09k] | Branch (143:26): [True: 0, False: 3.09k] | Branch (143:46): [True: 0, False: 3.09k] ------------------ 144| 0| ogg_stream_clear(os); 145| 0| return -1; 146| 0| } 147| | 148| 3.09k| os->serialno=serialno; 149| | 150| 3.09k| return(0); 151| 3.09k| } 152| 0| return(-1); 153| 3.09k|} ogg_stream_check: 156| 511k|int ogg_stream_check(ogg_stream_state *os){ 157| 511k| if(!os || !os->body_data) return -1; ------------------ | Branch (157:6): [True: 0, False: 511k] | Branch (157:13): [True: 0, False: 511k] ------------------ 158| 511k| return 0; 159| 511k|} ogg_stream_clear: 162| 3.09k|int ogg_stream_clear(ogg_stream_state *os){ 163| 3.09k| if(os){ ------------------ | Branch (163:6): [True: 3.09k, False: 0] ------------------ 164| 3.09k| if(os->body_data)_ogg_free(os->body_data); ------------------ | | 24| 3.09k|#define _ogg_free free ------------------ | Branch (164:8): [True: 3.09k, False: 0] ------------------ 165| 3.09k| if(os->lacing_vals)_ogg_free(os->lacing_vals); ------------------ | | 24| 3.09k|#define _ogg_free free ------------------ | Branch (165:8): [True: 3.09k, False: 0] ------------------ 166| 3.09k| if(os->granule_vals)_ogg_free(os->granule_vals); ------------------ | | 24| 3.09k|#define _ogg_free free ------------------ | Branch (166:8): [True: 3.09k, False: 0] ------------------ 167| | 168| 3.09k| memset(os,0,sizeof(*os)); 169| 3.09k| } 170| 3.09k| return(0); 171| 3.09k|} ogg_page_checksum_set: 255| 11.0k|void ogg_page_checksum_set(ogg_page *og){ 256| 11.0k| if(og){ ------------------ | Branch (256:6): [True: 11.0k, False: 0] ------------------ 257| 11.0k| ogg_uint32_t crc_reg=0; 258| | 259| | /* safety; needed for API behavior, but not framing code */ 260| 11.0k| og->header[22]=0; 261| 11.0k| og->header[23]=0; 262| 11.0k| og->header[24]=0; 263| 11.0k| og->header[25]=0; 264| | 265| 11.0k| crc_reg=_os_update_crc(crc_reg,og->header,og->header_len); 266| 11.0k| crc_reg=_os_update_crc(crc_reg,og->body,og->body_len); 267| | 268| 11.0k| og->header[22]=(unsigned char)(crc_reg&0xff); 269| 11.0k| og->header[23]=(unsigned char)((crc_reg>>8)&0xff); 270| 11.0k| og->header[24]=(unsigned char)((crc_reg>>16)&0xff); 271| 11.0k| og->header[25]=(unsigned char)((crc_reg>>24)&0xff); 272| 11.0k| } 273| 11.0k|} ogg_stream_iovecin: 277| 167k| long e_o_s, ogg_int64_t granulepos){ 278| | 279| 167k| long bytes = 0, lacing_vals; 280| 167k| int i; 281| | 282| 167k| if(ogg_stream_check(os)) return -1; ------------------ | Branch (282:6): [True: 0, False: 167k] ------------------ 283| 167k| if(!iov) return 0; ------------------ | Branch (283:6): [True: 0, False: 167k] ------------------ 284| | 285| 334k| for (i = 0; i < count; ++i){ ------------------ | Branch (285:15): [True: 167k, False: 167k] ------------------ 286| 167k| if(iov[i].iov_len>LONG_MAX) return -1; ------------------ | Branch (286:8): [True: 0, False: 167k] ------------------ 287| 167k| if(bytes>LONG_MAX-(long)iov[i].iov_len) return -1; ------------------ | Branch (287:8): [True: 0, False: 167k] ------------------ 288| 167k| bytes += (long)iov[i].iov_len; 289| 167k| } 290| 167k| lacing_vals=bytes/255+1; 291| | 292| 167k| if(os->body_returned){ ------------------ | Branch (292:6): [True: 7.58k, False: 159k] ------------------ 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| 7.58k| os->body_fill-=os->body_returned; 298| 7.58k| if(os->body_fill) ------------------ | Branch (298:8): [True: 1.58k, False: 6.00k] ------------------ 299| 1.58k| memmove(os->body_data,os->body_data+os->body_returned, 300| 1.58k| os->body_fill); 301| 7.58k| os->body_returned=0; 302| 7.58k| } 303| | 304| | /* make sure we have the buffer storage */ 305| 167k| if(_os_body_expand(os,bytes) || _os_lacing_expand(os,lacing_vals)) ------------------ | Branch (305:6): [True: 0, False: 167k] | Branch (305:35): [True: 0, False: 167k] ------------------ 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| 334k| for (i = 0; i < count; ++i) { ------------------ | Branch (313:15): [True: 167k, False: 167k] ------------------ 314| 167k| memcpy(os->body_data+os->body_fill, iov[i].iov_base, iov[i].iov_len); 315| 167k| os->body_fill += (long)iov[i].iov_len; 316| 167k| } 317| | 318| | /* Store lacing vals for this packet */ 319| 310k| for(i=0;ilacing_vals[os->lacing_fill+i]=255; 321| 142k| os->granule_vals[os->lacing_fill+i]=os->granulepos; 322| 142k| } 323| 167k| os->lacing_vals[os->lacing_fill+i]=bytes%255; 324| 167k| os->granulepos=os->granule_vals[os->lacing_fill+i]=granulepos; 325| | 326| | /* flag the first segment as the beginning of the packet */ 327| 167k| os->lacing_vals[os->lacing_fill]|= 0x100; 328| | 329| 167k| os->lacing_fill+=lacing_vals; 330| | 331| | /* for the sake of completeness */ 332| 167k| os->packetno++; 333| | 334| 167k| if(e_o_s)os->e_o_s=1; ------------------ | Branch (334:6): [True: 2.75k, False: 164k] ------------------ 335| | 336| 167k| return(0); 337| 167k|} ogg_stream_packetin: 339| 167k|int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){ 340| 167k| ogg_iovec_t iov; 341| 167k| iov.iov_base = op->packet; 342| 167k| iov.iov_len = op->bytes; 343| 167k| return ogg_stream_iovecin(os, &iov, 1, op->e_o_s, op->granulepos); 344| 167k|} ogg_stream_flush: 495| 12.3k|int ogg_stream_flush(ogg_stream_state *os,ogg_page *og){ 496| 12.3k| return ogg_stream_flush_i(os,og,1,4096); 497| 12.3k|} ogg_stream_pageout: 511| 165k|int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og){ 512| 165k| int force=0; 513| 165k| if(ogg_stream_check(os)) return 0; ------------------ | Branch (513:6): [True: 0, False: 165k] ------------------ 514| | 515| 165k| if((os->e_o_s&&os->lacing_fill) || /* 'were done, now flush' case */ ------------------ | Branch (515:7): [True: 5.85k, False: 159k] | Branch (515:18): [True: 3.09k, False: 2.75k] ------------------ 516| 162k| (os->lacing_fill&&!os->b_o_s)) /* 'initial header page' case */ ------------------ | Branch (516:7): [True: 159k, False: 2.90k] | Branch (516:24): [True: 0, False: 159k] ------------------ 517| 3.09k| force=1; 518| | 519| 165k| return(ogg_stream_flush_i(os,og,force,4096)); 520| 165k|} framing.c:_os_update_crc: 237| 22.1k|static ogg_uint32_t _os_update_crc(ogg_uint32_t crc, unsigned char *buffer, int size){ 238| 5.59M| while (size>=8){ ------------------ | Branch (238:10): [True: 5.57M, False: 22.1k] ------------------ 239| 5.57M| 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.57M| crc=crc_lookup[7][ crc>>24 ]^crc_lookup[6][(crc>>16)&0xFF]^ 242| 5.57M| crc_lookup[5][(crc>> 8)&0xFF]^crc_lookup[4][ crc &0xFF]^ 243| 5.57M| crc_lookup[3][buffer[4] ]^crc_lookup[2][buffer[5] ]^ 244| 5.57M| crc_lookup[1][buffer[6] ]^crc_lookup[0][buffer[7] ]; 245| | 246| 5.57M| buffer+=8; 247| 5.57M| size-=8; 248| 5.57M| } 249| | 250| 97.2k| while (size--) ------------------ | Branch (250:10): [True: 75.1k, False: 22.1k] ------------------ 251| 75.1k| crc=(crc<<8)^crc_lookup[0][((crc >> 24)&0xff)^*buffer++]; 252| 22.1k| return crc; 253| 22.1k|} framing.c:_os_body_expand: 184| 167k|static int _os_body_expand(ogg_stream_state *os,long needed){ 185| 167k| if(os->body_storage-needed<=os->body_fill){ ------------------ | Branch (185:6): [True: 423, False: 166k] ------------------ 186| 423| long body_storage; 187| 423| void *ret; 188| 423| if(os->body_storage>LONG_MAX-needed){ ------------------ | Branch (188:8): [True: 0, False: 423] ------------------ 189| 0| ogg_stream_clear(os); 190| 0| return -1; 191| 0| } 192| 423| body_storage=os->body_storage+needed; 193| 423| if(body_storagebody_data,body_storage*sizeof(*os->body_data)); ------------------ | | 23| 423|#define _ogg_realloc realloc ------------------ 195| 423| if(!ret){ ------------------ | Branch (195:8): [True: 0, False: 423] ------------------ 196| 0| ogg_stream_clear(os); 197| 0| return -1; 198| 0| } 199| 423| os->body_storage=body_storage; 200| 423| os->body_data=ret; 201| 423| } 202| 167k| return 0; 203| 167k|} framing.c:_os_lacing_expand: 205| 167k|static int _os_lacing_expand(ogg_stream_state *os,long needed){ 206| 167k| if(os->lacing_storage-needed<=os->lacing_fill){ ------------------ | Branch (206:6): [True: 30, False: 167k] ------------------ 207| 30| long lacing_storage; 208| 30| void *ret; 209| 30| if(os->lacing_storage>LONG_MAX-needed){ ------------------ | Branch (209:8): [True: 0, False: 30] ------------------ 210| 0| ogg_stream_clear(os); 211| 0| return -1; 212| 0| } 213| 30| lacing_storage=os->lacing_storage+needed; 214| 30| if(lacing_storagelacing_vals,lacing_storage*sizeof(*os->lacing_vals)); ------------------ | | 23| 30|#define _ogg_realloc realloc ------------------ 216| 30| if(!ret){ ------------------ | Branch (216:8): [True: 0, False: 30] ------------------ 217| 0| ogg_stream_clear(os); 218| 0| return -1; 219| 0| } 220| 30| os->lacing_vals=ret; 221| 30| ret=_ogg_realloc(os->granule_vals,lacing_storage* ------------------ | | 23| 30|#define _ogg_realloc realloc ------------------ 222| 30| sizeof(*os->granule_vals)); 223| 30| if(!ret){ ------------------ | Branch (223:8): [True: 0, False: 30] ------------------ 224| 0| ogg_stream_clear(os); 225| 0| return -1; 226| 0| } 227| 30| os->granule_vals=ret; 228| 30| os->lacing_storage=lacing_storage; 229| 30| } 230| 167k| return 0; 231| 167k|} framing.c:ogg_stream_flush_i: 349| 178k|static int ogg_stream_flush_i(ogg_stream_state *os,ogg_page *og, int force, int nfill){ 350| 178k| int i; 351| 178k| int vals=0; 352| 178k| int maxvals; 353| 178k| int bytes=0; 354| 178k| long acc=0; 355| 178k| ogg_int64_t granule_pos=-1; 356| | 357| 178k| if(ogg_stream_check(os)) return(0); ------------------ | Branch (357:6): [True: 0, False: 178k] ------------------ 358| 178k| maxvals=(os->lacing_fill>255?255:os->lacing_fill); ------------------ | Branch (358:12): [True: 381, False: 177k] ------------------ 359| 178k| if(maxvals==0) return(0); ------------------ | Branch (359:6): [True: 9.09k, False: 169k] ------------------ 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| 169k| if(os->b_o_s==0){ /* 'initial header page' case */ ------------------ | Branch (366:6): [True: 3.09k, False: 166k] ------------------ 367| 3.09k| granule_pos=0; 368| 3.09k| for(vals=0;valslacing_vals[vals]&0x0ff)<255){ ------------------ | Branch (369:10): [True: 3.09k, False: 0] ------------------ 370| 3.09k| vals++; 371| 3.09k| break; 372| 3.09k| } 373| 3.09k| } 374| 166k| }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| 166k| int packets_done=0; 386| 166k| int packet_just_done=0; 387| 12.0M| for(vals=0;valsnfill && packet_just_done>=4){ ------------------ | Branch (388:10): [True: 153k, False: 11.6M] | Branch (388:23): [True: 1.58k, False: 151k] ------------------ 389| 1.58k| force=1; 390| 1.58k| break; 391| 1.58k| } 392| 11.8M| acc+=os->lacing_vals[vals]&0x0ff; 393| 11.8M| if((os->lacing_vals[vals]&0xff)<255){ ------------------ | Branch (393:10): [True: 11.6M, False: 186k] ------------------ 394| 11.6M| granule_pos=os->granule_vals[vals]; 395| 11.6M| packet_just_done=++packets_done; 396| 11.6M| }else 397| 186k| packet_just_done=0; 398| 11.8M| } 399| 166k| if(vals==255)force=1; ------------------ | Branch (399:8): [True: 527, False: 165k] ------------------ 400| 166k| } 401| | 402| 169k| if(!force) return(0); ------------------ | Branch (402:6): [True: 158k, False: 11.0k] ------------------ 403| | 404| | /* construct the header in temp storage */ 405| 11.0k| memcpy(os->header,"OggS",4); 406| | 407| | /* stream structure version */ 408| 11.0k| os->header[4]=0x00; 409| | 410| | /* continued packet flag? */ 411| 11.0k| os->header[5]=0x00; 412| 11.0k| if((os->lacing_vals[0]&0x100)==0)os->header[5]|=0x01; ------------------ | Branch (412:6): [True: 375, False: 10.6k] ------------------ 413| | /* first page flag? */ 414| 11.0k| if(os->b_o_s==0)os->header[5]|=0x02; ------------------ | Branch (414:6): [True: 3.09k, False: 7.95k] ------------------ 415| | /* last page flag? */ 416| 11.0k| if(os->e_o_s && os->lacing_fill==vals)os->header[5]|=0x04; ------------------ | Branch (416:6): [True: 3.09k, False: 7.96k] | Branch (416:19): [True: 2.75k, False: 341] ------------------ 417| 11.0k| os->b_o_s=1; 418| | 419| | /* 64 bits of PCM position */ 420| 99.5k| for(i=6;i<14;i++){ ------------------ | Branch (420:11): [True: 88.4k, False: 11.0k] ------------------ 421| 88.4k| os->header[i]=(unsigned char)(granule_pos&0xff); 422| 88.4k| granule_pos>>=8; 423| 88.4k| } 424| | 425| | /* 32 bits of stream serial number */ 426| 11.0k| { 427| 11.0k| long serialno=os->serialno; 428| 55.2k| for(i=14;i<18;i++){ ------------------ | Branch (428:14): [True: 44.2k, False: 11.0k] ------------------ 429| 44.2k| os->header[i]=(unsigned char)(serialno&0xff); 430| 44.2k| serialno>>=8; 431| 44.2k| } 432| 11.0k| } 433| | 434| | /* 32 bits of page counter (we have both counter and page header 435| | because this val can roll over) */ 436| 11.0k| if(os->pageno==-1)os->pageno=0; /* because someone called ------------------ | Branch (436:6): [True: 0, False: 11.0k] ------------------ 437| | stream_reset; this would be a 438| | strange thing to do in an 439| | encode stream, but it has 440| | plausible uses */ 441| 11.0k| { 442| 11.0k| long pageno=os->pageno++; 443| 55.2k| for(i=18;i<22;i++){ ------------------ | Branch (443:14): [True: 44.2k, False: 11.0k] ------------------ 444| 44.2k| os->header[i]=(unsigned char)(pageno&0xff); 445| 44.2k| pageno>>=8; 446| 44.2k| } 447| 11.0k| } 448| | 449| | /* zero for computation; filled in later */ 450| 11.0k| os->header[22]=0; 451| 11.0k| os->header[23]=0; 452| 11.0k| os->header[24]=0; 453| 11.0k| os->header[25]=0; 454| | 455| | /* segment table */ 456| 11.0k| os->header[26]=(unsigned char)(vals&0xff); 457| 321k| for(i=0;iheader[i+27]=(unsigned char)(os->lacing_vals[i]&0xff); 459| | 460| | /* set pointers in the ogg_page struct */ 461| 11.0k| og->header=os->header; 462| 11.0k| og->header_len=os->header_fill=vals+27; 463| 11.0k| og->body=os->body_data+os->body_returned; 464| 11.0k| og->body_len=bytes; 465| | 466| | /* advance the lacing data and set the body_returned pointer */ 467| | 468| 11.0k| os->lacing_fill-=vals; 469| 11.0k| memmove(os->lacing_vals,os->lacing_vals+vals,os->lacing_fill*sizeof(*os->lacing_vals)); 470| 11.0k| memmove(os->granule_vals,os->granule_vals+vals,os->lacing_fill*sizeof(*os->granule_vals)); 471| 11.0k| os->body_returned+=bytes; 472| | 473| | /* calculate the checksum */ 474| | 475| 11.0k| ogg_page_checksum_set(og); 476| | 477| | /* done */ 478| 11.0k| return(1); 479| 169k|}