_ZN5ErrorC2E15heif_error_code18heif_suberror_codeRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 52| 2| : error_code(c), 53| 2| sub_error_code(sc), 54| 2| message(msg) 55| 2|{ 56| 2|} _Z24register_default_pluginsv: 149| 1|{ 150| |#if HAVE_WEBCODECS 151| | register_decoder(get_decoder_plugin_webcodecs()); 152| |#endif 153| | 154| 1|#if HAVE_LIBDE265 155| 1| register_decoder(get_decoder_plugin_libde265()); 156| 1|#endif 157| | 158| 1|#if HAVE_X265 159| 1| register_encoder(get_encoder_plugin_x265()); 160| 1|#endif 161| | 162| |#if HAVE_KVAZAAR 163| | register_encoder(get_encoder_plugin_kvazaar()); 164| |#endif 165| | 166| |#if HAVE_UVG266 167| | register_encoder(get_encoder_plugin_uvg266()); 168| |#endif 169| | 170| 1|#if HAVE_VVENC 171| 1| register_encoder(get_encoder_plugin_vvenc()); 172| 1|#endif 173| | 174| 1|#if HAVE_VVDEC 175| 1| register_decoder(get_decoder_plugin_vvdec()); 176| 1|#endif 177| | 178| 1|#if HAVE_AOM_ENCODER 179| 1| register_encoder(get_encoder_plugin_aom()); 180| 1|#endif 181| | 182| 1|#if HAVE_AOM_DECODER 183| 1| register_decoder(get_decoder_plugin_aom()); 184| 1|#endif 185| | 186| |#if HAVE_RAV1E 187| | register_encoder(get_encoder_plugin_rav1e()); 188| |#endif 189| | 190| 1|#if HAVE_DAV1D 191| 1| register_decoder(get_decoder_plugin_dav1d()); 192| 1|#endif 193| | 194| 1|#if HAVE_SvtEnc 195| 1| register_encoder(get_encoder_plugin_svt()); 196| 1|#endif 197| | 198| |#if HAVE_FFMPEG_DECODER 199| | register_decoder(get_decoder_plugin_ffmpeg()); 200| |#endif 201| | 202| 1|#if HAVE_JPEG_DECODER 203| 1| register_decoder(get_decoder_plugin_jpeg()); 204| 1|#endif 205| | 206| 1|#if HAVE_JPEG_ENCODER 207| 1| register_encoder(get_encoder_plugin_jpeg()); 208| 1|#endif 209| | 210| 1|#if HAVE_OPENJPEG_ENCODER 211| 1| register_encoder(get_encoder_plugin_openjpeg()); 212| 1|#endif 213| | 214| 1|#if HAVE_OPENJPEG_DECODER 215| 1| register_decoder(get_decoder_plugin_openjpeg()); 216| 1|#endif 217| | 218| 1|#if HAVE_OPENJPH_ENCODER 219| 1| register_encoder(get_encoder_plugin_openjph()); 220| 1|#endif 221| | 222| 1|#if HAVE_OpenH264_DECODER 223| 1| register_decoder(get_decoder_plugin_openh264()); 224| 1|#endif 225| | 226| 1|#if HAVE_X264 227| 1| register_encoder(get_encoder_plugin_x264()); 228| 1|#endif 229| | 230| 1|#if WITH_UNCOMPRESSED_CODEC 231| 1| register_encoder(get_encoder_plugin_uncompressed()); 232| 1| register_decoder(get_decoder_plugin_uncompressed()); 233| 1|#endif 234| | 235| 1| register_encoder(get_encoder_plugin_mask()); 236| 1|} _Z16register_decoderPK19heif_decoder_plugin: 240| 8|{ 241| 8| if (decoder_plugin->init_plugin) { ------------------ | Branch (241:7): [True: 7, False: 1] ------------------ 242| 7| (*decoder_plugin->init_plugin)(); 243| 7| } 244| | 245| 8| s_decoder_plugins.insert(decoder_plugin); 246| 8|} _Z16register_encoderPK19heif_encoder_plugin: 292| 10|{ 293| 10| if (encoder_plugin->init_plugin) { ------------------ | Branch (293:7): [True: 10, False: 0] ------------------ 294| 10| (*encoder_plugin->init_plugin)(); 295| 10| } 296| | 297| 10| auto descriptor = std::unique_ptr(new heif_encoder_descriptor); 298| 10| descriptor->plugin = encoder_plugin; 299| | 300| 10| s_encoder_descriptors.insert(std::move(descriptor)); 301| 10|} _ZN24Register_Default_PluginsC2Ev: 142| 1| { 143| 1| register_default_plugins(); 144| 1| } _ZNK33encoder_descriptor_priority_orderclERKNSt3__110unique_ptrI23heif_encoder_descriptorNS0_14default_deleteIS2_EEEES7_: 50| 25| { 51| 25| return a->plugin->priority > b->plugin->priority; // highest priority first 52| 25| } _Z22get_decoder_plugin_aomv: 435| 1|{ 436| 1| return &decoder_aom; 437| 1|} decoder_aom.cc:_ZL15aom_init_pluginv: 88| 1|{ 89| 1|} _Z24get_decoder_plugin_dav1dv: 446| 1|{ 447| 1| return &decoder_dav1d; 448| 1|} decoder_dav1d.cc:_ZL17dav1d_init_pluginv: 71| 1|{ 72| 1|} _Z23get_decoder_plugin_jpegv: 494| 1|{ 495| 1| return &decoder_jpeg; 496| 1|} decoder_jpeg.cc:_ZL16jpeg_init_pluginv: 70| 1|{ 71| 1|} _Z27get_decoder_plugin_libde265v: 502| 1|{ 503| 1| return &decoder_libde265; 504| 1|} decoder_libde265.cc:_ZL20libde265_init_pluginv: 66| 1|{ 67| 1| de265_init(); 68| 1|} _Z27get_decoder_plugin_openh264v: 466| 1|{ 467| 1| return &decoder_openh264; 468| 1|} decoder_openh264.cc:_ZL20openh264_init_pluginv: 95| 1|{ 96| 1|} _Z27get_decoder_plugin_openjpegv: 550| 1|{ 551| 1| return &decoder_openjpeg; 552| 1|} decoder_openjpeg.cc:_ZL20openjpeg_init_pluginv: 60| 1|{ 61| 1|} _Z31get_decoder_plugin_uncompressedv: 71| 1|{ 72| 1| return &decoder_uncompressed; 73| 1|} _Z24get_decoder_plugin_vvdecv: 440| 1|{ 441| 1| return &decoder_vvdec; 442| 1|} decoder_vvdec.cc:_ZL17vvdec_init_pluginv: 84| 1|{ 85| 1|} _Z22get_encoder_plugin_aomv: 1452| 1|{ 1453| 1| return &encoder_plugin_aom; 1454| 1|} encoder_aom.cc:_ZL15aom_init_pluginv: 416| 1|{ 417| 1| aom_init_parameters(); 418| 1|} encoder_aom.cc:_ZL19aom_init_parametersv: 230| 1|{ 231| 1| heif_encoder_parameter* p = aom_encoder_params; 232| 1| const heif_encoder_parameter** d = aom_encoder_parameter_ptrs; 233| 1| int i = 0; 234| | 235| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (235:3): [True: 1, False: 0] ------------------ 236| 1| p->version = 2; 237| 1| p->name = kParam_realtime; 238| 1| p->type = heif_encoder_parameter_type_boolean; 239| 1| p->boolean.default_value = false; 240| 1| p->has_default = true; 241| 1| d[i++] = p++; 242| | 243| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (243:3): [True: 1, False: 0] ------------------ 244| 1| p->version = 2; 245| 1| p->name = kParam_speed; 246| 1| p->type = heif_encoder_parameter_type_integer; 247| 1| p->integer.default_value = 6; 248| 1| p->has_default = true; 249| 1| p->integer.have_minimum_maximum = true; 250| 1| p->integer.minimum = 0; 251| 1| if (aom_codec_version_major() >= 3) { ------------------ | Branch (251:7): [True: 1, False: 0] ------------------ 252| 1| p->integer.maximum = 9; 253| 1| } 254| 0| else { 255| 0| p->integer.maximum = 8; 256| 0| } 257| 1| p->integer.valid_values = NULL; 258| 1| p->integer.num_valid_values = 0; 259| 1| d[i++] = p++; 260| | 261| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (261:3): [True: 1, False: 0] ------------------ 262| 1| p->version = 2; 263| 1| p->name = kParam_threads; 264| 1| p->type = heif_encoder_parameter_type_integer; 265| 1| p->has_default = true; 266| 1| p->integer.have_minimum_maximum = true; 267| 1| p->integer.minimum = 1; 268| 1| p->integer.maximum = 64; 269| 1| int threads = static_cast(std::thread::hardware_concurrency()); 270| 1| if (threads == 0) { ------------------ | Branch (270:7): [True: 0, False: 1] ------------------ 271| | // Could not autodetect, use previous default value. 272| 0| threads = 4; 273| 0| } 274| 1| threads = std::min(threads, p->integer.maximum); 275| 1| p->integer.default_value = threads; 276| 1| p->integer.valid_values = NULL; 277| 1| p->integer.num_valid_values = 0; 278| 1| d[i++] = p++; 279| | 280| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (280:3): [True: 1, False: 0] ------------------ 281| 1| p->version = 2; 282| 1| p->name = heif_encoder_parameter_name_quality; ------------------ | | 317| 1|#define heif_encoder_parameter_name_quality "quality" ------------------ 283| 1| p->type = heif_encoder_parameter_type_integer; 284| 1| p->integer.default_value = 50; 285| 1| p->has_default = true; 286| 1| p->integer.have_minimum_maximum = true; 287| 1| p->integer.minimum = 0; 288| 1| p->integer.maximum = 100; 289| 1| p->integer.valid_values = NULL; 290| 1| p->integer.num_valid_values = 0; 291| 1| d[i++] = p++; 292| | 293| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (293:3): [True: 1, False: 0] ------------------ 294| 1| p->version = 2; 295| 1| p->name = heif_encoder_parameter_name_lossless; ------------------ | | 318| 1|#define heif_encoder_parameter_name_lossless "lossless" ------------------ 296| 1| p->type = heif_encoder_parameter_type_boolean; 297| 1| p->boolean.default_value = false; 298| 1| p->has_default = true; 299| 1| d[i++] = p++; 300| | 301| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (301:3): [True: 1, False: 0] ------------------ 302| 1| p->version = 2; 303| 1| p->name = kParam_chroma; 304| 1| p->type = heif_encoder_parameter_type_string; 305| 1| p->string.default_value = "420"; 306| 1| p->has_default = true; 307| 1| p->string.valid_values = kParam_chroma_valid_values; 308| 1| d[i++] = p++; 309| | 310| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (310:3): [True: 1, False: 0] ------------------ 311| 1| p->version = 2; 312| 1| p->name = kParam_tune; 313| 1| p->type = heif_encoder_parameter_type_string; 314| 1| p->string.default_value = "auto"; 315| 1| p->has_default = true; 316| 1| p->string.valid_values = kParam_tune_valid_values; 317| 1| d[i++] = p++; 318| | 319| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (319:3): [True: 1, False: 0] ------------------ 320| 1| p->version = 2; 321| 1| p->name = kParam_min_q; 322| 1| p->type = heif_encoder_parameter_type_integer; 323| 1| p->integer.default_value = 0; 324| 1| p->has_default = true; 325| 1| p->integer.have_minimum_maximum = true; 326| 1| p->integer.minimum = 0; 327| 1| p->integer.maximum = 63; 328| 1| p->integer.valid_values = NULL; 329| 1| p->integer.num_valid_values = 0; 330| 1| d[i++] = p++; 331| | 332| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (332:3): [True: 1, False: 0] ------------------ 333| 1| p->version = 2; 334| 1| p->name = kParam_max_q; 335| 1| p->type = heif_encoder_parameter_type_integer; 336| 1| p->integer.default_value = 63; 337| 1| p->has_default = true; 338| 1| p->integer.have_minimum_maximum = true; 339| 1| p->integer.minimum = 0; 340| 1| p->integer.maximum = 63; 341| 1| p->integer.valid_values = NULL; 342| 1| p->integer.num_valid_values = 0; 343| 1| d[i++] = p++; 344| | 345| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (345:3): [True: 1, False: 0] ------------------ 346| 1| p->version = 2; 347| 1| p->name = kParam_alpha_quality; 348| 1| p->type = heif_encoder_parameter_type_integer; 349| 1| p->has_default = false; 350| 1| p->integer.have_minimum_maximum = true; 351| 1| p->integer.minimum = 0; 352| 1| p->integer.maximum = 100; 353| 1| p->integer.valid_values = NULL; 354| 1| p->integer.num_valid_values = 0; 355| 1| d[i++] = p++; 356| | 357| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (357:3): [True: 1, False: 0] ------------------ 358| 1| p->version = 2; 359| 1| p->name = kParam_alpha_min_q; 360| 1| p->type = heif_encoder_parameter_type_integer; 361| 1| p->has_default = false; 362| 1| p->integer.have_minimum_maximum = true; 363| 1| p->integer.minimum = 0; 364| 1| p->integer.maximum = 63; 365| 1| p->integer.valid_values = NULL; 366| 1| p->integer.num_valid_values = 0; 367| 1| d[i++] = p++; 368| | 369| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (369:3): [True: 1, False: 0] ------------------ 370| 1| p->version = 2; 371| 1| p->name = kParam_alpha_max_q; 372| 1| p->type = heif_encoder_parameter_type_integer; 373| 1| p->has_default = false; 374| 1| p->integer.have_minimum_maximum = true; 375| 1| p->integer.minimum = 0; 376| 1| p->integer.maximum = 63; 377| 1| p->integer.valid_values = NULL; 378| 1| p->integer.num_valid_values = 0; 379| 1| d[i++] = p++; 380| | 381| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (381:3): [True: 1, False: 0] ------------------ 382| 1| p->version = 2; 383| 1| p->name = kParam_lossless_alpha; 384| 1| p->type = heif_encoder_parameter_type_boolean; 385| 1| p->boolean.default_value = false; 386| 1| p->has_default = true; 387| 1| d[i++] = p++; 388| | 389| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (389:3): [True: 1, False: 0] ------------------ 390| 1| p->version = 2; 391| 1| p->name = kParam_auto_tiles; 392| 1| p->type = heif_encoder_parameter_type_boolean; 393| 1| p->boolean.default_value = false; 394| 1| p->has_default = true; 395| 1| d[i++] = p++; 396| | 397| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (397:3): [True: 1, False: 0] ------------------ 398| 1| p->version = 2; 399| 1| p->name = kParam_enable_intra_block_copy; 400| 1| p->type = heif_encoder_parameter_type_boolean; 401| 1| p->boolean.default_value = true; 402| 1| p->has_default = true; 403| 1| d[i++] = p++; 404| | 405| 1| assert(i < MAX_NPARAMETERS + 1); ------------------ | Branch (405:3): [True: 1, False: 0] ------------------ 406| 1| d[i++] = nullptr; 407| 1|} _Z23get_encoder_plugin_jpegv: 522| 1|{ 523| 1| return &encoder_plugin_jpeg; 524| 1|} encoder_jpeg.cc:_ZL16jpeg_init_pluginv: 117| 1|{ 118| 1| jpeg_init_parameters(); 119| 1|} encoder_jpeg.cc:_ZL20jpeg_init_parametersv: 79| 1|{ 80| 1| heif_encoder_parameter* p = jpeg_encoder_params; 81| 1| const heif_encoder_parameter** d = jpeg_encoder_parameter_ptrs; 82| 1| int i = 0; 83| | 84| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (84:3): [True: 1, False: 0] ------------------ 85| 1| p->version = 2; 86| 1| p->name = heif_encoder_parameter_name_quality; ------------------ | | 317| 1|#define heif_encoder_parameter_name_quality "quality" ------------------ 87| 1| p->type = heif_encoder_parameter_type_integer; 88| 1| p->integer.default_value = 50; 89| 1| p->has_default = true; 90| 1| p->integer.have_minimum_maximum = true; 91| 1| p->integer.minimum = 0; 92| 1| p->integer.maximum = 100; 93| 1| p->integer.valid_values = NULL; 94| 1| p->integer.num_valid_values = 0; 95| 1| d[i++] = p++; 96| | 97| | /* 98| | assert(i < MAX_NPARAMETERS); 99| | p->version = 2; 100| | p->name = heif_encoder_parameter_name_lossless; 101| | p->type = heif_encoder_parameter_type_boolean; 102| | p->boolean.default_value = false; 103| | p->has_default = true; 104| | d[i++] = p++; 105| |*/ 106| | 107| 1| d[i++] = nullptr; 108| 1|} _Z23get_encoder_plugin_maskv: 293| 1|{ 294| 1| return &encoder_plugin_mask; 295| 1|} encoder_mask.cc:_ZL16mask_init_pluginv: 80| 1|{ 81| 1| mask_init_parameters(); 82| 1|} encoder_mask.cc:_ZL20mask_init_parametersv: 56| 1|{ 57| 1| heif_encoder_parameter* p = mask_encoder_params; 58| 1| const heif_encoder_parameter** d = mask_encoder_parameter_ptrs; 59| 1| int i = 0; 60| | 61| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (61:3): [True: 1, False: 0] ------------------ 62| 1| p->version = 2; 63| 1| p->name = kParam_interleave; 64| 1| p->type = heif_encoder_parameter_type_string; 65| 1| p->string.default_value = "planar"; 66| 1| p->has_default = true; 67| 1| d[i++] = p++; 68| | 69| 1| assert(i < MAX_NPARAMETERS + 1); ------------------ | Branch (69:3): [True: 1, False: 0] ------------------ 70| 1| d[i++] = nullptr; 71| 1|} _Z15opj_init_pluginv: 112| 1|{ 113| 1| opj_init_parameters(); 114| 1|} _Z27get_encoder_plugin_openjpegv: 673| 1|{ 674| 1| return &encoder_plugin_openjpeg; 675| 1|} encoder_openjpeg.cc:_ZL19opj_init_parametersv: 94| 1|{ 95| 1| heif_encoder_parameter* p = opj_encoder_params; 96| 1| const heif_encoder_parameter** d = opj_encoder_parameter_ptrs; 97| 1| int i = 0; 98| | 99| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (99:3): [True: 1, False: 0] ------------------ 100| 1| p->version = 2; 101| 1| p->name = kParam_chroma; 102| 1| p->type = heif_encoder_parameter_type_string; 103| | //p->string.default_value = "420"; 104| 1| p->has_default = false; 105| 1| p->string.valid_values = kParam_chroma_valid_values; 106| 1| d[i++] = p++; 107| | 108| 1| d[i++] = nullptr; 109| 1|} _Z16ojph_init_pluginv: 231| 1|{ 232| 1| ojph_init_encoder_parameters(); 233| 1|} _Z26get_encoder_plugin_openjphv: 935| 1|{ 936| 1| return &encoder_plugin_openjph; 937| 1|} encoder_openjph.cc:_ZL28ojph_init_encoder_parametersv: 134| 1|{ 135| 1| heif_encoder_parameter* p = ojph_encoder_params; 136| 1| const heif_encoder_parameter** d = ojph_encoder_parameter_ptrs; 137| 1| int i = 0; 138| | 139| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (139:3): [True: 1, False: 0] ------------------ 140| 1| p->version = 2; 141| 1| p->name = heif_encoder_parameter_name_lossless; ------------------ | | 318| 1|#define heif_encoder_parameter_name_lossless "lossless" ------------------ 142| 1| p->type = heif_encoder_parameter_type_boolean; 143| 1| p->boolean.default_value = false; 144| 1| p->has_default = true; 145| 1| d[i++] = p++; 146| | 147| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (147:3): [True: 1, False: 0] ------------------ 148| 1| p->version = 2; 149| 1| p->name = kParam_chroma; 150| 1| p->type = heif_encoder_parameter_type_string; 151| 1| p->string.default_value = "444"; 152| 1| p->has_default = true; 153| 1| p->string.valid_values = kParam_chroma_valid_values; 154| 1| d[i++] = p++; 155| | 156| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (156:3): [True: 1, False: 0] ------------------ 157| 1| p->version = 2; 158| 1| p->name = kParam_num_decompositions; 159| 1| p->type = heif_encoder_parameter_type_integer; 160| 1| p->integer.default_value = 5; 161| 1| p->integer.have_minimum_maximum = true; 162| 1| p->integer.minimum = NUM_DECOMPOSITIONS_MIN; 163| 1| p->integer.maximum = NUM_DECOMPOSITIONS_MAX; 164| 1| p->integer.valid_values = NULL; 165| 1| p->integer.num_valid_values = 0; 166| 1| p->has_default = true; 167| 1| d[i++] = p++; 168| | 169| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (169:3): [True: 1, False: 0] ------------------ 170| 1| p->version = 2; 171| 1| p->name = kParam_progression_order; 172| 1| p->type = heif_encoder_parameter_type_string; 173| 1| p->string.default_value = "RPCL"; 174| 1| p->has_default = true; 175| 1| p->string.valid_values = kParam_progression_order_valid_values; 176| 1| d[i++] = p++; 177| | 178| |#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 10 179| | assert(i < MAX_NPARAMETERS); 180| | p->version = 2; 181| | p->name = kParam_tlm_marker; 182| | p->type = heif_encoder_parameter_type_boolean; 183| | p->boolean.default_value = false; 184| | p->has_default = true; 185| | d[i++] = p++; 186| |#endif 187| | 188| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (188:3): [True: 1, False: 0] ------------------ 189| 1| p->version = 2; 190| 1| p->name = kParam_codestream_comment; 191| 1| p->type = heif_encoder_parameter_type_string; 192| 1| p->string.default_value = nullptr; 193| 1| p->has_default = false; 194| 1| p->string.valid_values = nullptr; 195| 1| d[i++] = p++; 196| | 197| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (197:3): [True: 1, False: 0] ------------------ 198| 1| p->version = 2; 199| 1| p->name = kParam_tile_size; 200| 1| p->type = heif_encoder_parameter_type_string; 201| 1| p->string.default_value = "0,0"; 202| 1| p->has_default = true; 203| 1| p->string.valid_values = nullptr; 204| 1| d[i++] = p++; 205| | 206| |#if OPENJPH_MAJOR_VERSION > 1 || OPENJPH_MINOR_VERSION > 11 207| | assert(i < MAX_NPARAMETERS); 208| | p->version = 2; 209| | p->name = kParam_tilepart_division; 210| | p->type = heif_encoder_parameter_type_string; 211| | p->string.default_value = "none"; 212| | p->has_default = true; 213| | p->string.valid_values = kParam_tilepart_division_valid_values; 214| | d[i++] = p++; 215| |#endif 216| | 217| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (217:3): [True: 1, False: 0] ------------------ 218| 1| p->version = 2; 219| 1| p->name = kParam_block_dimensions; 220| 1| p->type = heif_encoder_parameter_type_string; 221| 1| p->string.default_value = "64,64"; 222| 1| p->has_default = true; 223| 1| p->string.valid_values = nullptr; 224| 1| d[i++] = p++; 225| | 226| 1| d[i++] = nullptr; 227| 1|} _Z22get_encoder_plugin_svtv: 1277| 1|{ 1278| 1| return &encoder_plugin_svt; 1279| 1|} encoder_svt.cc:_ZL15svt_init_pluginv: 324| 1|{ 325| 1| svt_init_parameters(); 326| 1|} encoder_svt.cc:_ZL19svt_init_parametersv: 176| 1|{ 177| 1| heif_encoder_parameter* p = svt_encoder_params; 178| 1| const heif_encoder_parameter** d = svt_encoder_parameter_ptrs; 179| 1| int i = 0; 180| | 181| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (181:3): [True: 1, False: 0] ------------------ 182| 1| p->version = 2; 183| 1| p->name = kParam_speed; 184| 1| p->type = heif_encoder_parameter_type_integer; 185| 1| p->integer.default_value = 12; 186| 1| p->has_default = true; 187| 1| p->integer.have_minimum_maximum = true; 188| 1| p->integer.minimum = 0; 189| 1| p->integer.maximum = 13; 190| 1| p->integer.valid_values = nullptr; 191| 1| p->integer.num_valid_values = 0; 192| 1| d[i++] = p++; 193| | 194| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (194:3): [True: 1, False: 0] ------------------ 195| 1| p->version = 2; 196| 1| p->name = kParam_threads; 197| 1| p->type = heif_encoder_parameter_type_integer; 198| 1| p->integer.default_value = 4; 199| 1| p->has_default = true; 200| 1| p->integer.have_minimum_maximum = true; 201| 1| p->integer.minimum = 1; 202| 1| p->integer.maximum = 16; 203| 1| p->integer.valid_values = nullptr; 204| 1| p->integer.num_valid_values = 0; 205| 1| d[i++] = p++; 206| | 207| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (207:3): [True: 1, False: 0] ------------------ 208| 1| p->version = 2; 209| 1| p->name = "tile-rows"; 210| 1| p->type = heif_encoder_parameter_type_integer; 211| 1| p->integer.default_value = 4; 212| 1| p->has_default = true; 213| 1| p->integer.have_minimum_maximum = false; 214| 1| p->integer.valid_values = valid_tile_num_values; 215| 1| p->integer.num_valid_values = 7; 216| 1| d[i++] = p++; 217| | 218| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (218:3): [True: 1, False: 0] ------------------ 219| 1| p->version = 2; 220| 1| p->name = "tile-cols"; 221| 1| p->type = heif_encoder_parameter_type_integer; 222| 1| p->integer.default_value = 4; 223| 1| p->has_default = true; 224| 1| p->integer.have_minimum_maximum = false; 225| 1| p->integer.valid_values = valid_tile_num_values; 226| 1| p->integer.num_valid_values = 7; 227| 1| d[i++] = p++; 228| | 229| | 230| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (230:3): [True: 1, False: 0] ------------------ 231| 1| p->version = 2; 232| 1| p->name = heif_encoder_parameter_name_quality; ------------------ | | 317| 1|#define heif_encoder_parameter_name_quality "quality" ------------------ 233| 1| p->type = heif_encoder_parameter_type_integer; 234| 1| p->integer.default_value = 50; 235| 1| p->has_default = true; 236| 1| p->integer.have_minimum_maximum = true; 237| 1| p->integer.minimum = 0; 238| 1| p->integer.maximum = 100; 239| 1| p->integer.valid_values = NULL; 240| 1| p->integer.num_valid_values = 0; 241| 1| d[i++] = p++; 242| | 243| 1|#if SVT_AV1_CHECK_VERSION(3, 0, 0) 244| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (244:3): [True: 1, False: 0] ------------------ 245| 1| p->version = 2; 246| 1| p->name = heif_encoder_parameter_name_lossless; ------------------ | | 318| 1|#define heif_encoder_parameter_name_lossless "lossless" ------------------ 247| 1| p->type = heif_encoder_parameter_type_boolean; 248| 1| p->boolean.default_value = false; 249| 1| p->has_default = true; 250| 1| d[i++] = p++; 251| 1|#endif 252| | 253| |#if 0 254| | assert(i < MAX_NPARAMETERS); 255| | p->version = 2; 256| | p->name = kParam_chroma; 257| | p->type = heif_encoder_parameter_type_string; 258| | p->string.default_value = "420"; 259| | p->has_default = true; 260| | p->string.valid_values = kParam_chroma_valid_values; 261| | d[i++] = p++; 262| |#endif 263| | 264| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (264:3): [True: 1, False: 0] ------------------ 265| 1| p->version = 2; 266| 1| p->name = kParam_qp; 267| 1| p->type = heif_encoder_parameter_type_integer; 268| 1| p->integer.default_value = 50; 269| 1| p->has_default = false; 270| 1| p->integer.have_minimum_maximum = true; 271| 1| p->integer.minimum = 0; 272| 1| p->integer.maximum = 63; 273| 1| p->integer.valid_values = nullptr; 274| 1| p->integer.num_valid_values = 0; 275| 1| d[i++] = p++; 276| | 277| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (277:3): [True: 1, False: 0] ------------------ 278| 1| p->version = 2; 279| 1| p->name = kParam_min_q; 280| 1| p->type = heif_encoder_parameter_type_integer; 281| 1| p->integer.default_value = 0; 282| 1| p->has_default = true; 283| 1| p->integer.have_minimum_maximum = true; 284| 1| p->integer.minimum = 0; 285| 1| p->integer.maximum = 63; 286| 1| p->integer.valid_values = nullptr; 287| 1| p->integer.num_valid_values = 0; 288| 1| d[i++] = p++; 289| | 290| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (290:3): [True: 1, False: 0] ------------------ 291| 1| p->version = 2; 292| 1| p->name = kParam_max_q; 293| 1| p->type = heif_encoder_parameter_type_integer; 294| 1| p->integer.default_value = 63; 295| 1| p->has_default = true; 296| 1| p->integer.have_minimum_maximum = true; 297| 1| p->integer.minimum = 0; 298| 1| p->integer.maximum = 63; 299| 1| p->integer.valid_values = nullptr; 300| 1| p->integer.num_valid_values = 0; 301| 1| d[i++] = p++; 302| | 303| 1|#if SVT_AV1_CHECK_VERSION(0, 9, 1) 304| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (304:3): [True: 1, False: 0] ------------------ 305| 1| p->version = 2; 306| 1| p->name = kParam_tune; 307| 1| p->type = heif_encoder_parameter_type_string; 308| 1| p->string.default_value = "psnr"; 309| 1| p->has_default = true; 310| 1| p->string.valid_values = kParam_tune_valid_values; 311| 1| d[i++] = p++; 312| 1|#endif 313| | 314| 1| d[i++] = nullptr; 315| 1|} _Z31get_encoder_plugin_uncompressedv: 359| 1|{ 360| 1| return &encoder_plugin_uncompressed; 361| 1|} encoder_uncompressed.cc:_ZL24uncompressed_init_pluginv: 80| 1|{ 81| 1| uncompressed_init_parameters(); 82| 1|} encoder_uncompressed.cc:_ZL28uncompressed_init_parametersv: 56| 1|{ 57| 1| heif_encoder_parameter* p = uncompressed_encoder_params; 58| 1| const heif_encoder_parameter** d = uncompressed_encoder_parameter_ptrs; 59| 1| int i = 0; 60| | 61| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (61:3): [True: 1, False: 0] ------------------ 62| 1| p->version = 2; 63| 1| p->name = kParam_interleave; 64| 1| p->type = heif_encoder_parameter_type_string; 65| 1| p->string.default_value = "planar"; 66| 1| p->has_default = true; 67| 1| d[i++] = p++; 68| | 69| 1| assert(i < MAX_NPARAMETERS + 1); ------------------ | Branch (69:3): [True: 1, False: 0] ------------------ 70| 1| d[i++] = nullptr; 71| 1|} _Z24get_encoder_plugin_vvencv: 875| 1|{ 876| 1| return &encoder_plugin_vvenc; 877| 1|} encoder_vvenc.cc:_ZL17vvenc_init_pluginv: 138| 1|{ 139| 1| vvenc_init_parameters(); 140| 1|} encoder_vvenc.cc:_ZL21vvenc_init_parametersv: 101| 1|{ 102| 1| heif_encoder_parameter* p = vvenc_encoder_params; 103| 1| const heif_encoder_parameter** d = vvenc_encoder_parameter_ptrs; 104| 1| int i = 0; 105| | 106| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (106:3): [True: 1, False: 0] ------------------ 107| 1| p->version = 2; 108| 1| p->name = heif_encoder_parameter_name_quality; ------------------ | | 317| 1|#define heif_encoder_parameter_name_quality "quality" ------------------ 109| 1| p->type = heif_encoder_parameter_type_integer; 110| 1| p->integer.default_value = 50; 111| 1| p->has_default = true; 112| 1| p->integer.have_minimum_maximum = true; 113| 1| p->integer.minimum = 0; 114| 1| p->integer.maximum = 100; 115| 1| p->integer.valid_values = NULL; 116| 1| p->integer.num_valid_values = 0; 117| 1| d[i++] = p++; 118| | 119| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (119:3): [True: 1, False: 0] ------------------ 120| 1| p->version = 2; 121| 1| p->name = heif_encoder_parameter_name_lossless; ------------------ | | 318| 1|#define heif_encoder_parameter_name_lossless "lossless" ------------------ 122| 1| p->type = heif_encoder_parameter_type_boolean; 123| 1| p->boolean.default_value = false; 124| 1| p->has_default = true; 125| 1| d[i++] = p++; 126| | 127| 1| d[i++] = nullptr; 128| 1|} _Z23get_encoder_plugin_x264v: 1227| 1|{ 1228| 1| return &encoder_plugin_x264; 1229| 1|} encoder_x264.cc:_ZL16x264_init_pluginv: 368| 1|{ 369| 1| x264_init_parameters(); 370| 1|} encoder_x264.cc:_ZL20x264_init_parametersv: 278| 1|{ 279| 1| heif_encoder_parameter* p = x264_encoder_params; 280| 1| const heif_encoder_parameter** d = x264_encoder_parameter_ptrs; 281| 1| int i = 0; 282| | 283| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (283:3): [True: 1, False: 0] ------------------ 284| 1| p->version = 2; 285| 1| p->name = heif_encoder_parameter_name_quality; ------------------ | | 317| 1|#define heif_encoder_parameter_name_quality "quality" ------------------ 286| 1| p->type = heif_encoder_parameter_type_integer; 287| 1| p->integer.default_value = 50; 288| 1| p->has_default = true; 289| 1| p->integer.have_minimum_maximum = true; 290| 1| p->integer.minimum = 0; 291| 1| p->integer.maximum = 100; 292| 1| p->integer.valid_values = NULL; 293| 1| p->integer.num_valid_values = 0; 294| 1| d[i++] = p++; 295| | 296| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (296:3): [True: 1, False: 0] ------------------ 297| 1| p->version = 2; 298| 1| p->name = heif_encoder_parameter_name_lossless; ------------------ | | 318| 1|#define heif_encoder_parameter_name_lossless "lossless" ------------------ 299| 1| p->type = heif_encoder_parameter_type_boolean; 300| 1| p->boolean.default_value = false; 301| 1| p->has_default = true; 302| 1| d[i++] = p++; 303| | 304| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (304:3): [True: 1, False: 0] ------------------ 305| 1| p->version = 2; 306| 1| p->name = kParam_preset; 307| 1| p->type = heif_encoder_parameter_type_string; 308| 1| p->string.default_value = "slow"; // increases computation time 309| 1| p->has_default = true; 310| 1| p->string.valid_values = kParam_preset_valid_values; 311| 1| d[i++] = p++; 312| | 313| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (313:3): [True: 1, False: 0] ------------------ 314| 1| p->version = 2; 315| 1| p->name = kParam_tune; 316| 1| p->type = heif_encoder_parameter_type_string; 317| 1| p->string.default_value = "ssim"; 318| 1| p->has_default = true; 319| 1| p->string.valid_values = kParam_tune_valid_values; 320| 1| d[i++] = p++; 321| | 322| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (322:3): [True: 1, False: 0] ------------------ 323| 1| p->version = 2; 324| 1| p->name = kParam_TU_intra_depth; 325| 1| p->type = heif_encoder_parameter_type_integer; 326| 1| p->integer.default_value = 2; // increases computation time 327| 1| p->has_default = true; 328| 1| p->integer.have_minimum_maximum = true; 329| 1| p->integer.minimum = 1; 330| 1| p->integer.maximum = 4; 331| 1| p->integer.valid_values = NULL; 332| 1| p->integer.num_valid_values = 0; 333| 1| d[i++] = p++; 334| | 335| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (335:3): [True: 1, False: 0] ------------------ 336| 1| p->version = 2; 337| 1| p->name = kParam_complexity; 338| 1| p->type = heif_encoder_parameter_type_integer; 339| 1| p->integer.default_value = 50; 340| 1| p->has_default = false; 341| 1| p->integer.have_minimum_maximum = true; 342| 1| p->integer.minimum = 0; 343| 1| p->integer.maximum = 100; 344| 1| p->integer.valid_values = NULL; 345| 1| p->integer.num_valid_values = 0; 346| 1| d[i++] = p++; 347| | 348| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (348:3): [True: 1, False: 0] ------------------ 349| 1| p->version = 2; 350| 1| p->name = kParam_chroma; 351| 1| p->type = heif_encoder_parameter_type_string; 352| 1| p->string.default_value = "420"; 353| 1| p->has_default = true; 354| 1| p->string.valid_values = kParam_chroma_valid_values; 355| 1| d[i++] = p++; 356| | 357| 1| d[i++] = nullptr; 358| 1|} _Z23get_encoder_plugin_x265v: 1287| 1|{ 1288| 1| return &encoder_plugin_x265; 1289| 1|} encoder_x265.cc:_ZL16x265_init_pluginv: 310| 1|{ 311| 1| x265_init_parameters(); 312| 1|} encoder_x265.cc:_ZL20x265_init_parametersv: 220| 1|{ 221| 1| heif_encoder_parameter* p = x265_encoder_params; 222| 1| const heif_encoder_parameter** d = x265_encoder_parameter_ptrs; 223| 1| int i = 0; 224| | 225| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (225:3): [True: 1, False: 0] ------------------ 226| 1| p->version = 2; 227| 1| p->name = heif_encoder_parameter_name_quality; ------------------ | | 317| 1|#define heif_encoder_parameter_name_quality "quality" ------------------ 228| 1| p->type = heif_encoder_parameter_type_integer; 229| 1| p->integer.default_value = 50; 230| 1| p->has_default = true; 231| 1| p->integer.have_minimum_maximum = true; 232| 1| p->integer.minimum = 0; 233| 1| p->integer.maximum = 100; 234| 1| p->integer.valid_values = NULL; 235| 1| p->integer.num_valid_values = 0; 236| 1| d[i++] = p++; 237| | 238| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (238:3): [True: 1, False: 0] ------------------ 239| 1| p->version = 2; 240| 1| p->name = heif_encoder_parameter_name_lossless; ------------------ | | 318| 1|#define heif_encoder_parameter_name_lossless "lossless" ------------------ 241| 1| p->type = heif_encoder_parameter_type_boolean; 242| 1| p->boolean.default_value = false; 243| 1| p->has_default = true; 244| 1| d[i++] = p++; 245| | 246| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (246:3): [True: 1, False: 0] ------------------ 247| 1| p->version = 2; 248| 1| p->name = kParam_preset; 249| 1| p->type = heif_encoder_parameter_type_string; 250| 1| p->string.default_value = "slow"; // increases computation time 251| 1| p->has_default = true; 252| 1| p->string.valid_values = kParam_preset_valid_values; 253| 1| d[i++] = p++; 254| | 255| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (255:3): [True: 1, False: 0] ------------------ 256| 1| p->version = 2; 257| 1| p->name = kParam_tune; 258| 1| p->type = heif_encoder_parameter_type_string; 259| 1| p->string.default_value = "ssim"; 260| 1| p->has_default = true; 261| 1| p->string.valid_values = kParam_tune_valid_values; 262| 1| d[i++] = p++; 263| | 264| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (264:3): [True: 1, False: 0] ------------------ 265| 1| p->version = 2; 266| 1| p->name = kParam_TU_intra_depth; 267| 1| p->type = heif_encoder_parameter_type_integer; 268| 1| p->integer.default_value = 2; // increases computation time 269| 1| p->has_default = true; 270| 1| p->integer.have_minimum_maximum = true; 271| 1| p->integer.minimum = 1; 272| 1| p->integer.maximum = 4; 273| 1| p->integer.valid_values = NULL; 274| 1| p->integer.num_valid_values = 0; 275| 1| d[i++] = p++; 276| | 277| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (277:3): [True: 1, False: 0] ------------------ 278| 1| p->version = 2; 279| 1| p->name = kParam_complexity; 280| 1| p->type = heif_encoder_parameter_type_integer; 281| 1| p->integer.default_value = 50; 282| 1| p->has_default = false; 283| 1| p->integer.have_minimum_maximum = true; 284| 1| p->integer.minimum = 0; 285| 1| p->integer.maximum = 100; 286| 1| p->integer.valid_values = NULL; 287| 1| p->integer.num_valid_values = 0; 288| 1| d[i++] = p++; 289| | 290| 1| assert(i < MAX_NPARAMETERS); ------------------ | Branch (290:3): [True: 1, False: 0] ------------------ 291| 1| p->version = 2; 292| 1| p->name = kParam_chroma; 293| 1| p->type = heif_encoder_parameter_type_string; 294| 1| p->string.default_value = "420"; 295| 1| p->has_default = true; 296| 1| p->string.valid_values = kParam_chroma_valid_values; 297| 1| d[i++] = p++; 298| | 299| 1| d[i++] = nullptr; 300| 1|} aom_codec_version: 25| 1|int aom_codec_version(void) { return VERSION_PACKED; } ------------------ | | 17| 1| ((VERSION_MAJOR << 16) | (VERSION_MINOR << 8) | (VERSION_PATCH)) | | ------------------ | | | | 12| 1|#define VERSION_MAJOR 3 | | ------------------ | | ((VERSION_MAJOR << 16) | (VERSION_MINOR << 8) | (VERSION_PATCH)) | | ------------------ | | | | 13| 1|#define VERSION_MINOR 2 | | ------------------ | | ((VERSION_MAJOR << 16) | (VERSION_MINOR << 8) | (VERSION_PATCH)) | | ------------------ | | | | 14| 1|#define VERSION_PATCH 0 | | ------------------ ------------------ de265_init: 205| 1|{ 206| 1| std::lock_guard lock(de265_init_mutex()); 207| | 208| 1| de265_init_count++; 209| | 210| 1| if (de265_init_count > 1) { ------------------ | Branch (210:7): [True: 0, False: 1] ------------------ 211| | // we are not the first -> already initialized 212| | 213| 0| return DE265_OK; 214| 0| } 215| | 216| | 217| | // do initializations 218| | 219| 1| init_scan_orders(); 220| | 221| 1| if (!alloc_and_init_significant_coeff_ctxIdx_lookupTable()) { ------------------ | Branch (221:7): [True: 0, False: 1] ------------------ 222| 0| de265_init_count--; 223| 0| return DE265_ERROR_LIBRARY_INITIALIZATION_FAILED; 224| 0| } 225| | 226| 1| return DE265_OK; 227| 1|} de265.cc:_ZL16de265_init_mutexv: 198| 1|{ 199| 1| static std::mutex de265_init_mutex; 200| 1| return de265_init_mutex; 201| 1|} _Z14get_scan_orderii: 81| 8.16k|{ 82| 8.16k| switch (scanIdx) { 83| 2.72k| case 0: return scan_d[log2BlockSize]; ------------------ | Branch (83:3): [True: 2.72k, False: 5.44k] ------------------ 84| 2.72k| case 1: return scan_h[log2BlockSize]; ------------------ | Branch (84:3): [True: 2.72k, False: 5.44k] ------------------ 85| 2.72k| case 2: return scan_v[log2BlockSize]; ------------------ | Branch (85:3): [True: 2.72k, False: 5.44k] ------------------ 86| 0| default: return 0; // should never happen ------------------ | Branch (86:3): [True: 0, False: 8.16k] ------------------ 87| 8.16k| } 88| 8.16k|} _Z16init_scan_ordersv: 136| 1|{ 137| 6| for (int log2size=1;log2size<=5;log2size++) ------------------ | Branch (137:23): [True: 5, False: 1] ------------------ 138| 5| { 139| 5| init_scan_h(scan_h[log2size], 1<=0) { ------------------ | Branch (64:12): [True: 2.66k, False: 119] ------------------ 65| 2.66k| if (xsubBlock = lastSubBlock; 131| 4.08k| pos->scanPos = lastScanPos; 132| 4.08k|} _Z51alloc_and_init_significant_coeff_ctxIdx_lookupTablev: 1996| 1|{ 1997| 1| int tableSize = 4 * 4 * (2) + 8 * 8 * (2 * 2 * 4) + 16 * 16 * (2 * 4) + 32 * 32 * (2 * 4); 1998| | 1999| 1| uint8_t* p = (uint8_t*) malloc(tableSize); 2000| 1| if (p == nullptr) { ------------------ | Branch (2000:7): [True: 0, False: 1] ------------------ 2001| 0| return false; 2002| 0| } 2003| | 2004| 1| memset(p, 0xFF, tableSize); // just for debugging 2005| | 2006| | 2007| | // --- Set pointers to memory areas. Note that some parameters share the same memory. --- 2008| | 2009| | // 4x4 2010| | 2011| 3| for (int cIdx = 0; cIdx < 2; cIdx++) { ------------------ | Branch (2011:22): [True: 2, False: 1] ------------------ 2012| 6| for (int scanIdx = 0; scanIdx < 2; scanIdx++) ------------------ | Branch (2012:27): [True: 4, False: 2] ------------------ 2013| 20| for (int prevCsbf = 0; prevCsbf < 4; prevCsbf++) ------------------ | Branch (2013:30): [True: 16, False: 4] ------------------ 2014| 16| ctxIdxLookup[0][cIdx][scanIdx][prevCsbf] = p; 2015| | 2016| 2| p += 4 * 4; 2017| 2| } 2018| | 2019| | // 8x8 2020| | 2021| 3| for (int cIdx = 0; cIdx < 2; cIdx++) ------------------ | Branch (2021:22): [True: 2, False: 1] ------------------ 2022| 6| for (int scanIdx = 0; scanIdx < 2; scanIdx++) ------------------ | Branch (2022:27): [True: 4, False: 2] ------------------ 2023| 20| for (int prevCsbf = 0; prevCsbf < 4; prevCsbf++) { ------------------ | Branch (2023:30): [True: 16, False: 4] ------------------ 2024| 16| ctxIdxLookup[1][cIdx][scanIdx][prevCsbf] = p; 2025| 16| p += 8 * 8; 2026| 16| } 2027| | 2028| | // 16x16 2029| | 2030| 3| for (int cIdx = 0; cIdx < 2; cIdx++) ------------------ | Branch (2030:22): [True: 2, False: 1] ------------------ 2031| 10| for (int prevCsbf = 0; prevCsbf < 4; prevCsbf++) { ------------------ | Branch (2031:28): [True: 8, False: 2] ------------------ 2032| 24| for (int scanIdx = 0; scanIdx < 2; scanIdx++) { ------------------ | Branch (2032:29): [True: 16, False: 8] ------------------ 2033| 16| ctxIdxLookup[2][cIdx][scanIdx][prevCsbf] = p; 2034| 16| } 2035| | 2036| 8| p += 16 * 16; 2037| 8| } 2038| | 2039| | // 32x32 2040| | 2041| 3| for (int cIdx = 0; cIdx < 2; cIdx++) ------------------ | Branch (2041:22): [True: 2, False: 1] ------------------ 2042| 10| for (int prevCsbf = 0; prevCsbf < 4; prevCsbf++) { ------------------ | Branch (2042:28): [True: 8, False: 2] ------------------ 2043| 24| for (int scanIdx = 0; scanIdx < 2; scanIdx++) { ------------------ | Branch (2043:29): [True: 16, False: 8] ------------------ 2044| 16| ctxIdxLookup[3][cIdx][scanIdx][prevCsbf] = p; 2045| 16| } 2046| | 2047| 8| p += 32 * 32; 2048| 8| } 2049| | 2050| | 2051| | // --- precompute ctxIdx tables --- 2052| | 2053| 5| for (int log2w = 2; log2w <= 5; log2w++) ------------------ | Branch (2053:23): [True: 4, False: 1] ------------------ 2054| 12| for (int cIdx = 0; cIdx < 2; cIdx++) ------------------ | Branch (2054:24): [True: 8, False: 4] ------------------ 2055| 24| for (int scanIdx = 0; scanIdx < 2; scanIdx++) ------------------ | Branch (2055:29): [True: 16, False: 8] ------------------ 2056| 80| for (int prevCsbf = 0; prevCsbf < 4; prevCsbf++) { ------------------ | Branch (2056:32): [True: 64, False: 16] ------------------ 2057| 1.02k| for (int yC = 0; yC < (1 << log2w); yC++) ------------------ | Branch (2057:28): [True: 960, False: 64] ------------------ 2058| 22.7k| for (int xC = 0; xC < (1 << log2w); xC++) { ------------------ | Branch (2058:30): [True: 21.7k, False: 960] ------------------ 2059| 21.7k| int w = 1 << log2w; 2060| 21.7k| int sbWidth = w >> 2; 2061| | 2062| 21.7k| int sigCtx; 2063| | 2064| | // if log2TrafoSize==2 2065| 21.7k| if (sbWidth == 1) { ------------------ | Branch (2065:19): [True: 256, False: 21.5k] ------------------ 2066| 256| sigCtx = ctxIdxMap[(yC << 2) + xC]; 2067| 256| } 2068| 21.5k| else if (xC + yC == 0) { ------------------ | Branch (2068:24): [True: 48, False: 21.4k] ------------------ 2069| 48| sigCtx = 0; 2070| 48| } 2071| 21.4k| else { 2072| 21.4k| int xS = xC >> 2; 2073| 21.4k| int yS = yC >> 2; 2074| | /* 2075| | int prevCsbf = 0; 2076| | 2077| | if (xS < sbWidth-1) { prevCsbf += coded_sub_block_flag[xS+1 +yS*sbWidth]; } 2078| | if (yS < sbWidth-1) { prevCsbf += coded_sub_block_flag[xS+(1+yS)*sbWidth]<<1; } 2079| | */ 2080| 21.4k| int xP = xC & 3; 2081| 21.4k| int yP = yC & 3; 2082| | 2083| | //logtrace(LogSlice,"posInSubset: %d,%d\n",xP,yP); 2084| | //logtrace(LogSlice,"prevCsbf: %d\n",prevCsbf); 2085| | 2086| 21.4k| switch (prevCsbf) { 2087| 5.36k| case 0: ------------------ | Branch (2087:19): [True: 5.36k, False: 16.0k] ------------------ 2088| 5.36k| sigCtx = (xP + yP >= 3) ? 0 : (xP + yP > 0) ? 1 : 2; ------------------ | Branch (2088:30): [True: 3.36k, False: 2.00k] | Branch (2088:51): [True: 1.68k, False: 324] ------------------ 2089| 5.36k| break; 2090| 5.36k| case 1: ------------------ | Branch (2090:19): [True: 5.36k, False: 16.0k] ------------------ 2091| 5.36k| sigCtx = (yP == 0) ? 2 : (yP == 1) ? 1 : 0; ------------------ | Branch (2091:30): [True: 1.33k, False: 4.03k] | Branch (2091:46): [True: 1.34k, False: 2.68k] ------------------ 2092| 5.36k| break; 2093| 5.36k| case 2: ------------------ | Branch (2093:19): [True: 5.36k, False: 16.0k] ------------------ 2094| 5.36k| sigCtx = (xP == 0) ? 2 : (xP == 1) ? 1 : 0; ------------------ | Branch (2094:30): [True: 1.33k, False: 4.03k] | Branch (2094:46): [True: 1.34k, False: 2.68k] ------------------ 2095| 5.36k| break; 2096| 5.36k| default: ------------------ | Branch (2096:19): [True: 5.36k, False: 16.0k] ------------------ 2097| 5.36k| sigCtx = 2; 2098| 5.36k| break; 2099| 21.4k| } 2100| | 2101| | //logtrace(LogSlice,"a) sigCtx=%d\n",sigCtx); 2102| | 2103| 21.4k| if (cIdx == 0) { ------------------ | Branch (2103:21): [True: 10.7k, False: 10.7k] ------------------ 2104| 10.7k| if (xS + yS > 0) sigCtx += 3; ------------------ | Branch (2104:23): [True: 10.3k, False: 360] ------------------ 2105| | 2106| | //logtrace(LogSlice,"b) sigCtx=%d\n",sigCtx); 2107| | 2108| | // if log2TrafoSize==3 2109| 10.7k| if (sbWidth == 2) { ------------------ | Branch (2109:23): [True: 504, False: 10.2k] ------------------ 2110| | // 8x8 block 2111| 504| sigCtx += (scanIdx == 0) ? 9 : 15; ------------------ | Branch (2111:31): [True: 252, False: 252] ------------------ 2112| 504| } 2113| 10.2k| else { 2114| 10.2k| sigCtx += 21; 2115| 10.2k| } 2116| | 2117| | //logtrace(LogSlice,"c) sigCtx=%d\n",sigCtx); 2118| 10.7k| } 2119| 10.7k| else { 2120| | // if log2TrafoSize==3 2121| 10.7k| if (sbWidth == 2) { ------------------ | Branch (2121:23): [True: 504, False: 10.2k] ------------------ 2122| | // 8x8 block 2123| 504| sigCtx += 9; 2124| 504| } 2125| 10.2k| else { 2126| 10.2k| sigCtx += 12; 2127| 10.2k| } 2128| 10.7k| } 2129| 21.4k| } 2130| | 2131| 21.7k| int ctxIdxInc; 2132| 21.7k| if (cIdx == 0) { ctxIdxInc = sigCtx; } ------------------ | Branch (2132:19): [True: 10.8k, False: 10.8k] ------------------ 2133| 10.8k| else { ctxIdxInc = 27 + sigCtx; } 2134| | 2135| 21.7k| if (ctxIdxLookup[log2w - 2][cIdx][scanIdx][prevCsbf][xC + (yC << log2w)] != 0xFF) { ------------------ | Branch (2135:19): [True: 10.4k, False: 11.2k] ------------------ 2136| 10.4k| assert(ctxIdxLookup[log2w-2][cIdx][scanIdx][prevCsbf][xC+(yC<> 7; // from i extract context 152| | // See if this case exist in the table, if so then set the entry in 153| | // vlc_tbl0 154| 455k| for (size_t j = 0; j < tbl0_size; ++j) ------------------ | Branch (154:28): [True: 454k, False: 1.02k] ------------------ 155| 454k| if (tbl0[j].c_q == c_q) // this is an and operation ------------------ | Branch (155:15): [True: 56.8k, False: 397k] ------------------ 156| 56.8k| if (tbl0[j].cwd == (cwd & ((1 << tbl0[j].cwd_len) - 1))) ------------------ | Branch (156:17): [True: 1.02k, False: 55.8k] ------------------ 157| 1.02k| { 158| 1.02k| if (debug) assert(vlc_tbl0[i] == 0); ------------------ | Branch (158:19): [Folded, False: 1.02k] ------------------ 159| | // Put this entry into the table 160| 1.02k| vlc_tbl0[i] = (ui16)((tbl0[j].rho << 4) | (tbl0[j].u_off << 3) 161| 1.02k| | (tbl0[j].e_k << 12) | (tbl0[j].e_1 << 8) | tbl0[j].cwd_len); 162| 1.02k| } 163| 1.02k| } 164| | 165| 1| if (debug) memset(vlc_tbl1, 0, sizeof(vlc_tbl1)); //unnecessary ------------------ | Branch (165:11): [Folded, False: 1] ------------------ 166| | 167| | // this the same as above but for non-initial rows 168| 1.02k| for (int i = 0; i < 1024; ++i) ------------------ | Branch (168:23): [True: 1.02k, False: 1] ------------------ 169| 1.02k| { 170| 1.02k| int cwd = i & 0x7F; //7 bits 171| 1.02k| int c_q = i >> 7; 172| 367k| for (size_t j = 0; j < tbl1_size; ++j) ------------------ | Branch (172:28): [True: 366k, False: 1.02k] ------------------ 173| 366k| if (tbl1[j].c_q == c_q) // this is an and operation ------------------ | Branch (173:15): [True: 45.8k, False: 320k] ------------------ 174| 45.8k| if (tbl1[j].cwd == (cwd & ((1 << tbl1[j].cwd_len) - 1))) ------------------ | Branch (174:17): [True: 1.02k, False: 44.8k] ------------------ 175| 1.02k| { 176| 1.02k| if (debug) assert(vlc_tbl1[i] == 0); ------------------ | Branch (176:19): [Folded, False: 1.02k] ------------------ 177| 1.02k| vlc_tbl1[i] = (ui16)((tbl1[j].rho << 4) | (tbl1[j].u_off << 3) 178| 1.02k| | (tbl1[j].e_k << 12) | (tbl1[j].e_1 << 8) | tbl1[j].cwd_len); 179| 1.02k| } 180| 1.02k| } 181| | 182| 1| return true; 183| 1| } ojph_block_common.cpp:_ZN4ojph5localL16uvlc_init_tablesEv: 190| 1| { 191| | // table stores possible decoding three bits from vlc 192| | // there are 8 entries for xx1, x10, 100, 000, where x means do not 193| | // care table value is made up of 194| | // 2 bits in the LSB for prefix length 195| | // 3 bits for suffix length 196| | // 3 bits in the MSB for prefix value (u_pfx in Table 3 of ITU T.814) 197| 1| static const ui8 dec[8] = { // the index is the prefix codeword 198| 1| 3 | (5 << 2) | (5 << 5), //000 == 000, prefix codeword "000" 199| 1| 1 | (0 << 2) | (1 << 5), //001 == xx1, prefix codeword "1" 200| 1| 2 | (0 << 2) | (2 << 5), //010 == x10, prefix codeword "01" 201| 1| 1 | (0 << 2) | (1 << 5), //011 == xx1, prefix codeword "1" 202| 1| 3 | (1 << 2) | (3 << 5), //100 == 100, prefix codeword "001" 203| 1| 1 | (0 << 2) | (1 << 5), //101 == xx1, prefix codeword "1" 204| 1| 2 | (0 << 2) | (2 << 5), //110 == x10, prefix codeword "01" 205| 1| 1 | (0 << 2) | (1 << 5) //111 == xx1, prefix codeword "1" 206| 1| }; 207| | 208| 321| for (ui32 i = 0; i < 256 + 64; ++i) ------------------ | Branch (208:24): [True: 320, False: 1] ------------------ 209| 320| { 210| 320| ui32 mode = i >> 6; 211| 320| ui32 vlc = i & 0x3F; 212| | 213| 320| if (mode == 0) { // both u_off are 0 ------------------ | Branch (213:13): [True: 64, False: 256] ------------------ 214| 64| uvlc_tbl0[i] = 0; 215| 64| uvlc_bias[i] = 0; 216| 64| } 217| 256| else if (mode <= 2) // u_off are either 01 or 10 ------------------ | Branch (217:18): [True: 128, False: 128] ------------------ 218| 128| { 219| 128| ui32 d = dec[vlc & 0x7]; //look at the least significant 3 bits 220| | 221| 128| ui32 total_prefix = d & 0x3; 222| 128| ui32 total_suffix = (d >> 2) & 0x7; 223| 128| ui32 u0_suffix_len = (mode == 1) ? total_suffix : 0; ------------------ | Branch (223:32): [True: 64, False: 64] ------------------ 224| 128| ui32 u0 = (mode == 1) ? (d >> 5) : 0; ------------------ | Branch (224:21): [True: 64, False: 64] ------------------ 225| 128| ui32 u1 = (mode == 1) ? 0 : (d >> 5); ------------------ | Branch (225:21): [True: 64, False: 64] ------------------ 226| | 227| 128| uvlc_tbl0[i] = (ui16)(total_prefix | 228| 128| (total_suffix << 3) | 229| 128| (u0_suffix_len << 7) | 230| 128| (u0 << 10) | 231| 128| (u1 << 13)); 232| | 233| 128| } 234| 128| else if (mode == 3) // both u_off are 1, and MEL event is 0 ------------------ | Branch (234:18): [True: 64, False: 64] ------------------ 235| 64| { 236| 64| ui32 d0 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword 237| 64| vlc >>= d0 & 0x3; // Consume bits 238| 64| ui32 d1 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword 239| | 240| 64| ui32 total_prefix, u0_suffix_len, total_suffix, u0, u1; 241| 64| if ((d0 & 0x3) == 3) ------------------ | Branch (241:15): [True: 16, False: 48] ------------------ 242| 16| { 243| 16| total_prefix = (d0 & 0x3) + 1; 244| 16| u0_suffix_len = (d0 >> 2) & 0x7; 245| 16| total_suffix = u0_suffix_len; 246| 16| u0 = d0 >> 5; 247| 16| u1 = (vlc & 1) + 1; 248| 16| uvlc_bias[i] = 4; // 0b00 for u0 and 0b01 for u1 249| 16| } 250| 48| else 251| 48| { 252| 48| total_prefix = (d0 & 0x3) + (d1 & 0x3); 253| 48| u0_suffix_len = (d0 >> 2) & 0x7; 254| 48| total_suffix = u0_suffix_len + ((d1 >> 2) & 0x7); 255| 48| u0 = d0 >> 5; 256| 48| u1 = d1 >> 5; 257| 48| uvlc_bias[i] = 0; 258| 48| } 259| | 260| 64| uvlc_tbl0[i] = (ui16)(total_prefix | 261| 64| (total_suffix << 3) | 262| 64| (u0_suffix_len << 7) | 263| 64| (u0 << 10) | 264| 64| (u1 << 13)); 265| 64| } 266| 64| else if (mode == 4) // both u_off are 1, and MEL event is 1 ------------------ | Branch (266:18): [True: 64, False: 0] ------------------ 267| 64| { 268| 64| ui32 d0 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword 269| 64| vlc >>= d0 & 0x3; // Consume bits 270| 64| ui32 d1 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword 271| | 272| 64| ui32 total_prefix = (d0 & 0x3) + (d1 & 0x3); 273| 64| ui32 u0_suffix_len = (d0 >> 2) & 0x7; 274| 64| ui32 total_suffix = u0_suffix_len + ((d1 >> 2) & 0x7); 275| 64| ui32 u0 = (d0 >> 5) + 2; 276| 64| ui32 u1 = (d1 >> 5) + 2; 277| | 278| 64| uvlc_tbl0[i] = (ui16)(total_prefix | 279| 64| (total_suffix << 3) | 280| 64| (u0_suffix_len << 7) | 281| 64| (u0 << 10) | 282| 64| (u1 << 13)); 283| 64| uvlc_bias[i] = 10; // 0b10 for u0 and 0b10 for u1 284| 64| } 285| 320| } 286| | 287| 257| for (ui32 i = 0; i < 256; ++i) ------------------ | Branch (287:24): [True: 256, False: 1] ------------------ 288| 256| { 289| 256| ui32 mode = i >> 6; 290| 256| ui32 vlc = i & 0x3F; 291| | 292| 256| if (mode == 0) // both u_off are 0 ------------------ | Branch (292:13): [True: 64, False: 192] ------------------ 293| 64| uvlc_tbl1[i] = 0; 294| 192| else if (mode <= 2) // u_off are either 01 or 10 ------------------ | Branch (294:18): [True: 128, False: 64] ------------------ 295| 128| { 296| 128| ui32 d = dec[vlc & 0x7]; // look at the 3 LSB bits 297| | 298| 128| ui32 total_prefix = d & 0x3; 299| 128| ui32 total_suffix = (d >> 2) & 0x7; 300| 128| ui32 u0_suffix_len = (mode == 1) ? total_suffix : 0; ------------------ | Branch (300:32): [True: 64, False: 64] ------------------ 301| 128| ui32 u0 = (mode == 1) ? (d >> 5) : 0; ------------------ | Branch (301:21): [True: 64, False: 64] ------------------ 302| 128| ui32 u1 = (mode == 1) ? 0 : (d >> 5); ------------------ | Branch (302:21): [True: 64, False: 64] ------------------ 303| | 304| 128| uvlc_tbl1[i] = (ui16)(total_prefix | 305| 128| (total_suffix << 3) | 306| 128| (u0_suffix_len << 7) | 307| 128| (u0 << 10) | 308| 128| (u1 << 13)); 309| 128| } 310| 64| else if (mode == 3) // both u_off are 1 ------------------ | Branch (310:18): [True: 64, False: 0] ------------------ 311| 64| { 312| 64| ui32 d0 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword 313| 64| vlc >>= d0 & 0x3; // Consume bits 314| 64| ui32 d1 = dec[vlc & 0x7]; // LSBs of VLC are prefix codeword 315| | 316| 64| ui32 total_prefix = (d0 & 0x3) + (d1 & 0x3); 317| 64| ui32 u0_suffix_len = (d0 >> 2) & 0x7; 318| 64| ui32 total_suffix = u0_suffix_len + ((d1 >> 2) & 0x7); 319| 64| ui32 u0 = d0 >> 5; 320| 64| ui32 u1 = d1 >> 5; 321| | 322| 64| uvlc_tbl1[i] = (ui16)(total_prefix | 323| 64| (total_suffix << 3) | 324| 64| (u0_suffix_len << 7) | 325| 64| (u0 << 10) | 326| 64| (u1 << 13)); 327| 64| } 328| 256| } 329| 1| return true; 330| 1| } ojph_codestream.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_codestream_local.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_params.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_tile.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_tile_comp.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_file.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_mem.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_message.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_colour.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_transform.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_colour_sse.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_transform_sse.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_colour_sse2.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_transform_sse2.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_colour_avx.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_transform_avx.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_colour_avx2.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_transform_avx2.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_transform_avx512.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_resolution.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_subband.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_arch.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_codeblock.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_codeblock_fun.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_codestream_gen.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_precinct.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_block_decoder32.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_block_decoder64.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_block_encoder.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_codestream_sse.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_codestream_sse2.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_block_decoder_ssse3.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_codestream_avx.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_codestream_avx2.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_block_decoder_avx2.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_block_encoder_avx2.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } ojph_block_encoder_avx512.cpp:_ZN4ojphL19count_leading_zerosEj: 178| 1| { 179| | #ifdef OJPH_COMPILER_MSVC 180| | unsigned long result = 0; 181| | _BitScanReverse(&result, val); 182| | return 31 ^ (ui32)result; 183| | #elif (defined OJPH_COMPILER_GNUC) 184| | return (ui32)__builtin_clz(val); 185| | #else 186| | val |= (val >> 1); 187| | val |= (val >> 2); 188| | val |= (val >> 4); 189| | val |= (val >> 8); 190| | val |= (val >> 16); 191| | return 32 - population_count(val); 192| | #endif 193| 1| } _ZN4ojph9run_cpuidEjjPj: 53| 2| { 54| | #ifdef OJPH_COMPILER_MSVC 55| | __cpuidex((int *)abcd, eax, ecx); 56| | #else 57| 2| uint32_t ebx = 0, edx = 0; 58| | #if defined( __i386__ ) && defined ( __PIC__ ) 59| | /* in case of PIC under 32-bit EBX cannot be clobbered */ 60| | __asm__ ( "movl %%ebx, %%edi \n\t cpuid \n\t xchgl %%ebx, %%edi" 61| | : "=D" (ebx), "+a" (eax), "+c" (ecx), "=d" (edx) ); 62| | #else 63| 2| __asm__ ( "cpuid" : "+b" (ebx), "+a" (eax), "+c" (ecx), "=d" (edx) ); 64| 2| #endif 65| 2| abcd[0] = eax; abcd[1] = ebx; abcd[2] = ecx; abcd[3] = edx; 66| 2| #endif 67| 2| return true; 68| 2| } _ZN4ojph8read_xcrEj: 72| 1| { 73| | #ifdef OJPH_COMPILER_MSVC 74| | return _xgetbv(index); 75| | #else 76| 1| uint32_t eax = 0, edx = 0; 77| 1| __asm__ ( "xgetbv" : "=a" (eax), "=d" (edx) : "c" (index) ); 78| 1| return ((uint64_t)edx << 32) | eax; 79| 1| #endif 80| 1| } _ZN4ojph18init_cpu_ext_levelERi: 84| 1| { 85| 1| uint32_t mmx_abcd[4]; 86| 1| run_cpuid(1, 0, mmx_abcd); 87| 1| bool mmx_avail = ((mmx_abcd[3] & 0x00800000) == 0x00800000); 88| | 89| 1| level = 0; 90| 1| if (mmx_avail) ------------------ | Branch (90:9): [True: 1, False: 0] ------------------ 91| 1| { 92| 1| level = X86_CPU_EXT_LEVEL_MMX; 93| 1| bool sse_avail = ((mmx_abcd[3] & 0x02000000) == 0x02000000); 94| 1| if (sse_avail) ------------------ | Branch (94:11): [True: 1, False: 0] ------------------ 95| 1| { 96| 1| level = X86_CPU_EXT_LEVEL_SSE; 97| 1| bool sse2_avail = ((mmx_abcd[3] & 0x04000000) == 0x04000000); 98| 1| if (sse2_avail) ------------------ | Branch (98:13): [True: 1, False: 0] ------------------ 99| 1| { 100| 1| level = X86_CPU_EXT_LEVEL_SSE2; 101| 1| bool sse3_avail = ((mmx_abcd[2] & 0x00000001) == 0x00000001); 102| 1| if (sse3_avail) ------------------ | Branch (102:15): [True: 1, False: 0] ------------------ 103| 1| { 104| 1| level = X86_CPU_EXT_LEVEL_SSE3; 105| 1| bool ssse3_avail = ((mmx_abcd[2] & 0x00000200) == 0x00000200); 106| 1| if (ssse3_avail) ------------------ | Branch (106:17): [True: 1, False: 0] ------------------ 107| 1| { 108| 1| level = X86_CPU_EXT_LEVEL_SSSE3; 109| 1| bool sse41_avail = ((mmx_abcd[2] & 0x00080000) == 0x00080000); 110| 1| if (sse41_avail) { ------------------ | Branch (110:19): [True: 1, False: 0] ------------------ 111| 1| level = X86_CPU_EXT_LEVEL_SSE41; 112| 1| bool sse42_avail = ((mmx_abcd[2] & 0x00100000) == 0x00100000); 113| 1| if (sse42_avail) ------------------ | Branch (113:21): [True: 1, False: 0] ------------------ 114| 1| { 115| 1| level = X86_CPU_EXT_LEVEL_SSE42; 116| | 117| 1| uint64_t xcr_val = 0; 118| 1| bool osxsave_avail, ymm_avail, avx_avail = false; 119| 1| osxsave_avail = ((mmx_abcd[2] & 0x08000000) == 0x08000000); 120| 1| if (osxsave_avail) ------------------ | Branch (120:23): [True: 1, False: 0] ------------------ 121| 1| { 122| 1| xcr_val = read_xcr(0); // _XCR_XFEATURE_ENABLED_MASK = 0 123| 1| ymm_avail = osxsave_avail && ((xcr_val & 0x6) == 0x6); ------------------ | Branch (123:33): [True: 1, False: 0] | Branch (123:50): [True: 1, False: 0] ------------------ 124| 1| avx_avail = ymm_avail && (mmx_abcd[2] & 0x10000000); ------------------ | Branch (124:33): [True: 1, False: 0] | Branch (124:46): [True: 1, False: 0] ------------------ 125| 1| } 126| 1| if (avx_avail) ------------------ | Branch (126:23): [True: 1, False: 0] ------------------ 127| 1| { 128| 1| level = X86_CPU_EXT_LEVEL_AVX; 129| | 130| 1| uint32_t avx2_abcd[4]; 131| 1| run_cpuid(7, 0, avx2_abcd); 132| 1| bool avx2_avail = (avx2_abcd[1] & 0x20) != 0; 133| 1| if (avx2_avail) ------------------ | Branch (133:25): [True: 1, False: 0] ------------------ 134| 1| { 135| 1| level = X86_CPU_EXT_LEVEL_AVX2; 136| 1| bool avx2fma_avail = 137| 1| avx2_avail && ((mmx_abcd[2] & 0x1000) == 0x1000); ------------------ | Branch (137:25): [True: 1, False: 0] | Branch (137:39): [True: 1, False: 0] ------------------ 138| 1| if (avx2fma_avail) ------------------ | Branch (138:27): [True: 1, False: 0] ------------------ 139| 1| { 140| 1| level = X86_CPU_EXT_LEVEL_AVX2FMA; 141| | 142| 1| bool zmm_avail = 143| 1| osxsave_avail && ((xcr_val & 0xE0) == 0xE0); ------------------ | Branch (143:27): [True: 1, False: 0] | Branch (143:44): [True: 0, False: 1] ------------------ 144| 1| bool avx512f_avail = (avx2_abcd[1] & 0x10000) != 0; 145| 1| bool avx512cd_avail = (avx2_abcd[1] & 0x10000000) != 0; 146| 1| bool avx512_avail = 147| 1| zmm_avail && avx512f_avail && avx512cd_avail; ------------------ | Branch (147:27): [True: 0, False: 1] | Branch (147:40): [True: 0, False: 0] | Branch (147:57): [True: 0, False: 0] ------------------ 148| 1| if (avx512_avail) ------------------ | Branch (148:29): [True: 0, False: 1] ------------------ 149| 0| level = X86_CPU_EXT_LEVEL_AVX512; 150| 1| } 151| 1| } 152| 1| } 153| 1| } 154| 1| } 155| 1| } 156| 1| } 157| 1| } 158| 1| } 159| 1| } 160| 1| return true; 161| 1| } _ZN5vvdec12PelBufferOpsC2Ev: 341| 1|{ 342| 1| addAvg4 = addAvgCore; 343| 1| addAvg8 = addAvgCore; 344| 1| addAvg16 = addAvgCore; 345| | 346| 1| reco4 = reconstructCore; 347| 1| reco8 = reconstructCore; 348| | 349| 1| linTf4 = linTfCore; 350| 1| linTf8 = linTfCore; 351| | 352| 1| wghtAvg4 = addWeightedAvgCore; 353| 1| wghtAvg8 = addWeightedAvgCore; 354| | 355| 1| copyBuffer = copyBufferCore; 356| | 357| 1| transpose4x4 = transpose4x4Core; 358| 1| transpose8x8 = transpose8x8Core; 359| | 360| 1| applyLut = applyLutCore; 361| 1| rspFwd = rspFwdCore; 362| 1| rspBcw = nullptr; 363| | 364| 1| fillN_CU = fillN_CuCore; 365| | 366| 1| sampleRateConv = sampleRateConvCore; 367| 1|} _ZN5vvdec6CtxSetC2ESt16initializer_listIS0_E: 82| 2|{ 83| 2| uint16_t minOffset = std::numeric_limits::max(); 84| 2| uint16_t maxOffset = 0; 85| 2| for( auto& set: ctxSets ) ------------------ | Branch (85:17): [True: 5, False: 2] ------------------ 86| 5| { 87| 5| minOffset = std::min( minOffset, set.Offset ); 88| 5| maxOffset = std::max( maxOffset, set.Offset + set.Size ); 89| 5| } 90| 2| Offset = minOffset; 91| 2| Size = maxOffset - minOffset; 92| 2|} _ZN5vvdec13ContextSetCfg9addCtxSetESt16initializer_listIS1_IhEE: 103| 82|{ 104| 82| const std::size_t startIdx = sm_InitTables[0].size(); 105| 82| const std::size_t numValues = ( *initSet2d.begin() ).size(); 106| 82| std::size_t setId = 0; 107| 82| for( auto& initSet: initSet2d ) ------------------ | Branch (107:21): [True: 328, False: 82] ------------------ 108| 328| { 109| 328| if( setId >= sm_InitTables.size() ) ------------------ | Branch (109:9): [True: 0, False: 328] ------------------ 110| 0| break; 111| | 112| 328| CHECK( initSet.size() != numValues, ------------------ | | 830| 328|#define CHECK( cond, msg ) { if UNLIKELY( cond ) { THROW_RECOVERABLE( msg << "\nERROR CONDITION: " << #cond ); } } | | ------------------ | | | | 793| 328|# define UNLIKELY( expr ) ( expr ) [[unlikely]] | | | | ------------------ | | | | | Branch (793:32): [True: 0, False: 328] | | | | ------------------ | | ------------------ | | #define CHECK( cond, msg ) { if UNLIKELY( cond ) { THROW_RECOVERABLE( msg << "\nERROR CONDITION: " << #cond ); } } | | ------------------ | | | | 820| 0|# define THROW_RECOVERABLE( msg ) throw( RecoverableException ( "\nERROR: " ) << FMT_ERROR_LOCATION << msg ) | | | | ------------------ | | | | | | 813| 0|#define FMT_ERROR_LOCATION "In function \"" << __PRETTY_FUNCTION__ << "\" in " << __FILE__ ":" << __LINE__ << ": " | | | | ------------------ | | ------------------ ------------------ 113| 328| "Number of init values do not match for all sets (" << initSet.size() << " != " << numValues << ")." ); 114| | 115| 328| for( auto& elemIter: initSet ) ------------------ | Branch (115:24): [True: 1.48k, False: 328] ------------------ 116| 1.48k| { 117| 1.48k| sm_InitTables[setId].push_back( elemIter ); 118| 1.48k| } 119| | 120| 328| setId++; 121| 328| } 122| 82| return CtxSet( (uint16_t)startIdx, (uint16_t)numValues ); 123| 82|} _ZN5vvdec6CtxSetC2Ett: 154| 82| CtxSet( uint16_t offset, uint16_t size ) : Offset( offset ), Size( size ) {} _ZN5vvdec9TCoeffOpsC2Ev: 408| 1|{ 409| 1| cpyResiClip[0] = cpyResiClipCore; // 1 410| 1| cpyResiClip[1] = cpyResiClipCore; // 2 411| 1| cpyResiClip[2] = cpyResiClipCore; // 4 412| 1| cpyResiClip[3] = cpyResiClipCore; // 8 413| 1| cpyResiClip[4] = cpyResiClipCore; // 16 414| 1| cpyResiClip[5] = cpyResiClipCore; // 32 415| 1| cpyResiClip[6] = cpyResiClipCore; // 64 416| 1| roundClip4 = clipCore; 417| 1| roundClip8 = clipCore; 418| 1| fastInvCore[0] = fastInvCore_< 4>; 419| 1| fastInvCore[1] = fastInvCore_< 8>; 420| 1| fastInvCore[2] = fastInvCore_<16>; 421| 1| fastInvCore[3] = fastInvCore_<32>; 422| 1| fastInvCore[4] = fastInvCore_<64>; 423| 1|} ThreadPool.cpp:_ZNK5vvdec3$_0clEv: 59| 1|const static auto VVDEC_BUSY_WAIT_TIME_MIN = [] { 60| 1| const char* env = getenv( "VVDEC_BUSY_WAIT_TIME_MIN" ); 61| 1| if( env ) ------------------ | Branch (61:7): [True: 0, False: 1] ------------------ 62| 0| return std::chrono::microseconds( int( atof( env ) * 1000 ) ); 63| 1| return std::chrono::microseconds( 1ms ); 64| 1|}(); ThreadPool.cpp:_ZNK5vvdec3$_1clEv: 67| 1|const static auto VVDEC_BUSY_WAIT_TIME_MAX = [] { 68| 1| const char* env = getenv( "VVDEC_BUSY_WAIT_TIME_MAX" ); 69| 1| if( env ) ------------------ | Branch (69:7): [True: 0, False: 1] ------------------ 70| 0| return atoi( env ) * 1ms; 71| 1| return 5ms; 72| 1|}(); _ZN5vvenc12PelBufferOpsC2Ev: 449| 1|{ 450| 1| isInitX86Done = false; 451| | 452| 1| addAvg = addAvgCore; 453| 1| reco = recoCore; 454| 1| copyClip = copyClipCore; 455| 1| roundGeo = roundGeoCore; 456| | 457| 1| addAvg4 = addAvgCore; 458| 1| addAvg8 = addAvgCore; 459| 1| addAvg16 = addAvgCore; 460| | 461| 1| sub4 = subsCore; 462| 1| sub8 = subsCore; 463| | 464| 1| wghtAvg4 = addWeightedAvgCore; 465| 1| wghtAvg8 = addWeightedAvgCore; 466| | 467| 1| copyClip4 = copyClipCore; 468| 1| copyClip8 = copyClipCore; 469| | 470| 1| reco4 = reconstructCore; 471| 1| reco8 = reconstructCore; 472| | 473| 1| linTf4 = linTfCore; 474| 1| linTf8 = linTfCore; 475| | 476| 1| copyBuffer = copyBufferCore; 477| | 478| 1| removeHighFreq8 = removeHighFreq; 479| 1| removeHighFreq4 = removeHighFreq; 480| | 481| 1| transpose4x4 = transposeNxNCore; 482| 1| transpose8x8 = transposeNxNCore; 483| 1| mipMatrixMul_4_4 = mipMatrixMulCore<4,4>; 484| 1| mipMatrixMul_8_4 = mipMatrixMulCore<8,4>; 485| 1| mipMatrixMul_8_8 = mipMatrixMulCore<8,8>; 486| 1| weightCiip = weightCiipCore; 487| 1| roundIntVector = nullptr; 488| | 489| 1| applyLut = applyLutCore; 490| | 491| 1| fillPtrMap = fillMapPtr_Core; 492| 1| AvgHighPassWithDownsampling = AvgHighPassWithDownsamplingCore; 493| 1| AvgHighPass = AvgHighPassCore; 494| 1| AvgHighPassWithDownsamplingDiff1st = AvgHighPassWithDownsamplingDiff1stCore; 495| 1| AvgHighPassWithDownsamplingDiff2nd = AvgHighPassWithDownsamplingDiff2ndCore; 496| 1| HDHighPass = HDHighPassCore; 497| 1| HDHighPass2 = HDHighPass2Core; 498| 1|} _ZN5vvenc9UnitScaleC2Eii: 127| 1| UnitScale( int sx, int sy ) : posx(sx), posy(sy), area(posx+posy) {} Rom.cpp:_ZN5vvencL5Clip3IiEET_S1_S1_S1_: 570| 75.2k|template constexpr static inline T Clip3 ( const T minVal, const T maxVal, const T a) { return std::min (std::max (minVal, a) , maxVal); } ///< general min/max clip _ZN5vvenc6CtxSetC2ESt16initializer_listIS0_E: 151| 2|{ 152| 2| uint16_t minOffset = std::numeric_limits::max(); 153| 2| uint16_t maxOffset = 0; 154| 7| for( auto iter = ctxSets.begin(); iter != ctxSets.end(); iter++ ) ------------------ | Branch (154:37): [True: 5, False: 2] ------------------ 155| 5| { 156| 5| minOffset = std::min( minOffset, (*iter).Offset ); 157| 5| maxOffset = std::max( maxOffset, (*iter).Offset+(*iter).Size ); 158| 5| } 159| 2| Offset = minOffset; 160| 2| Size = maxOffset - minOffset; 161| 2|} _ZN5vvenc13ContextSetCfg9addCtxSetESt16initializer_listIS1_IhEE: 176| 82|{ 177| 82| const std::size_t startIdx = sm_InitTables[0].size(); 178| 82| const std::size_t numValues = ( *initSet2d.begin() ).size(); 179| 82| std::size_t setId = 0; 180| 410| for( auto setIter = initSet2d.begin(); setIter != initSet2d.end() && setId < sm_InitTables.size(); setIter++, setId++ ) ------------------ | Branch (180:42): [True: 328, False: 82] | Branch (180:72): [True: 328, False: 0] ------------------ 181| 328| { 182| 328| const std::initializer_list& initSet = *setIter; 183| 328| std::vector& initTable = sm_InitTables[setId]; 184| 328| CHECK( initSet.size() != numValues, ------------------ | | 647| 328|#define CHECK(c,x) if(c){ THROW(x); } | | ------------------ | | | | 646| 0|#define THROW(x) throw( Exception( "ERROR: In function \"" ) << __FUNCTION__ << "\" in " << __FILE__ << ":" << __LINE__ << ": " << x ) | | ------------------ | | | Branch (647:32): [True: 0, False: 328] | | ------------------ ------------------ 185| 328| "Number of init values do not match for all sets (" << initSet.size() << " != " << numValues << ")." ); 186| 328| initTable.resize( startIdx + numValues ); 187| 328| std::size_t elemId = startIdx; 188| 1.80k| for( auto elemIter = ( *setIter ).begin(); elemIter != ( *setIter ).end(); elemIter++, elemId++ ) ------------------ | Branch (188:48): [True: 1.47k, False: 328] ------------------ 189| 1.47k| { 190| 1.47k| initTable[elemId] = *elemIter; 191| 1.47k| } 192| 328| } 193| 82| return CtxSet( (uint16_t)startIdx, (uint16_t)numValues ); 194| 82|} _ZN5vvenc6CtxSetC2Ett: 159| 82| CtxSet( uint16_t offset, uint16_t size ) : Offset( offset ), Size( size ) {} _ZN5vvenc6CtxSetC2ERKS0_: 160| 5| CtxSet( const CtxSet& ctxSet ) : Offset( ctxSet.Offset ), Size( ctxSet.Size ) {} _ZN5vvenc2MvC2Eii: 90| 18| Mv( int iHor, int iVer ) : hor( iHor ), ver( iVer ) {} _ZNK5vvenc10InitGeoRom15initGeoTemplateEv: 1305| 1|{ 1306| 1| int modeIdx = 0; 1307| 33| for (int angleIdx = 0; angleIdx < GEO_NUM_ANGLES; angleIdx++) ------------------ | Branch (1307:26): [True: 32, False: 1] ------------------ 1308| 32| { 1309| 160| for (int distanceIdx = 0; distanceIdx < GEO_NUM_DISTANCES; distanceIdx++) ------------------ | Branch (1309:31): [True: 128, False: 32] ------------------ 1310| 128| { 1311| 128| if ((distanceIdx == 0 && angleIdx >= 16) ------------------ | Branch (1311:12): [True: 32, False: 96] | Branch (1311:32): [True: 16, False: 16] ------------------ 1312| 112| || ((distanceIdx == 2 || distanceIdx == 0) && (g_angle2mask[angleIdx] == 0 || g_angle2mask[angleIdx] == 5)) ------------------ | Branch (1312:16): [True: 32, False: 80] | Branch (1312:36): [True: 16, False: 64] | Branch (1312:58): [True: 3, False: 45] | Branch (1312:89): [True: 3, False: 42] ------------------ 1313| 106| || g_angle2mask[angleIdx] == -1) ------------------ | Branch (1313:14): [True: 42, False: 64] ------------------ 1314| 64| continue; 1315| 64| g_GeoParams[modeIdx][0] = (int16_t) angleIdx; 1316| 64| g_GeoParams[modeIdx][1] = (int16_t) distanceIdx; 1317| 64| modeIdx++; 1318| 64| } 1319| 32| } 1320| 10| for (int angleIdx = 0; angleIdx < (GEO_NUM_ANGLES >> 2) + 1; angleIdx++) ------------------ | Branch (1320:26): [True: 9, False: 1] ------------------ 1321| 9| { 1322| 9| if (g_angle2mask[angleIdx] == -1) ------------------ | Branch (1322:9): [True: 3, False: 6] ------------------ 1323| 3| continue; 1324| | 1325| 6| int distanceX = angleIdx; 1326| 6| int distanceY = (distanceX + (GEO_NUM_ANGLES >> 2)) % GEO_NUM_ANGLES; 1327| 6| int16_t rho = (g_Dis[distanceX] * 2 * GEO_MAX_CU_SIZE) + (g_Dis[distanceY] * 2 * GEO_MAX_CU_SIZE); 1328| 6| static const int16_t maskOffset = (2 * GEO_MAX_CU_SIZE - GEO_WEIGHT_MASK_SIZE) >> 1; 1329| 6| int index = 0; 1330| 678| for (int y = 0; y < GEO_WEIGHT_MASK_SIZE; y++) ------------------ | Branch (1330:21): [True: 672, False: 6] ------------------ 1331| 672| { 1332| 672| int16_t lookUpY = (((y + maskOffset) << 1) + 1) * g_Dis[distanceY]; 1333| 75.9k| for (int x = 0; x < GEO_WEIGHT_MASK_SIZE; x++, index++) ------------------ | Branch (1333:23): [True: 75.2k, False: 672] ------------------ 1334| 75.2k| { 1335| 75.2k| int16_t sx_i = ((x + maskOffset) << 1) + 1; 1336| 75.2k| int16_t weightIdx = sx_i * g_Dis[distanceX] + lookUpY - rho; 1337| 75.2k| int weightLinearIdx = 32 + weightIdx; 1338| 75.2k| g_globalGeoWeights[g_angle2mask[angleIdx]][index] = Clip3(0, 8, (weightLinearIdx + 4) >> 3); 1339| 75.2k| g_globalGeoEncSADmask[g_angle2mask[angleIdx]][index] = weightIdx > 0 ? 1 : 0; ------------------ | Branch (1339:64): [True: 37.5k, False: 37.6k] ------------------ 1340| 75.2k| } 1341| 672| } 1342| 6| } 1343| | 1344| 5| for (int hIdx = 0; hIdx < GEO_NUM_CU_SIZE; hIdx++) ------------------ | Branch (1344:22): [True: 4, False: 1] ------------------ 1345| 4| { 1346| 4| int16_t height = 1 << (hIdx + GEO_MIN_CU_LOG2); 1347| 20| for (int wIdx = 0; wIdx < GEO_NUM_CU_SIZE; wIdx++) ------------------ | Branch (1347:24): [True: 16, False: 4] ------------------ 1348| 16| { 1349| 16| int16_t width = 1 << (wIdx + GEO_MIN_CU_LOG2); 1350| 1.04k| for (int splitDir = 0; splitDir < GEO_NUM_PARTITION_MODE; splitDir++) ------------------ | Branch (1350:30): [True: 1.02k, False: 16] ------------------ 1351| 1.02k| { 1352| 1.02k| int16_t angle = g_GeoParams[splitDir][0]; 1353| 1.02k| int16_t distance = g_GeoParams[splitDir][1]; 1354| 1.02k| int16_t offsetX = (GEO_WEIGHT_MASK_SIZE - width) >> 1; 1355| 1.02k| int16_t offsetY = (GEO_WEIGHT_MASK_SIZE - height) >> 1; 1356| 1.02k| if (distance > 0) ------------------ | Branch (1356:13): [True: 896, False: 128] ------------------ 1357| 896| { 1358| 896| if (angle % 16 == 8 || (angle % 16 != 0 && height >= width)) ------------------ | Branch (1358:15): [True: 64, False: 832] | Branch (1358:35): [True: 768, False: 64] | Branch (1358:54): [True: 480, False: 288] ------------------ 1359| 544| { 1360| 544| offsetY += angle < 16 ? ((distance * (int32_t) height) >> 3) : -((distance * (int32_t) height) >> 3); ------------------ | Branch (1360:24): [True: 272, False: 272] ------------------ 1361| 544| } 1362| 352| else 1363| 352| { 1364| 352| offsetX += angle < 16 ? ((distance * (int32_t) width) >> 3) : -((distance * (int32_t) width) >> 3); ------------------ | Branch (1364:24): [True: 176, False: 176] ------------------ 1365| 352| } 1366| 896| } 1367| 1.02k| g_weightOffset[hIdx][wIdx][splitDir][0] = offsetX; 1368| 1.02k| g_weightOffset[hIdx][wIdx][splitDir][1] = offsetY; 1369| 1.02k| } 1370| 16| } 1371| 4| } 1372| 1|} _ZN5vvenc10InitGeoRomC2Ev: 91| 1| InitGeoRom() { initGeoTemplate(); } _ZN5vvenc9TCoeffOpsC2Ev: 2004| 1|{ 2005| 1| cpyResi4 = cpyResiCore; 2006| 1| cpyResi8 = cpyResiCore; 2007| 1| cpyCoeff4 = cpyCoeffCore; 2008| 1| cpyCoeff8 = cpyCoeffCore; 2009| 1| roundClip4 = clipCore; 2010| 1| roundClip8 = clipCore; 2011| 1| fastInvCore[0] = fastInvCore_< 4>; 2012| 1| fastInvCore[1] = fastInvCore_< 8>; 2013| 1| fastInvCore[2] = fastInvCore_<16>; 2014| 1| fastInvCore[3] = fastInvCore_<32>; 2015| 1| fastInvCore[4] = fastInvCore_<64>; 2016| 1| fastFwdCore_1D[0] = fastFwdCore< 4>; 2017| 1| fastFwdCore_1D[1] = fastFwdCore< 8>; 2018| 1| fastFwdCore_1D[2] = fastFwdCore<16>; 2019| 1| fastFwdCore_1D[3] = fastFwdCore<32>; 2020| 1| fastFwdCore_1D[4] = fastFwdCore<64>; 2021| 1| fastFwdCore_2D[0] = fastFwdCore< 4>; 2022| 1| fastFwdCore_2D[1] = fastFwdCore< 8>; 2023| 1| fastFwdCore_2D[2] = fastFwdCore<16>; 2024| 1| fastFwdCore_2D[3] = fastFwdCore<32>; 2025| 1| fastFwdCore_2D[4] = fastFwdCore<64>; 2026| 1|} vvencimpl.cpp:_ZNK5vvenc3$_0clEv: 85| 1|const static auto BUSY_WAIT_TIME = [] { 86| 1| const char *env = getenv( "BUSY_WAIT_TIME" ); 87| 1| if( env ) ------------------ | Branch (87:7): [True: 0, False: 1] ------------------ 88| 0| return std::chrono::milliseconds( atoi( env ) ); 89| 1| return std::chrono::milliseconds( 1 ); 90| 1|}(); EncLib.cpp:_ZNK5vvenc3$_0clEv: 85| 1|const static auto BUSY_WAIT_TIME = [] { 86| 1| const char *env = getenv( "BUSY_WAIT_TIME" ); 87| 1| if( env ) ------------------ | Branch (87:7): [True: 0, False: 1] ------------------ 88| 0| return std::chrono::milliseconds( atoi( env ) ); 89| 1| return std::chrono::milliseconds( 1 ); 90| 1|}(); NoMallocThreadPool.cpp:_ZNK5vvenc3$_0clEv: 85| 1|const static auto BUSY_WAIT_TIME = [] { 86| 1| const char *env = getenv( "BUSY_WAIT_TIME" ); 87| 1| if( env ) ------------------ | Branch (87:7): [True: 0, False: 1] ------------------ 88| 0| return std::chrono::milliseconds( atoi( env ) ); 89| 1| return std::chrono::milliseconds( 1 ); 90| 1|}(); MCTF.cpp:_ZNK5vvenc3$_0clEv: 85| 1|const static auto BUSY_WAIT_TIME = [] { 86| 1| const char *env = getenv( "BUSY_WAIT_TIME" ); 87| 1| if( env ) ------------------ | Branch (87:7): [True: 0, False: 1] ------------------ 88| 0| return std::chrono::milliseconds( atoi( env ) ); 89| 1| return std::chrono::milliseconds( 1 ); 90| 1|}(); EncGOP.cpp:_ZNK5vvenc3$_0clEv: 85| 1|const static auto BUSY_WAIT_TIME = [] { 86| 1| const char *env = getenv( "BUSY_WAIT_TIME" ); 87| 1| if( env ) ------------------ | Branch (87:7): [True: 0, False: 1] ------------------ 88| 0| return std::chrono::milliseconds( atoi( env ) ); 89| 1| return std::chrono::milliseconds( 1 ); 90| 1|}(); EncPicture.cpp:_ZNK5vvenc3$_0clEv: 85| 1|const static auto BUSY_WAIT_TIME = [] { 86| 1| const char *env = getenv( "BUSY_WAIT_TIME" ); 87| 1| if( env ) ------------------ | Branch (87:7): [True: 0, False: 1] ------------------ 88| 0| return std::chrono::milliseconds( atoi( env ) ); 89| 1| return std::chrono::milliseconds( 1 ); 90| 1|}(); EncSlice.cpp:_ZNK5vvenc3$_0clEv: 85| 1|const static auto BUSY_WAIT_TIME = [] { 86| 1| const char *env = getenv( "BUSY_WAIT_TIME" ); 87| 1| if( env ) ------------------ | Branch (87:7): [True: 0, False: 1] ------------------ 88| 0| return std::chrono::milliseconds( atoi( env ) ); 89| 1| return std::chrono::milliseconds( 1 ); 90| 1|}(); EncAdaptiveLoopFilter.cpp:_ZNK5vvenc3$_0clEv: 85| 1|const static auto BUSY_WAIT_TIME = [] { 86| 1| const char *env = getenv( "BUSY_WAIT_TIME" ); 87| 1| if( env ) ------------------ | Branch (87:7): [True: 0, False: 1] ------------------ 88| 0| return std::chrono::milliseconds( atoi( env ) ); 89| 1| return std::chrono::milliseconds( 1 ); 90| 1|}(); EncCu.cpp:_ZNK5vvenc3$_0clEv: 85| 1|const static auto BUSY_WAIT_TIME = [] { 86| 1| const char *env = getenv( "BUSY_WAIT_TIME" ); 87| 1| if( env ) ------------------ | Branch (87:7): [True: 0, False: 1] ------------------ 88| 0| return std::chrono::milliseconds( atoi( env ) ); 89| 1| return std::chrono::milliseconds( 1 ); 90| 1|}(); IntraSearch.cpp:_ZNK5vvenc3$_0clEv: 85| 1|const static auto BUSY_WAIT_TIME = [] { 86| 1| const char *env = getenv( "BUSY_WAIT_TIME" ); 87| 1| if( env ) ------------------ | Branch (87:7): [True: 0, False: 1] ------------------ 88| 0| return std::chrono::milliseconds( atoi( env ) ); 89| 1| return std::chrono::milliseconds( 1 ); 90| 1|}(); _ZN8apputils15program_options13ErrorReporterC2Ev: 80| 1| ErrorReporter() : is_errored(0) {} _ZN4x2652MVC2Eii: 49| 49| MV(int32_t _x, int32_t _y) : x(_x), y(_y) {}