Changeset 1200 in 3DVCSoftware for branches/HTM-14.1-update-dev0/source/App/TAppEncoder/TAppEncCfg.cpp
- Timestamp:
- 4 May 2015, 18:38:08 (9 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/HTM-14.1-update-dev0/source/App/TAppEncoder/TAppEncCfg.cpp
r1196 r1200 2 2 * License, included below. This software may be subject to other third party 3 3 * and contributor rights, including patent rights, and no such rights are 4 * granted under this license. 4 * granted under this license. 5 5 * 6 * Copyright (c) 2010-2015, ITU/ISO/IEC6 * Copyright (c) 2010-2015, ITU/ISO/IEC 7 7 * All rights reserved. 8 8 * … … 36 36 */ 37 37 38 #include <stdio.h> 38 39 #include <stdlib.h> 39 40 #include <cassert> 40 41 #include <cstring> 41 42 #include <string> 43 #include <limits> 42 44 #include "TLibCommon/TComRom.h" 43 45 #include "TAppEncCfg.h" 44 45 static istream& operator>>(istream &, Level::Name &);46 static istream& operator>>(istream &, Level::Tier &);47 static istream& operator>>(istream &, Profile::Name &);48 49 46 #include "TAppCommon/program_options_lite.h" 50 47 #include "TLibEncoder/TEncRateCtrl.h" … … 53 50 #endif 54 51 52 #define MACRO_TO_STRING_HELPER(val) #val 53 #define MACRO_TO_STRING(val) MACRO_TO_STRING_HELPER(val) 54 55 55 using namespace std; 56 56 namespace po = df::program_options_lite; 57 58 59 60 enum ExtendedProfileName // this is used for determining profile strings, where multiple profiles map to a single profile idc with various constraint flag combinations 61 { 62 NONE = 0, 63 MAIN = 1, 64 MAIN10 = 2, 65 MAINSTILLPICTURE = 3, 66 MAINREXT = 4, 67 HIGHTHROUGHPUTREXT = 5, // Placeholder profile for development 68 // The following are RExt profiles, which would map to the MAINREXT profile idc. 69 // The enumeration indicates the bit-depth constraint in the bottom 2 digits 70 // the chroma format in the next digit 71 // the intra constraint in the next digit 72 // If it is a RExt still picture, there is a '1' for the top digit. 73 #if NH_MV 74 MULTIVIEWMAIN = 6, 75 #if NH_3D 76 MAIN3D = 8, 77 #endif 78 #endif 79 MONOCHROME_8 = 1008, 80 MONOCHROME_12 = 1012, 81 MONOCHROME_16 = 1016, 82 MAIN_12 = 1112, 83 MAIN_422_10 = 1210, 84 MAIN_422_12 = 1212, 85 MAIN_444 = 1308, 86 MAIN_444_10 = 1310, 87 MAIN_444_12 = 1312, 88 MAIN_444_16 = 1316, // non-standard profile definition, used for development purposes 89 MAIN_INTRA = 2108, 90 MAIN_10_INTRA = 2110, 91 MAIN_12_INTRA = 2112, 92 MAIN_422_10_INTRA = 2210, 93 MAIN_422_12_INTRA = 2212, 94 MAIN_444_INTRA = 2308, 95 MAIN_444_10_INTRA = 2310, 96 MAIN_444_12_INTRA = 2312, 97 MAIN_444_16_INTRA = 2316, 98 MAIN_444_STILL_PICTURE = 11308, 99 MAIN_444_16_STILL_PICTURE = 12316 100 }; 101 57 102 58 103 //! \ingroup TAppEncoder … … 64 109 65 110 TAppEncCfg::TAppEncCfg() 66 #if H_MV111 #if NH_MV 67 112 : m_pchBitstreamFile() 68 113 #else … … 71 116 , m_pchReconFile() 72 117 #endif 118 , m_inputColourSpaceConvert(IPCOLOURSPACE_UNCHANGED) 119 , m_snrInternalColourSpace(false) 120 , m_outputInternalColourSpace(false) 73 121 , m_pchdQPFile() 74 122 , m_scalingListFile() 75 123 { 76 #if ! H_MV124 #if !NH_MV 77 125 m_aidQP = NULL; 78 126 #endif … … 88 136 TAppEncCfg::~TAppEncCfg() 89 137 { 90 #if H_MV138 #if NH_MV 91 139 for( Int layer = 0; layer < m_aidQP.size(); layer++ ) 92 140 { … … 123 171 m_targetPivotValue = NULL; 124 172 } 125 #if ! H_MV173 #if !NH_MV 126 174 free(m_pchInputFile); 127 175 #endif 128 176 free(m_pchBitstreamFile); 129 #if H_MV177 #if NH_MV 130 178 for(Int i = 0; i< m_pchReconFileList.size(); i++ ) 131 179 { … … 138 186 free(m_pchdQPFile); 139 187 free(m_scalingListFile); 140 #if H_MV188 #if NH_MV 141 189 for( Int i = 0; i < m_GOPListMvc.size(); i++ ) 142 190 { … … 148 196 } 149 197 #endif 150 #if H_3D151 #if H_3D_VSO198 #if NH_3D 199 #if NH_3D_VSO 152 200 if ( m_pchVSOConfig != NULL) 201 { 153 202 free ( m_pchVSOConfig ); 203 } 154 204 #endif 155 205 if ( m_pchCameraParameterFile != NULL ) 206 { 156 207 free ( m_pchCameraParameterFile ); 208 } 157 209 158 210 if ( m_pchBaseViewCameraNumbers != NULL ) 211 { 159 212 free ( m_pchBaseViewCameraNumbers ); 213 } 160 214 #endif 161 215 } … … 185 239 } 186 240 in>>entry.m_interRPSPrediction; 187 #if AUTO_INTER_RPS188 241 if (entry.m_interRPSPrediction==1) 189 242 { … … 199 252 in>>entry.m_deltaRPS; 200 253 } 201 #else 202 if (entry.m_interRPSPrediction) 203 { 204 in>>entry.m_deltaRPS; 205 in>>entry.m_numRefIdc; 206 for ( Int i = 0; i < entry.m_numRefIdc; i++ ) 207 { 208 in>>entry.m_refIdc[i]; 209 } 210 } 211 #endif 212 #if H_MV 254 #if NH_MV 213 255 in>>entry.m_numActiveRefLayerPics; 214 256 for( Int i = 0; i < entry.m_numActiveRefLayerPics; i++ ) … … 225 267 } 226 268 #endif 227 #if H_3D269 #if NH_3D 228 270 in>>entry.m_interCompPredFlag; 229 271 #endif 272 230 273 return in; 231 274 } 232 275 233 static const struct MapStrToProfile { 276 Bool confirmPara(Bool bflag, const Char* message); 277 278 static inline ChromaFormat numberToChromaFormat(const Int val) 279 { 280 switch (val) 281 { 282 case 400: return CHROMA_400; break; 283 case 420: return CHROMA_420; break; 284 case 422: return CHROMA_422; break; 285 case 444: return CHROMA_444; break; 286 default: return NUM_CHROMA_FORMAT; 287 } 288 } 289 290 static const struct MapStrToProfile 291 { 234 292 const Char* str; 235 293 Profile::Name value; 236 } strToProfile[] = { 237 {"none", Profile::NONE}, 238 {"main", Profile::MAIN}, 239 {"main10", Profile::MAIN10}, 240 {"main-still-picture", Profile::MAINSTILLPICTURE}, 241 #if H_MV 242 {"multiview-main", Profile::MULTIVIEWMAIN}, 243 #if H_3D 244 {"3d-main" , Profile::MAIN3D}, 245 #endif 246 247 #endif 294 } 295 strToProfile[] = 296 { 297 {"none", Profile::NONE }, 298 {"main", Profile::MAIN }, 299 {"main10", Profile::MAIN10 }, 300 {"main-still-picture", Profile::MAINSTILLPICTURE }, 301 {"main-RExt", Profile::MAINREXT }, 302 {"high-throughput-RExt", Profile::HIGHTHROUGHPUTREXT } 303 #if NH_MV 304 ,{"multiview-main" , Profile::MULTIVIEWMAIN }, 305 #if NH_3D 306 {"3d-main" , Profile::MAIN3D } 307 #endif 308 #endif 309 248 310 }; 249 311 250 static const struct MapStrToTier { 312 static const struct MapStrToExtendedProfile 313 { 314 const Char* str; 315 ExtendedProfileName value; 316 } 317 strToExtendedProfile[] = 318 { 319 {"none", NONE }, 320 {"main", MAIN }, 321 {"main10", MAIN10 }, 322 {"main_still_picture", MAINSTILLPICTURE }, 323 {"main-still-picture", MAINSTILLPICTURE }, 324 {"main_RExt", MAINREXT }, 325 {"main-RExt", MAINREXT }, 326 {"main_rext", MAINREXT }, 327 {"main-rext", MAINREXT }, 328 {"high_throughput_RExt", HIGHTHROUGHPUTREXT }, 329 {"high-throughput-RExt", HIGHTHROUGHPUTREXT }, 330 {"high_throughput_rext", HIGHTHROUGHPUTREXT }, 331 {"high-throughput-rext", HIGHTHROUGHPUTREXT }, 332 #if NH_MV 333 {"multiview-main" , MULTIVIEWMAIN }, 334 #if NH_3D 335 {"3d-main" , MAIN3D }, 336 #endif 337 #endif 338 {"monochrome", MONOCHROME_8 }, 339 {"monochrome12", MONOCHROME_12 }, 340 {"monochrome16", MONOCHROME_16 }, 341 {"main12", MAIN_12 }, 342 {"main_422_10", MAIN_422_10 }, 343 {"main_422_12", MAIN_422_12 }, 344 {"main_444", MAIN_444 }, 345 {"main_444_10", MAIN_444_10 }, 346 {"main_444_12", MAIN_444_12 }, 347 {"main_444_16", MAIN_444_16 }, 348 {"main_intra", MAIN_INTRA }, 349 {"main_10_intra", MAIN_10_INTRA }, 350 {"main_12_intra", MAIN_12_INTRA }, 351 {"main_422_10_intra", MAIN_422_10_INTRA}, 352 {"main_422_12_intra", MAIN_422_12_INTRA}, 353 {"main_444_intra", MAIN_444_INTRA }, 354 {"main_444_still_picture", MAIN_444_STILL_PICTURE }, 355 {"main_444_10_intra", MAIN_444_10_INTRA}, 356 {"main_444_12_intra", MAIN_444_12_INTRA}, 357 {"main_444_16_intra", MAIN_444_16_INTRA}, 358 {"main_444_16_still_picture", MAIN_444_16_STILL_PICTURE } 359 }; 360 361 static const ExtendedProfileName validRExtProfileNames[2/* intraConstraintFlag*/][4/* bit depth constraint 8=0, 10=1, 12=2, 16=3*/][4/*chroma format*/]= 362 { 363 { 364 { MONOCHROME_8, NONE, NONE, MAIN_444 }, // 8-bit inter for 400, 420, 422 and 444 365 { NONE, NONE, MAIN_422_10, MAIN_444_10 }, // 10-bit inter for 400, 420, 422 and 444 366 { MONOCHROME_12, MAIN_12, MAIN_422_12, MAIN_444_12 }, // 12-bit inter for 400, 420, 422 and 444 367 { MONOCHROME_16, NONE, NONE, MAIN_444_16 } // 16-bit inter for 400, 420, 422 and 444 (the latter is non standard used for development) 368 }, 369 { 370 { NONE, MAIN_INTRA, NONE, MAIN_444_INTRA }, // 8-bit intra for 400, 420, 422 and 444 371 { NONE, MAIN_10_INTRA, MAIN_422_10_INTRA, MAIN_444_10_INTRA }, // 10-bit intra for 400, 420, 422 and 444 372 { NONE, MAIN_12_INTRA, MAIN_422_12_INTRA, MAIN_444_12_INTRA }, // 12-bit intra for 400, 420, 422 and 444 373 { NONE, NONE, NONE, MAIN_444_16_INTRA } // 16-bit intra for 400, 420, 422 and 444 374 } 375 }; 376 377 static const struct MapStrToTier 378 { 251 379 const Char* str; 252 380 Level::Tier value; 253 } strToTier[] = { 381 } 382 strToTier[] = 383 { 254 384 {"main", Level::MAIN}, 255 385 {"high", Level::HIGH}, 256 386 }; 257 387 258 static const struct MapStrToLevel { 388 static const struct MapStrToLevel 389 { 259 390 const Char* str; 260 391 Level::Name value; 261 } strToLevel[] = { 392 } 393 strToLevel[] = 394 { 262 395 {"none",Level::NONE}, 263 396 {"1", Level::LEVEL1}, … … 274 407 {"6.1", Level::LEVEL6_1}, 275 408 {"6.2", Level::LEVEL6_2}, 409 {"8.5", Level::LEVEL8_5}, 276 410 }; 277 411 412 static const struct MapStrToCostMode 413 { 414 const Char* str; 415 CostMode value; 416 } 417 strToCostMode[] = 418 { 419 {"lossy", COST_STANDARD_LOSSY}, 420 {"sequence_level_lossless", COST_SEQUENCE_LEVEL_LOSSLESS}, 421 {"lossless", COST_LOSSLESS_CODING}, 422 {"mixed_lossless_lossy", COST_MIXED_LOSSLESS_LOSSY_CODING} 423 }; 424 425 static const struct MapStrToScalingListMode 426 { 427 const Char* str; 428 ScalingListMode value; 429 } 430 strToScalingListMode[] = 431 { 432 {"0", SCALING_LIST_OFF}, 433 {"1", SCALING_LIST_DEFAULT}, 434 {"2", SCALING_LIST_FILE_READ}, 435 {"off", SCALING_LIST_OFF}, 436 {"default", SCALING_LIST_DEFAULT}, 437 {"file", SCALING_LIST_FILE_READ} 438 }; 439 278 440 template<typename T, typename P> 279 static istream& readStrToEnum(P map[], unsigned long mapLen, istream &in, T &val) 441 static std::string enumToString(P map[], UInt mapLen, const T val) 442 { 443 for (UInt i = 0; i < mapLen; i++) 444 { 445 if (val == map[i].value) 446 { 447 return map[i].str; 448 } 449 } 450 return std::string(); 451 } 452 453 template<typename T, typename P> 454 static istream& readStrToEnum(P map[], UInt mapLen, istream &in, T &val) 280 455 { 281 456 string str; 282 457 in >> str; 283 458 284 for ( Int i = 0; i < mapLen; i++)459 for (UInt i = 0; i < mapLen; i++) 285 460 { 286 461 if (str == map[i].str) … … 296 471 } 297 472 298 static istream& operator>>(istream &in, Profile::Name &profile) 473 //inline to prevent compiler warnings for "unused static function" 474 475 static inline istream& operator >> (istream &in, ExtendedProfileName &profile) 299 476 { 300 return readStrToEnum(strTo Profile, sizeof(strToProfile)/sizeof(*strToProfile), in, profile);477 return readStrToEnum(strToExtendedProfile, sizeof(strToExtendedProfile)/sizeof(*strToExtendedProfile), in, profile); 301 478 } 302 479 303 static istream& operator>>(istream &in, Level::Tier &tier) 480 namespace Level 304 481 { 305 return readStrToEnum(strToTier, sizeof(strToTier)/sizeof(*strToTier), in, tier); 482 static inline istream& operator >> (istream &in, Tier &tier) 483 { 484 return readStrToEnum(strToTier, sizeof(strToTier)/sizeof(*strToTier), in, tier); 485 } 486 487 static inline istream& operator >> (istream &in, Name &level) 488 { 489 return readStrToEnum(strToLevel, sizeof(strToLevel)/sizeof(*strToLevel), in, level); 490 } 306 491 } 307 492 308 static i stream& operator>>(istream &in, Level::Name &level)493 static inline istream& operator >> (istream &in, CostMode &mode) 309 494 { 310 return readStrToEnum(strTo Level, sizeof(strToLevel)/sizeof(*strToLevel), in, level);495 return readStrToEnum(strToCostMode, sizeof(strToCostMode)/sizeof(*strToCostMode), in, mode); 311 496 } 312 497 498 static inline istream& operator >> (istream &in, ScalingListMode &mode) 499 { 500 return readStrToEnum(strToScalingListMode, sizeof(strToScalingListMode)/sizeof(*strToScalingListMode), in, mode); 501 } 502 503 template <class T> 504 struct SMultiValueInput 505 { 506 const T minValIncl; 507 const T maxValIncl; // Use 0 for unlimited 508 const std::size_t minNumValuesIncl; 509 const std::size_t maxNumValuesIncl; // Use 0 for unlimited 510 std::vector<T> values; 511 SMultiValueInput() : minValIncl(0), maxValIncl(0), minNumValuesIncl(0), maxNumValuesIncl(0), values() { } 512 SMultiValueInput(std::vector<T> &defaults) : minValIncl(0), maxValIncl(0), minNumValuesIncl(0), maxNumValuesIncl(0), values(defaults) { } 513 SMultiValueInput(const T &minValue, const T &maxValue, std::size_t minNumberValues=0, std::size_t maxNumberValues=0) 514 : minValIncl(minValue), maxValIncl(maxValue), minNumValuesIncl(minNumberValues), maxNumValuesIncl(maxNumberValues), values() { } 515 SMultiValueInput(const T &minValue, const T &maxValue, std::size_t minNumberValues, std::size_t maxNumberValues, const T* defValues, const UInt numDefValues) 516 : minValIncl(minValue), maxValIncl(maxValue), minNumValuesIncl(minNumberValues), maxNumValuesIncl(maxNumberValues), values(defValues, defValues+numDefValues) { } 517 SMultiValueInput<T> &operator=(const std::vector<T> &userValues) { values=userValues; return *this; } 518 SMultiValueInput<T> &operator=(const SMultiValueInput<T> &userValues) { values=userValues.values; return *this; } 519 }; 520 521 static inline istream& operator >> (istream &in, SMultiValueInput<UInt> &values) 522 { 523 values.values.clear(); 524 string str; 525 while (!in.eof()) 526 { 527 string tmp; in >> tmp; str+=" " + tmp; 528 } 529 if (!str.empty()) 530 { 531 const Char *pStr=str.c_str(); 532 // soak up any whitespace 533 for(;isspace(*pStr);pStr++); 534 535 while (*pStr != 0) 536 { 537 Char *eptr; 538 UInt val=strtoul(pStr, &eptr, 0); 539 if (*eptr!=0 && !isspace(*eptr) && *eptr!=',') 540 { 541 in.setstate(ios::failbit); 542 break; 543 } 544 if (val<values.minValIncl || val>values.maxValIncl) 545 { 546 in.setstate(ios::failbit); 547 break; 548 } 549 550 if (values.maxNumValuesIncl != 0 && values.values.size() >= values.maxNumValuesIncl) 551 { 552 in.setstate(ios::failbit); 553 break; 554 } 555 values.values.push_back(val); 556 // soak up any whitespace and up to 1 comma. 557 pStr=eptr; 558 for(;isspace(*pStr);pStr++); 559 if (*pStr == ',') 560 { 561 pStr++; 562 } 563 for(;isspace(*pStr);pStr++); 564 } 565 } 566 if (values.values.size() < values.minNumValuesIncl) 567 { 568 in.setstate(ios::failbit); 569 } 570 return in; 571 } 572 573 static inline istream& operator >> (istream &in, SMultiValueInput<Int> &values) 574 { 575 values.values.clear(); 576 string str; 577 while (!in.eof()) 578 { 579 string tmp; in >> tmp; str+=" " + tmp; 580 } 581 if (!str.empty()) 582 { 583 const Char *pStr=str.c_str(); 584 // soak up any whitespace 585 for(;isspace(*pStr);pStr++); 586 587 while (*pStr != 0) 588 { 589 Char *eptr; 590 Int val=strtol(pStr, &eptr, 0); 591 if (*eptr!=0 && !isspace(*eptr) && *eptr!=',') 592 { 593 in.setstate(ios::failbit); 594 break; 595 } 596 if (val<values.minValIncl || val>values.maxValIncl) 597 { 598 in.setstate(ios::failbit); 599 break; 600 } 601 602 if (values.maxNumValuesIncl != 0 && values.values.size() >= values.maxNumValuesIncl) 603 { 604 in.setstate(ios::failbit); 605 break; 606 } 607 values.values.push_back(val); 608 // soak up any whitespace and up to 1 comma. 609 pStr=eptr; 610 for(;isspace(*pStr);pStr++); 611 if (*pStr == ',') 612 { 613 pStr++; 614 } 615 for(;isspace(*pStr);pStr++); 616 } 617 } 618 if (values.values.size() < values.minNumValuesIncl) 619 { 620 in.setstate(ios::failbit); 621 } 622 return in; 623 } 624 625 static inline istream& operator >> (istream &in, SMultiValueInput<Bool> &values) 626 { 627 values.values.clear(); 628 string str; 629 while (!in.eof()) 630 { 631 string tmp; in >> tmp; str+=" " + tmp; 632 } 633 if (!str.empty()) 634 { 635 const Char *pStr=str.c_str(); 636 // soak up any whitespace 637 for(;isspace(*pStr);pStr++); 638 639 while (*pStr != 0) 640 { 641 Char *eptr; 642 Int val=strtol(pStr, &eptr, 0); 643 if (*eptr!=0 && !isspace(*eptr) && *eptr!=',') 644 { 645 in.setstate(ios::failbit); 646 break; 647 } 648 if (val<Int(values.minValIncl) || val>Int(values.maxValIncl)) 649 { 650 in.setstate(ios::failbit); 651 break; 652 } 653 654 if (values.maxNumValuesIncl != 0 && values.values.size() >= values.maxNumValuesIncl) 655 { 656 in.setstate(ios::failbit); 657 break; 658 } 659 values.values.push_back(val!=0); 660 // soak up any whitespace and up to 1 comma. 661 pStr=eptr; 662 for(;isspace(*pStr);pStr++); 663 if (*pStr == ',') 664 { 665 pStr++; 666 } 667 for(;isspace(*pStr);pStr++); 668 } 669 } 670 if (values.values.size() < values.minNumValuesIncl) 671 { 672 in.setstate(ios::failbit); 673 } 674 return in; 675 } 676 677 static Void 678 automaticallySelectRExtProfile(const Bool bUsingGeneralRExtTools, 679 const Bool bUsingChromaQPAdjustment, 680 const Bool bUsingExtendedPrecision, 681 const Bool bIntraConstraintFlag, 682 UInt &bitDepthConstraint, 683 ChromaFormat &chromaFormatConstraint, 684 const Int maxBitDepth, 685 const ChromaFormat chromaFormat) 686 { 687 // Try to choose profile, according to table in Q1013. 688 UInt trialBitDepthConstraint=maxBitDepth; 689 if (trialBitDepthConstraint<8) 690 { 691 trialBitDepthConstraint=8; 692 } 693 else if (trialBitDepthConstraint==9 || trialBitDepthConstraint==11) 694 { 695 trialBitDepthConstraint++; 696 } 697 else if (trialBitDepthConstraint>12) 698 { 699 trialBitDepthConstraint=16; 700 } 701 702 // both format and bit depth constraints are unspecified 703 if (bUsingExtendedPrecision || trialBitDepthConstraint==16) 704 { 705 bitDepthConstraint = 16; 706 chromaFormatConstraint = (!bIntraConstraintFlag && chromaFormat==CHROMA_400) ? CHROMA_400 : CHROMA_444; 707 } 708 else if (bUsingGeneralRExtTools) 709 { 710 if (chromaFormat == CHROMA_400 && !bIntraConstraintFlag) 711 { 712 bitDepthConstraint = 16; 713 chromaFormatConstraint = CHROMA_400; 714 } 715 else 716 { 717 bitDepthConstraint = trialBitDepthConstraint; 718 chromaFormatConstraint = CHROMA_444; 719 } 720 } 721 else if (chromaFormat == CHROMA_400) 722 { 723 if (bIntraConstraintFlag) 724 { 725 chromaFormatConstraint = CHROMA_420; // there is no intra 4:0:0 profile. 726 bitDepthConstraint = trialBitDepthConstraint; 727 } 728 else 729 { 730 chromaFormatConstraint = CHROMA_400; 731 bitDepthConstraint = trialBitDepthConstraint == 8 ? 8 : 12; 732 } 733 } 734 else 735 { 736 bitDepthConstraint = trialBitDepthConstraint; 737 chromaFormatConstraint = chromaFormat; 738 if (bUsingChromaQPAdjustment && chromaFormat == CHROMA_420) 739 { 740 chromaFormatConstraint = CHROMA_422; // 4:2:0 cannot use the chroma qp tool. 741 } 742 if (chromaFormatConstraint == CHROMA_422 && bitDepthConstraint == 8) 743 { 744 bitDepthConstraint = 10; // there is no 8-bit 4:2:2 profile. 745 } 746 if (chromaFormatConstraint == CHROMA_420 && !bIntraConstraintFlag) 747 { 748 bitDepthConstraint = 12; // there is no 8 or 10-bit 4:2:0 inter RExt profile. 749 } 750 } 751 } 313 752 // ==================================================================================================================== 314 753 // Public member functions … … 322 761 { 323 762 Bool do_help = false; 324 325 #if ! H_MV763 764 #if !NH_MV 326 765 string cfg_InputFile; 327 766 #endif 328 767 string cfg_BitstreamFile; 329 #if ! H_MV768 #if !NH_MV 330 769 string cfg_ReconFile; 331 770 #endif 332 #if H_MV771 #if NH_MV 333 772 vector<Int> cfg_dimensionLength; 334 773 string cfg_profiles; 335 774 string cfg_levels; 336 775 string cfg_tiers; 337 #if H_3D776 #if NH_3D 338 777 cfg_dimensionLength.push_back( 2 ); // depth 339 778 cfg_dimensionLength.push_back( 32 ); // texture … … 343 782 #endif 344 783 string cfg_dQPFile; 345 string cfgColumnWidth;346 string cfgRowHeight;347 784 string cfg_ScalingListFile; 348 string cfg_startOfCodedInterval; 349 string cfg_codedPivotValue; 350 string cfg_targetPivotValue; 785 786 Int tmpChromaFormat; 787 Int tmpInputChromaFormat; 788 Int tmpConstraintChromaFormat; 789 string inputColourSpaceConvert; 790 #if NH_MV 791 std::vector<ExtendedProfileName> extendedProfiles; 792 #else 793 ExtendedProfileName extendedProfile; 794 #endif 795 Int saoOffsetBitShift[MAX_NUM_CHANNEL_TYPE]; 796 797 // Multi-value input fields: // minval, maxval (incl), min_entries, max_entries (incl) [, default values, number of default values] 798 SMultiValueInput<UInt> cfg_ColumnWidth (0, std::numeric_limits<UInt>::max(), 0, std::numeric_limits<UInt>::max()); 799 SMultiValueInput<UInt> cfg_RowHeight (0, std::numeric_limits<UInt>::max(), 0, std::numeric_limits<UInt>::max()); 800 SMultiValueInput<Int> cfg_startOfCodedInterval (std::numeric_limits<Int>::min(), std::numeric_limits<Int>::max(), 0, 1<<16); 801 SMultiValueInput<Int> cfg_codedPivotValue (std::numeric_limits<Int>::min(), std::numeric_limits<Int>::max(), 0, 1<<16); 802 SMultiValueInput<Int> cfg_targetPivotValue (std::numeric_limits<Int>::min(), std::numeric_limits<Int>::max(), 0, 1<<16); 803 804 const UInt defaultInputKneeCodes[3] = { 600, 800, 900 }; 805 const UInt defaultOutputKneeCodes[3] = { 100, 250, 450 }; 806 SMultiValueInput<UInt> cfg_kneeSEIInputKneePointValue (1, 999, 0, 999, defaultInputKneeCodes, sizeof(defaultInputKneeCodes )/sizeof(UInt)); 807 SMultiValueInput<UInt> cfg_kneeSEIOutputKneePointValue (0, 1000, 0, 999, defaultOutputKneeCodes, sizeof(defaultOutputKneeCodes)/sizeof(UInt)); 808 const Int defaultPrimaryCodes[6] = { 0,50000, 0,0, 50000,0 }; 809 const Int defaultWhitePointCode[2] = { 16667, 16667 }; 810 SMultiValueInput<Int> cfg_DisplayPrimariesCode (0, 50000, 3, 3, defaultPrimaryCodes, sizeof(defaultPrimaryCodes )/sizeof(Int)); 811 SMultiValueInput<Int> cfg_DisplayWhitePointCode (0, 50000, 2, 2, defaultWhitePointCode, sizeof(defaultWhitePointCode)/sizeof(Int)); 812 813 SMultiValueInput<Bool> cfg_timeCodeSeiTimeStampFlag (0, 1, 0, MAX_TIMECODE_SEI_SETS); 814 SMultiValueInput<Bool> cfg_timeCodeSeiNumUnitFieldBasedFlag(0, 1, 0, MAX_TIMECODE_SEI_SETS); 815 SMultiValueInput<Int> cfg_timeCodeSeiCountingType (0, 6, 0, MAX_TIMECODE_SEI_SETS); 816 SMultiValueInput<Bool> cfg_timeCodeSeiFullTimeStampFlag (0, 1, 0, MAX_TIMECODE_SEI_SETS); 817 SMultiValueInput<Bool> cfg_timeCodeSeiDiscontinuityFlag (0, 1, 0, MAX_TIMECODE_SEI_SETS); 818 SMultiValueInput<Bool> cfg_timeCodeSeiCntDroppedFlag (0, 1, 0, MAX_TIMECODE_SEI_SETS); 819 SMultiValueInput<Int> cfg_timeCodeSeiNumberOfFrames (0,511, 0, MAX_TIMECODE_SEI_SETS); 820 SMultiValueInput<Int> cfg_timeCodeSeiSecondsValue (0, 59, 0, MAX_TIMECODE_SEI_SETS); 821 SMultiValueInput<Int> cfg_timeCodeSeiMinutesValue (0, 59, 0, MAX_TIMECODE_SEI_SETS); 822 SMultiValueInput<Int> cfg_timeCodeSeiHoursValue (0, 23, 0, MAX_TIMECODE_SEI_SETS); 823 SMultiValueInput<Bool> cfg_timeCodeSeiSecondsFlag (0, 1, 0, MAX_TIMECODE_SEI_SETS); 824 SMultiValueInput<Bool> cfg_timeCodeSeiMinutesFlag (0, 1, 0, MAX_TIMECODE_SEI_SETS); 825 SMultiValueInput<Bool> cfg_timeCodeSeiHoursFlag (0, 1, 0, MAX_TIMECODE_SEI_SETS); 826 SMultiValueInput<Int> cfg_timeCodeSeiTimeOffsetLength (0, 31, 0, MAX_TIMECODE_SEI_SETS); 827 SMultiValueInput<Int> cfg_timeCodeSeiTimeOffsetValue (std::numeric_limits<Int>::min(), std::numeric_limits<Int>::max(), 0, MAX_TIMECODE_SEI_SETS); 828 Int warnUnknowParameter = 0; 829 351 830 po::Options opts; 352 831 opts.addOptions() 353 ("help", do_help, false, "this help text") 354 ("c", po::parseConfigFile, "configuration file name") 355 832 ("help", do_help, false, "this help text") 833 ("c", po::parseConfigFile, "configuration file name") 834 ("WarnUnknowParameter,w", warnUnknowParameter, 0, "warn for unknown configuration parameters instead of failing") 835 356 836 // File, I/O and source parameters 357 #if H_MV837 #if NH_MV 358 838 ("InputFile_%d,i_%d", m_pchInputFileList, (char *) 0 , MAX_NUM_LAYER_IDS , "original Yuv input file name %d") 359 839 #else 360 ("InputFile,i", cfg_InputFile,string(""), "Original YUV input file name")361 #endif 362 ("BitstreamFile,b", cfg_BitstreamFile,string(""), "Bitstream output file name")363 #if H_MV840 ("InputFile,i", cfg_InputFile, string(""), "Original YUV input file name") 841 #endif 842 ("BitstreamFile,b", cfg_BitstreamFile, string(""), "Bitstream output file name") 843 #if NH_MV 364 844 ("ReconFile_%d,o_%d", m_pchReconFileList, (char *) 0 , MAX_NUM_LAYER_IDS , "reconstructed Yuv output file name %d") 365 845 #else 366 ("ReconFile,o", cfg_ReconFile,string(""), "Reconstructed YUV output file name")367 #endif 368 #if H_MV846 ("ReconFile,o", cfg_ReconFile, string(""), "Reconstructed YUV output file name") 847 #endif 848 #if NH_MV 369 849 ("NumberOfLayers", m_numberOfLayers , 1, "Number of layers") 370 #if ! H_3D850 #if !NH_3D 371 851 ("ScalabilityMask", m_scalabilityMask , 2 , "Scalability Mask: 2: Multiview, 8: Auxiliary, 10: Multiview + Auxiliary") 372 852 #else … … 377 857 ("ViewId", m_viewId , std::vector<Int>(1,0), "View Id per View Order Index") 378 858 ("AuxId", m_auxId , std::vector<Int>(1,0), "AuxId per layer") 379 #if H_3D859 #if NH_3D 380 860 ("DepthFlag", m_depthFlag , std::vector<Int>(1,0), "Depth Flag") 381 #if H_3D_DIM382 ("DLT", m_useDLT, true, "Depth lookup table")383 #endif384 #if H_3D385 #endif386 861 #endif 387 862 ("TargetEncLayerIdList", m_targetEncLayerIdList, std::vector<Int>(0,0), "LayerIds in Nuh to be encoded") 388 ("LayerIdInNuh", m_layerIdInNuh , std::vector<Int>(1,0), "LayerId in Nuh")389 ("SplittingFlag", m_splittingFlag , false , "Splitting Flag")863 ("LayerIdInNuh", m_layerIdInNuh , std::vector<Int>(1,0), "LayerId in Nuh") 864 ("SplittingFlag", m_splittingFlag , false , "Splitting Flag") 390 865 391 866 // Layer Sets + Output Layer Sets + Profile Tier Level … … 406 881 ("DependencyTypes_%d", m_dependencyTypes , std::vector<Int>(0,0), MAX_NUM_LAYERS, "Dependency types of direct reference layers, 0: Sample 1: Motion 2: Sample+Motion") 407 882 #endif 408 ("SourceWidth,-wdt", m_iSourceWidth, 0, "Source picture width") 409 ("SourceHeight,-hgt", m_iSourceHeight, 0, "Source picture height") 410 ("InputBitDepth", m_inputBitDepthY, 8, "Bit-depth of input file") 411 ("OutputBitDepth", m_outputBitDepthY, 0, "Bit-depth of output file (default:InternalBitDepth)") 412 ("InternalBitDepth", m_internalBitDepthY, 0, "Bit-depth the codec operates at. (default:InputBitDepth)" 413 "If different to InputBitDepth, source data will be converted") 414 ("InputBitDepthC", m_inputBitDepthC, 0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)") 415 ("OutputBitDepthC", m_outputBitDepthC, 0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)") 416 ("InternalBitDepthC", m_internalBitDepthC, 0, "As per InternalBitDepth but for chroma component. (default:IntrenalBitDepth)") 417 ("ConformanceMode", m_conformanceWindowMode, 0, "Deprecated alias of ConformanceWindowMode") 418 ("ConformanceWindowMode", m_conformanceWindowMode, 0, "Window conformance mode (0: no window, 1:automatic padding, 2:padding, 3:conformance") 419 ("HorizontalPadding,-pdx",m_aiPad[0], 0, "Horizontal source padding for conformance window mode 2") 420 ("VerticalPadding,-pdy", m_aiPad[1], 0, "Vertical source padding for conformance window mode 2") 421 ("ConfLeft", m_confWinLeft, 0, "Deprecated alias of ConfWinLeft") 422 ("ConfRight", m_confWinRight, 0, "Deprecated alias of ConfWinRight") 423 ("ConfTop", m_confWinTop, 0, "Deprecated alias of ConfWinTop") 424 ("ConfBottom", m_confWinBottom, 0, "Deprecated alias of ConfWinBottom") 425 ("ConfWinLeft", m_confWinLeft, 0, "Left offset for window conformance mode 3") 426 ("ConfWinRight", m_confWinRight, 0, "Right offset for window conformance mode 3") 427 ("ConfWinTop", m_confWinTop, 0, "Top offset for window conformance mode 3") 428 ("ConfWinBottom", m_confWinBottom, 0, "Bottom offset for window conformance mode 3") 429 ("FrameRate,-fr", m_iFrameRate, 0, "Frame rate") 430 ("FrameSkip,-fs", m_FrameSkip, 0u, "Number of frames to skip at start of input YUV") 431 ("FramesToBeEncoded,f", m_framesToBeEncoded, 0, "Number of frames to be encoded (default=all)") 883 ("SourceWidth,-wdt", m_iSourceWidth, 0, "Source picture width") 884 ("SourceHeight,-hgt", m_iSourceHeight, 0, "Source picture height") 885 ("InputBitDepth", m_inputBitDepth[CHANNEL_TYPE_LUMA], 8, "Bit-depth of input file") 886 ("OutputBitDepth", m_outputBitDepth[CHANNEL_TYPE_LUMA], 0, "Bit-depth of output file (default:InternalBitDepth)") 887 ("MSBExtendedBitDepth", m_MSBExtendedBitDepth[CHANNEL_TYPE_LUMA], 0, "bit depth of luma component after addition of MSBs of value 0 (used for synthesising High Dynamic Range source material). (default:InputBitDepth)") 888 ("InternalBitDepth", m_internalBitDepth[CHANNEL_TYPE_LUMA], 0, "Bit-depth the codec operates at. (default:MSBExtendedBitDepth). If different to MSBExtendedBitDepth, source data will be converted") 889 ("InputBitDepthC", m_inputBitDepth[CHANNEL_TYPE_CHROMA], 0, "As per InputBitDepth but for chroma component. (default:InputBitDepth)") 890 ("OutputBitDepthC", m_outputBitDepth[CHANNEL_TYPE_CHROMA], 0, "As per OutputBitDepth but for chroma component. (default:InternalBitDepthC)") 891 ("MSBExtendedBitDepthC", m_MSBExtendedBitDepth[CHANNEL_TYPE_CHROMA], 0, "As per MSBExtendedBitDepth but for chroma component. (default:MSBExtendedBitDepth)") 892 ("InternalBitDepthC", m_internalBitDepth[CHANNEL_TYPE_CHROMA], 0, "As per InternalBitDepth but for chroma component. (default:InternalBitDepth)") 893 ("ExtendedPrecision", m_extendedPrecisionProcessingFlag, false, "Increased internal accuracies to support high bit depths (not valid in V1 profiles)") 894 ("HighPrecisionPredictionWeighting", m_highPrecisionOffsetsEnabledFlag, false, "Use high precision option for weighted prediction (not valid in V1 profiles)") 895 ("InputColourSpaceConvert", inputColourSpaceConvert, string(""), "Colour space conversion to apply to input video. Permitted values are (empty string=UNCHANGED) " + getListOfColourSpaceConverts(true)) 896 ("SNRInternalColourSpace", m_snrInternalColourSpace, false, "If true, then no colour space conversion is applied prior to SNR, otherwise inverse of input is applied.") 897 ("OutputInternalColourSpace", m_outputInternalColourSpace, false, "If true, then no colour space conversion is applied for reconstructed video, otherwise inverse of input is applied.") 898 ("InputChromaFormat", tmpInputChromaFormat, 420, "InputChromaFormatIDC") 899 ("MSEBasedSequencePSNR", m_printMSEBasedSequencePSNR, false, "0 (default) emit sequence PSNR only as a linear average of the frame PSNRs, 1 = also emit a sequence PSNR based on an average of the frame MSEs") 900 ("PrintFrameMSE", m_printFrameMSE, false, "0 (default) emit only bit count and PSNRs for each frame, 1 = also emit MSE values") 901 ("PrintSequenceMSE", m_printSequenceMSE, false, "0 (default) emit only bit rate and PSNRs for the whole sequence, 1 = also emit MSE values") 902 ("CabacZeroWordPaddingEnabled", m_cabacZeroWordPaddingEnabled, true, "0 do not add conforming cabac-zero-words to bit streams, 1 (default) = add cabac-zero-words as required") 903 ("ChromaFormatIDC,-cf", tmpChromaFormat, 0, "ChromaFormatIDC (400|420|422|444 or set 0 (default) for same as InputChromaFormat)") 904 ("ConformanceMode", m_conformanceWindowMode, 0, "Deprecated alias of ConformanceWindowMode") 905 ("ConformanceWindowMode", m_conformanceWindowMode, 0, "Window conformance mode (0: no window, 1:automatic padding, 2:padding, 3:conformance") 906 ("HorizontalPadding,-pdx", m_aiPad[0], 0, "Horizontal source padding for conformance window mode 2") 907 ("VerticalPadding,-pdy", m_aiPad[1], 0, "Vertical source padding for conformance window mode 2") 908 ("ConfLeft", m_confWinLeft, 0, "Deprecated alias of ConfWinLeft") 909 ("ConfRight", m_confWinRight, 0, "Deprecated alias of ConfWinRight") 910 ("ConfTop", m_confWinTop, 0, "Deprecated alias of ConfWinTop") 911 ("ConfBottom", m_confWinBottom, 0, "Deprecated alias of ConfWinBottom") 912 ("ConfWinLeft", m_confWinLeft, 0, "Left offset for window conformance mode 3") 913 ("ConfWinRight", m_confWinRight, 0, "Right offset for window conformance mode 3") 914 ("ConfWinTop", m_confWinTop, 0, "Top offset for window conformance mode 3") 915 ("ConfWinBottom", m_confWinBottom, 0, "Bottom offset for window conformance mode 3") 916 ("FrameRate,-fr", m_iFrameRate, 0, "Frame rate") 917 ("FrameSkip,-fs", m_FrameSkip, 0u, "Number of frames to skip at start of input YUV") 918 ("FramesToBeEncoded,f", m_framesToBeEncoded, 0, "Number of frames to be encoded (default=all)") 919 ("ClipInputVideoToRec709Range", m_bClipInputVideoToRec709Range, false, "If true then clip input video to the Rec. 709 Range on loading when InternalBitDepth is less than MSBExtendedBitDepth") 920 ("ClipOutputVideoToRec709Range", m_bClipOutputVideoToRec709Range, false, "If true then clip output video to the Rec. 709 Range on saving when OutputBitDepth is less than InternalBitDepth") 921 ("SummaryOutFilename", m_summaryOutFilename, string(), "Filename to use for producing summary output file. If empty, do not produce a file.") 922 ("SummaryPicFilenameBase", m_summaryPicFilenameBase, string(), "Base filename to use for producing summary picture output files. The actual filenames used will have I.txt, P.txt and B.txt appended. If empty, do not produce a file.") 923 ("SummaryVerboseness", m_summaryVerboseness, 0u, "Specifies the level of the verboseness of the text output") 432 924 433 925 //Field coding parameters 434 ("FieldCoding", m_isField, false, "Signals if it's a field based coding") 435 ("TopFieldFirst, Tff", m_isTopFieldFirst, false, "In case of field based coding, signals whether if it's a top field first or not") 436 926 ("FieldCoding", m_isField, false, "Signals if it's a field based coding") 927 ("TopFieldFirst, Tff", m_isTopFieldFirst, false, "In case of field based coding, signals whether if it's a top field first or not") 928 ("EfficientFieldIRAPEnabled", m_bEfficientFieldIRAPEnabled, true, "Enable to code fields in a specific, potentially more efficient, order.") 929 ("HarmonizeGopFirstFieldCoupleEnabled", m_bHarmonizeGopFirstFieldCoupleEnabled, true, "Enables harmonization of Gop first field couple") 930 437 931 // Profile and level 438 #if H_MV439 ("Profile" , cfg_profiles, string(""),"Profile in VpsProfileTierLevel (Indication only)")440 ("Level" , cfg_levels , string(""),"Level indication in VpsProfileTierLevel (Indication only)")441 ("Tier" , cfg_tiers , string(""),"Tier indication in VpsProfileTierLevel (Indication only)")442 ("InblFlag", m_inblFlag ,std::vector<Bool>(0), "InblFlags in VpsProfileTierLevel (Indication only)" )932 #if NH_MV 933 ("Profile" , cfg_profiles, string(""), "Profile in VpsProfileTierLevel (Indication only)") 934 ("Level" , cfg_levels , string(""), "Level indication in VpsProfileTierLevel (Indication only)") 935 ("Tier" , cfg_tiers , string(""), "Tier indication in VpsProfileTierLevel (Indication only)") 936 ("InblFlag", m_inblFlag , std::vector<Bool>(0), "InblFlags in VpsProfileTierLevel (Indication only)" ) 443 937 #else 444 ("Profile", m_profile, Profile::NONE, "Profile to be used when encoding (Incomplete)") 445 ("Level", m_level, Level::NONE, "Level limit to be used, eg 5.1 (Incomplete)") 446 ("Tier", m_levelTier, Level::MAIN, "Tier to use for interpretation of --Level") 447 #endif 448 ("ProgressiveSource", m_progressiveSourceFlag, false, "Indicate that source is progressive") 449 ("InterlacedSource", m_interlacedSourceFlag, false, "Indicate that source is interlaced") 450 ("NonPackedSource", m_nonPackedConstraintFlag, false, "Indicate that source does not contain frame packing") 451 ("FrameOnly", m_frameOnlyConstraintFlag, false, "Indicate that the bitstream contains only frames") 452 938 ("Profile", extendedProfile, NONE, "Profile name to use for encoding. Use main (for main), main10 (for main10), main-still-picture, main-RExt (for Range Extensions profile), any of the RExt specific profile names, or none") 939 ("Level", m_level, Level::NONE, "Level limit to be used, eg 5.1, or none") 940 ("Tier", m_levelTier, Level::MAIN, "Tier to use for interpretation of --Level (main or high only)") 941 #endif 942 ("MaxBitDepthConstraint", m_bitDepthConstraint, 0u, "Bit depth to use for profile-constraint for RExt profiles. 0=automatically choose based upon other parameters") 943 ("MaxChromaFormatConstraint", tmpConstraintChromaFormat, 0, "Chroma-format to use for the profile-constraint for RExt profiles. 0=automatically choose based upon other parameters") 944 ("IntraConstraintFlag", m_intraConstraintFlag, false, "Value of general_intra_constraint_flag to use for RExt profiles (not used if an explicit RExt sub-profile is specified)") 945 ("OnePictureOnlyConstraintFlag", m_onePictureOnlyConstraintFlag, false, "Value of general_one_picture_only_constraint_flag to use for RExt profiles (not used if an explicit RExt sub-profile is specified)") 946 ("LowerBitRateConstraintFlag", m_lowerBitRateConstraintFlag, true, "Value of general_lower_bit_rate_constraint_flag to use for RExt profiles") 947 948 ("ProgressiveSource", m_progressiveSourceFlag, false, "Indicate that source is progressive") 949 ("InterlacedSource", m_interlacedSourceFlag, false, "Indicate that source is interlaced") 950 ("NonPackedSource", m_nonPackedConstraintFlag, false, "Indicate that source does not contain frame packing") 951 ("FrameOnly", m_frameOnlyConstraintFlag, false, "Indicate that the bitstream contains only frames") 952 453 953 // Unit definition parameters 454 ("MaxCUWidth", m_uiMaxCUWidth,64u)455 ("MaxCUHeight", m_uiMaxCUHeight,64u)954 ("MaxCUWidth", m_uiMaxCUWidth, 64u) 955 ("MaxCUHeight", m_uiMaxCUHeight, 64u) 456 956 // todo: remove defaults from MaxCUSize 457 ("MaxCUSize,s", m_uiMaxCUWidth,64u, "Maximum CU size")458 ("MaxCUSize,s", m_uiMaxCUHeight,64u, "Maximum CU size")459 ("MaxPartitionDepth,h", m_uiMaxCUDepth,4u, "CU depth")460 461 ("QuadtreeTULog2MaxSize", m_uiQuadtreeTULog2MaxSize,6u, "Maximum TU size in logarithm base 2")462 ("QuadtreeTULog2MinSize", m_uiQuadtreeTULog2MinSize,2u, "Minimum TU size in logarithm base 2")463 464 ("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra,1u, "Depth of TU tree for intra CUs")465 ("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter,2u, "Depth of TU tree for inter CUs")466 #if H_MV957 ("MaxCUSize,s", m_uiMaxCUWidth, 64u, "Maximum CU size") 958 ("MaxCUSize,s", m_uiMaxCUHeight, 64u, "Maximum CU size") 959 ("MaxPartitionDepth,h", m_uiMaxCUDepth, 4u, "CU depth") 960 961 ("QuadtreeTULog2MaxSize", m_uiQuadtreeTULog2MaxSize, 6u, "Maximum TU size in logarithm base 2") 962 ("QuadtreeTULog2MinSize", m_uiQuadtreeTULog2MinSize, 2u, "Minimum TU size in logarithm base 2") 963 964 ("QuadtreeTUMaxDepthIntra", m_uiQuadtreeTUMaxDepthIntra, 1u, "Depth of TU tree for intra CUs") 965 ("QuadtreeTUMaxDepthInter", m_uiQuadtreeTUMaxDepthInter, 2u, "Depth of TU tree for inter CUs") 966 #if NH_MV 467 967 // Coding structure parameters 468 ("IntraPeriod,-ip", m_iIntraPeriod,std::vector<Int>(1,-1), "Intra period in frames, (-1: only first frame), per layer")968 ("IntraPeriod,-ip", m_iIntraPeriod,std::vector<Int>(1,-1) , "Intra period in frames, (-1: only first frame), per layer") 469 969 #else 470 970 // Coding structure paramters 471 ("IntraPeriod,-ip", m_iIntraPeriod, -1, "Intra period in frames, (-1: only first frame)") 472 #endif 473 #if ALLOW_RECOVERY_POINT_AS_RAP 474 ("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR 3:RecPointSEI)") 475 #else 476 ("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR)") 477 #endif 478 ("GOPSize,g", m_iGOPSize, 1, "GOP size of temporal structure") 479 // motion options 480 ("FastSearch", m_iFastSearch, 1, "0:Full search 1:Diamond 2:PMVFAST") 481 ("SearchRange,-sr", m_iSearchRange, 96, "Motion search range") 482 #if H_MV 971 ("IntraPeriod,-ip", m_iIntraPeriod, -1, "Intra period in frames, (-1: only first frame)") 972 #endif 973 ("DecodingRefreshType,-dr", m_iDecodingRefreshType, 0, "Intra refresh type (0:none 1:CRA 2:IDR 3:RecPointSEI)") 974 ("GOPSize,g", m_iGOPSize, 1, "GOP size of temporal structure") 975 976 // motion search options 977 ("DisableIntraInInter", m_bDisableIntraPUsInInterSlices, false, "Flag to disable intra PUs in inter slices") 978 ("FastSearch", m_iFastSearch, 1, "0:Full search 1:Diamond 2:PMVFAST") 979 ("SearchRange,-sr", m_iSearchRange, 96, "Motion search range") 980 #if NH_MV 483 981 ("DispSearchRangeRestriction", m_bUseDisparitySearchRangeRestriction, false, "restrict disparity search range") 484 982 ("VerticalDispSearchRange", m_iVerticalDisparitySearchRange, 56, "vertical disparity search range") 485 983 #endif 486 ("BipredSearchRange", m_bipredSearchRange, 4, "Motion search range for bipred refinement") 487 ("HadamardME", m_bUseHADME, true, "Hadamard ME for fractional-pel") 488 ("ASR", m_bUseASR, false, "Adaptive motion search range") 984 ("BipredSearchRange", m_bipredSearchRange, 4, "Motion search range for bipred refinement") 985 ("ClipForBiPredMEEnabled", m_bClipForBiPredMeEnabled, false, "Enables clipping in the Bi-Pred ME. It is disabled to reduce encoder run-time") 986 ("FastMEAssumingSmootherMVEnabled", m_bFastMEAssumingSmootherMVEnabled, true, "Enables fast ME assuming a smoother MV.") 987 988 ("HadamardME", m_bUseHADME, true, "Hadamard ME for fractional-pel") 989 ("ASR", m_bUseASR, false, "Adaptive motion search range") 489 990 490 991 // Mode decision parameters 491 ("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ],( Double )1.0, "Lambda modifier for temporal layer 0")492 ("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ],( Double )1.0, "Lambda modifier for temporal layer 1")493 ("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ],( Double )1.0, "Lambda modifier for temporal layer 2")494 ("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ],( Double )1.0, "Lambda modifier for temporal layer 3")495 ("LambdaModifier4,-LM4", m_adLambdaModifier[ 4 ],( Double )1.0, "Lambda modifier for temporal layer 4")496 ("LambdaModifier5,-LM5", m_adLambdaModifier[ 5 ],( Double )1.0, "Lambda modifier for temporal layer 5")497 ("LambdaModifier6,-LM6", m_adLambdaModifier[ 6 ],( Double )1.0, "Lambda modifier for temporal layer 6")992 ("LambdaModifier0,-LM0", m_adLambdaModifier[ 0 ], ( Double )1.0, "Lambda modifier for temporal layer 0") 993 ("LambdaModifier1,-LM1", m_adLambdaModifier[ 1 ], ( Double )1.0, "Lambda modifier for temporal layer 1") 994 ("LambdaModifier2,-LM2", m_adLambdaModifier[ 2 ], ( Double )1.0, "Lambda modifier for temporal layer 2") 995 ("LambdaModifier3,-LM3", m_adLambdaModifier[ 3 ], ( Double )1.0, "Lambda modifier for temporal layer 3") 996 ("LambdaModifier4,-LM4", m_adLambdaModifier[ 4 ], ( Double )1.0, "Lambda modifier for temporal layer 4") 997 ("LambdaModifier5,-LM5", m_adLambdaModifier[ 5 ], ( Double )1.0, "Lambda modifier for temporal layer 5") 998 ("LambdaModifier6,-LM6", m_adLambdaModifier[ 6 ], ( Double )1.0, "Lambda modifier for temporal layer 6") 498 999 499 1000 /* Quantization parameters */ 500 #if H_MV1001 #if NH_MV 501 1002 ("QP,q", m_fQP, std::vector<double>(1,30.0), "Qp values for each layer, if value is float, QP is switched once during encoding") 502 1003 #else 503 ("QP,q", m_fQP, 30.0, "Qp value, if value is float, QP is switched once during encoding") 504 #endif 505 ("DeltaQpRD,-dqr",m_uiDeltaQpRD, 0u, "max dQp offset for slice") 506 ("MaxDeltaQP,d", m_iMaxDeltaQP, 0, "max dQp offset for block") 507 ("MaxCuDQPDepth,-dqd", m_iMaxCuDQPDepth, 0, "max depth for a minimum CuDQP") 508 509 ("CbQpOffset,-cbqpofs", m_cbQpOffset, 0, "Chroma Cb QP Offset") 510 ("CrQpOffset,-crqpofs", m_crQpOffset, 0, "Chroma Cr QP Offset") 1004 ("QP,q", m_fQP, 30.0, "Qp value, if value is float, QP is switched once during encoding") 1005 #endif 1006 ("DeltaQpRD,-dqr", m_uiDeltaQpRD, 0u, "max dQp offset for slice") 1007 ("MaxDeltaQP,d", m_iMaxDeltaQP, 0, "max dQp offset for block") 1008 ("MaxCuDQPDepth,-dqd", m_iMaxCuDQPDepth, 0, "max depth for a minimum CuDQP") 1009 ("MaxCUChromaQpAdjustmentDepth", m_diffCuChromaQpOffsetDepth, -1, "Maximum depth for CU chroma Qp adjustment - set less than 0 to disable") 1010 1011 ("CbQpOffset,-cbqpofs", m_cbQpOffset, 0, "Chroma Cb QP Offset") 1012 ("CrQpOffset,-crqpofs", m_crQpOffset, 0, "Chroma Cr QP Offset") 511 1013 512 1014 #if ADAPTIVE_QP_SELECTION 513 ("AdaptiveQpSelection,-aqps", m_bUseAdaptQpSelect, false, "AdaptiveQpSelection") 514 #endif 515 516 ("AdaptiveQP,-aq", m_bUseAdaptiveQP, false, "QP adaptation based on a psycho-visual model") 517 ("MaxQPAdaptationRange,-aqr", m_iQPAdaptationRange, 6, "QP adaptation range") 518 ("dQPFile,m", cfg_dQPFile, string(""), "dQP file name") 519 ("RDOQ", m_useRDOQ, true ) 520 ("RDOQTS", m_useRDOQTS, true ) 521 ("RDpenalty", m_rdPenalty, 0, "RD-penalty for 32x32 TU for intra in non-intra slices. 0:disbaled 1:RD-penalty 2:maximum RD-penalty") 522 1015 ("AdaptiveQpSelection,-aqps", m_bUseAdaptQpSelect, false, "AdaptiveQpSelection") 1016 #endif 1017 1018 ("AdaptiveQP,-aq", m_bUseAdaptiveQP, false, "QP adaptation based on a psycho-visual model") 1019 ("MaxQPAdaptationRange,-aqr", m_iQPAdaptationRange, 6, "QP adaptation range") 1020 ("dQPFile,m", cfg_dQPFile, string(""), "dQP file name") 1021 ("RDOQ", m_useRDOQ, true) 1022 ("RDOQTS", m_useRDOQTS, true) 1023 #if T0196_SELECTIVE_RDOQ 1024 ("SelectiveRDOQ", m_useSelectiveRDOQ, false, "Enable selective RDOQ") 1025 #endif 1026 ("RDpenalty", m_rdPenalty, 0, "RD-penalty for 32x32 TU for intra in non-intra slices. 0:disabled 1:RD-penalty 2:maximum RD-penalty") 1027 523 1028 // Deblocking filter parameters 524 #if H_MV525 ("LoopFilterDisable", m_bLoopFilterDisable,std::vector<Bool>(1,false), "Disable Loop Filter per Layer" )1029 #if NH_MV 1030 ("LoopFilterDisable", m_bLoopFilterDisable, std::vector<Bool>(1,false), "Disable Loop Filter per Layer" ) 526 1031 #else 527 ("LoopFilterDisable", m_bLoopFilterDisable, false ) 528 #endif 529 ("LoopFilterOffsetInPPS", m_loopFilterOffsetInPPS, false ) 530 ("LoopFilterBetaOffset_div2", m_loopFilterBetaOffsetDiv2, 0 ) 531 ("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0 ) 532 ("DeblockingFilterControlPresent", m_DeblockingFilterControlPresent, false ) 533 ("DeblockingFilterMetric", m_DeblockingFilterMetric, false ) 534 535 #if H_3D_IC 536 ("IlluCompEnable", m_abUseIC, true, "Enable illumination compensation") 537 ("IlluCompLowLatencyEnc", m_bUseLowLatencyICEnc, false, "Enable low-latency illumination compensation encoding") 538 #endif 1032 ("LoopFilterDisable", m_bLoopFilterDisable, false) 1033 #endif 1034 ("LoopFilterOffsetInPPS", m_loopFilterOffsetInPPS, true) 1035 ("LoopFilterBetaOffset_div2", m_loopFilterBetaOffsetDiv2, 0) 1036 ("LoopFilterTcOffset_div2", m_loopFilterTcOffsetDiv2, 0) 1037 ("DeblockingFilterMetric", m_DeblockingFilterMetric, false) 1038 539 1039 // Coding tools 540 ("AMP", m_enableAMP, true, "Enable asymmetric motion partitions") 541 ("TransformSkip", m_useTransformSkip, false, "Intra transform skipping") 542 ("TransformSkipFast", m_useTransformSkipFast, false, "Fast intra transform skipping") 543 #if H_MV 1040 ("AMP", m_enableAMP, true, "Enable asymmetric motion partitions") 1041 ("CrossComponentPrediction", m_crossComponentPredictionEnabledFlag, false, "Enable the use of cross-component prediction (not valid in V1 profiles)") 1042 ("ReconBasedCrossCPredictionEstimate", m_reconBasedCrossCPredictionEstimate, false, "When determining the alpha value for cross-component prediction, use the decoded residual rather than the pre-transform encoder-side residual") 1043 ("SaoLumaOffsetBitShift", saoOffsetBitShift[CHANNEL_TYPE_LUMA], 0, "Specify the luma SAO bit-shift. If negative, automatically calculate a suitable value based upon bit depth and initial QP") 1044 ("SaoChromaOffsetBitShift", saoOffsetBitShift[CHANNEL_TYPE_CHROMA], 0, "Specify the chroma SAO bit-shift. If negative, automatically calculate a suitable value based upon bit depth and initial QP") 1045 ("TransformSkip", m_useTransformSkip, false, "Intra transform skipping") 1046 ("TransformSkipFast", m_useTransformSkipFast, false, "Fast intra transform skipping") 1047 ("TransformSkipLog2MaxSize", m_log2MaxTransformSkipBlockSize, 2U, "Specify transform-skip maximum size. Minimum 2. (not valid in V1 profiles)") 1048 ("ImplicitResidualDPCM", m_rdpcmEnabledFlag[RDPCM_SIGNAL_IMPLICIT], false, "Enable implicitly signalled residual DPCM for intra (also known as sample-adaptive intra predict) (not valid in V1 profiles)") 1049 ("ExplicitResidualDPCM", m_rdpcmEnabledFlag[RDPCM_SIGNAL_EXPLICIT], false, "Enable explicitly signalled residual DPCM for inter (not valid in V1 profiles)") 1050 ("ResidualRotation", m_transformSkipRotationEnabledFlag, false, "Enable rotation of transform-skipped and transquant-bypassed TUs through 180 degrees prior to entropy coding (not valid in V1 profiles)") 1051 ("SingleSignificanceMapContext", m_transformSkipContextEnabledFlag, false, "Enable, for transform-skipped and transquant-bypassed TUs, the selection of a single significance map context variable for all coefficients (not valid in V1 profiles)") 1052 ("GolombRiceParameterAdaptation", m_persistentRiceAdaptationEnabledFlag, false, "Enable the adaptation of the Golomb-Rice parameter over the course of each slice") 1053 ("AlignCABACBeforeBypass", m_cabacBypassAlignmentEnabledFlag, false, "Align the CABAC engine to a defined fraction of a bit prior to coding bypass data. Must be 1 in high bit rate profile, 0 otherwise" ) 1054 #if NH_MV 544 1055 ("SAO", m_bUseSAO, std::vector<Bool>(1,true), "Enable Sample Adaptive Offset per Layer") 545 1056 #else 546 ("SAO", m_bUseSAO, true, "Enable Sample Adaptive Offset") 547 #endif 548 ("MaxNumOffsetsPerPic", m_maxNumOffsetsPerPic, 2048, "Max number of SAO offset per picture (Default: 2048)") 549 ("SAOLcuBoundary", m_saoLcuBoundary, false, "0: right/bottom LCU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas") 550 ("SliceMode", m_sliceMode, 0, "0: Disable all Recon slice limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice") 551 ("SliceArgument", m_sliceArgument, 0, "Depending on SliceMode being:" 552 "\t1: max number of CTUs per slice" 553 "\t2: max number of bytes per slice" 554 "\t3: max number of tiles per slice") 555 ("SliceSegmentMode", m_sliceSegmentMode, 0, "0: Disable all slice segment limits, 1: Enforce max # of LCUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice") 556 ("SliceSegmentArgument", m_sliceSegmentArgument, 0, "Depending on SliceSegmentMode being:" 557 "\t1: max number of CTUs per slice segment" 558 "\t2: max number of bytes per slice segment" 559 "\t3: max number of tiles per slice segment") 560 ("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true) 561 562 ("ConstrainedIntraPred", m_bUseConstrainedIntraPred, false, "Constrained Intra Prediction") 563 564 ("PCMEnabledFlag", m_usePCM, false) 565 ("PCMLog2MaxSize", m_pcmLog2MaxSize, 5u) 566 ("PCMLog2MinSize", m_uiPCMLog2MinSize, 3u) 567 ("PCMInputBitDepthFlag", m_bPCMInputBitDepthFlag, true) 568 ("PCMFilterDisableFlag", m_bPCMFilterDisableFlag, false) 569 570 ("WeightedPredP,-wpP", m_useWeightedPred, false, "Use weighted prediction in P slices") 571 ("WeightedPredB,-wpB", m_useWeightedBiPred, false, "Use weighted (bidirectional) prediction in B slices") 572 ("Log2ParallelMergeLevel", m_log2ParallelMergeLevel, 2u, "Parallel merge estimation region") 573 574 //deprecated copies of renamed tile parameters 575 ("UniformSpacingIdc", m_tileUniformSpacingFlag, false, "deprecated alias of TileUniformSpacing") 576 ("ColumnWidthArray", cfgColumnWidth, string(""), "deprecated alias of TileColumnWidthArray") 577 ("RowHeightArray", cfgRowHeight, string(""), "deprecated alias of TileRowHeightArray") 578 579 ("TileUniformSpacing", m_tileUniformSpacingFlag, false, "Indicates that tile columns and rows are distributed uniformly") 580 ("NumTileColumnsMinus1", m_numTileColumnsMinus1, 0, "Number of tile columns in a picture minus 1") 581 ("NumTileRowsMinus1", m_numTileRowsMinus1, 0, "Number of rows in a picture minus 1") 582 ("TileColumnWidthArray", cfgColumnWidth, string(""), "Array containing tile column width values in units of LCU") 583 ("TileRowHeightArray", cfgRowHeight, string(""), "Array containing tile row height values in units of LCU") 584 ("LFCrossTileBoundaryFlag", m_bLFCrossTileBoundaryFlag, true, "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering") 585 ("WaveFrontSynchro", m_iWaveFrontSynchro, 0, "0: no synchro; 1 synchro with TR; 2 TRR etc") 586 ("ScalingList", m_useScalingListId, 0, "0: no scaling list, 1: default scaling lists, 2: scaling lists specified in ScalingListFile") 587 ("ScalingListFile", cfg_ScalingListFile, string(""), "Scaling list file name") 588 ("SignHideFlag,-SBH", m_signHideFlag, 1) 589 ("MaxNumMergeCand", m_maxNumMergeCand, 5u, "Maximum number of merge candidates") 590 1057 ("SAO", m_bUseSAO, true, "Enable Sample Adaptive Offset") 1058 #endif 1059 ("TestSAODisableAtPictureLevel", m_bTestSAODisableAtPictureLevel, false, "Enables the testing of disabling SAO at the picture level after having analysed all blocks") 1060 ("SaoEncodingRate", m_saoEncodingRate, 0.75, "When >0 SAO early picture termination is enabled for luma and chroma") 1061 ("SaoEncodingRateChroma", m_saoEncodingRateChroma, 0.5, "The SAO early picture termination rate to use for chroma (when m_SaoEncodingRate is >0). If <=0, use results for luma") 1062 ("MaxNumOffsetsPerPic", m_maxNumOffsetsPerPic, 2048, "Max number of SAO offset per picture (Default: 2048)") 1063 ("SAOLcuBoundary", m_saoCtuBoundary, false, "0: right/bottom CTU boundary areas skipped from SAO parameter estimation, 1: non-deblocked pixels are used for those areas") 1064 ("SliceMode", m_sliceMode, 0, "0: Disable all Recon slice limits, 1: Enforce max # of CTUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice") 1065 ("SliceArgument", m_sliceArgument, 0, "Depending on SliceMode being:" 1066 "\t1: max number of CTUs per slice" 1067 "\t2: max number of bytes per slice" 1068 "\t3: max number of tiles per slice") 1069 ("SliceSegmentMode", m_sliceSegmentMode, 0, "0: Disable all slice segment limits, 1: Enforce max # of CTUs, 2: Enforce max # of bytes, 3:specify tiles per dependent slice") 1070 ("SliceSegmentArgument", m_sliceSegmentArgument, 0, "Depending on SliceSegmentMode being:" 1071 "\t1: max number of CTUs per slice segment" 1072 "\t2: max number of bytes per slice segment" 1073 "\t3: max number of tiles per slice segment") 1074 ("LFCrossSliceBoundaryFlag", m_bLFCrossSliceBoundaryFlag, true) 1075 1076 ("ConstrainedIntraPred", m_bUseConstrainedIntraPred, false, "Constrained Intra Prediction") 1077 ("FastUDIUseMPMEnabled", m_bFastUDIUseMPMEnabled, true, "If enabled, adapt intra direction search, accounting for MPM") 1078 ("FastMEForGenBLowDelayEnabled", m_bFastMEForGenBLowDelayEnabled, true, "If enabled use a fast ME for generalised B Low Delay slices") 1079 ("UseBLambdaForNonKeyLowDelayPictures", m_bUseBLambdaForNonKeyLowDelayPictures, true, "Enables use of B-Lambda for non-key low-delay pictures") 1080 ("PCMEnabledFlag", m_usePCM, false) 1081 ("PCMLog2MaxSize", m_pcmLog2MaxSize, 5u) 1082 ("PCMLog2MinSize", m_uiPCMLog2MinSize, 3u) 1083 1084 ("PCMInputBitDepthFlag", m_bPCMInputBitDepthFlag, true) 1085 ("PCMFilterDisableFlag", m_bPCMFilterDisableFlag, false) 1086 ("IntraReferenceSmoothing", m_enableIntraReferenceSmoothing, true, "0: Disable use of intra reference smoothing. 1: Enable use of intra reference smoothing (not valid in V1 profiles)") 1087 ("WeightedPredP,-wpP", m_useWeightedPred, false, "Use weighted prediction in P slices") 1088 ("WeightedPredB,-wpB", m_useWeightedBiPred, false, "Use weighted (bidirectional) prediction in B slices") 1089 ("Log2ParallelMergeLevel", m_log2ParallelMergeLevel, 2u, "Parallel merge estimation region") 1090 //deprecated copies of renamed tile parameters 1091 ("UniformSpacingIdc", m_tileUniformSpacingFlag, false, "deprecated alias of TileUniformSpacing") 1092 ("ColumnWidthArray", cfg_ColumnWidth, cfg_ColumnWidth, "deprecated alias of TileColumnWidthArray") 1093 ("RowHeightArray", cfg_RowHeight, cfg_RowHeight, "deprecated alias of TileRowHeightArray") 1094 1095 ("TileUniformSpacing", m_tileUniformSpacingFlag, false, "Indicates that tile columns and rows are distributed uniformly") 1096 ("NumTileColumnsMinus1", m_numTileColumnsMinus1, 0, "Number of tile columns in a picture minus 1") 1097 ("NumTileRowsMinus1", m_numTileRowsMinus1, 0, "Number of rows in a picture minus 1") 1098 ("TileColumnWidthArray", cfg_ColumnWidth, cfg_ColumnWidth, "Array containing tile column width values in units of CTU") 1099 ("TileRowHeightArray", cfg_RowHeight, cfg_RowHeight, "Array containing tile row height values in units of CTU") 1100 ("LFCrossTileBoundaryFlag", m_bLFCrossTileBoundaryFlag, true, "1: cross-tile-boundary loop filtering. 0:non-cross-tile-boundary loop filtering") 1101 ("WaveFrontSynchro", m_iWaveFrontSynchro, 0, "0: no synchro; 1 synchro with top-right-right") 1102 ("ScalingList", m_useScalingListId, SCALING_LIST_OFF, "0/off: no scaling list, 1/default: default scaling lists, 2/file: scaling lists specified in ScalingListFile") 1103 ("ScalingListFile", cfg_ScalingListFile, string(""), "Scaling list file name. Use an empty string to produce help.") 1104 ("SignHideFlag,-SBH", m_signHideFlag, true) 1105 ("MaxNumMergeCand", m_maxNumMergeCand, 5u, "Maximum number of merge candidates") 591 1106 /* Misc. */ 592 ("SEIDecodedPictureHash", m_decodedPictureHashSEIEnabled, 0, "Control generation of decode picture hash SEI messages\n" 593 "\t3: checksum\n" 594 "\t2: CRC\n" 595 "\t1: use MD5\n" 596 "\t0: disable") 597 ("SEIpictureDigest", m_decodedPictureHashSEIEnabled, 0, "deprecated alias for SEIDecodedPictureHash") 598 ("TMVPMode", m_TMVPModeId, 1, "TMVP mode 0: TMVP disable for all slices. 1: TMVP enable for all slices (default) 2: TMVP enable for certain slices only") 599 ("FEN", m_bUseFastEnc, false, "fast encoder setting") 600 ("ECU", m_bUseEarlyCU, false, "Early CU setting") 601 ("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost") 602 ("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting") 603 ("ESD", m_useEarlySkipDetection, false, "Early SKIP detection setting") 604 ( "RateControl", m_RCEnableRateControl, false, "Rate control: enable rate control" ) 605 ( "TargetBitrate", m_RCTargetBitrate, 0, "Rate control: target bitrate" ) 606 ( "KeepHierarchicalBit", m_RCKeepHierarchicalBit, 0, "Rate control: 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation" ) 607 ( "LCULevelRateControl", m_RCLCULevelRC, true, "Rate control: true: LCU level RC; false: picture level RC" ) 608 ( "RCLCUSeparateModel", m_RCUseLCUSeparateModel, true, "Rate control: use LCU level separate R-lambda model" ) 609 ( "InitialQP", m_RCInitialQP, 0, "Rate control: initial QP" ) 610 ( "RCForceIntraQP", m_RCForceIntraQP, false, "Rate control: force intra QP to be equal to initial QP" ) 1107 ("SEIDecodedPictureHash", m_decodedPictureHashSEIEnabled, 0, "Control generation of decode picture hash SEI messages\n" 1108 "\t3: checksum\n" 1109 "\t2: CRC\n" 1110 "\t1: use MD5\n" 1111 "\t0: disable") 1112 ("TMVPMode", m_TMVPModeId, 1, "TMVP mode 0: TMVP disable for all slices. 1: TMVP enable for all slices (default) 2: TMVP enable for certain slices only") 1113 ("FEN", m_bUseFastEnc, false, "fast encoder setting") 1114 ("ECU", m_bUseEarlyCU, false, "Early CU setting") 1115 ("FDM", m_useFastDecisionForMerge, true, "Fast decision for Merge RD Cost") 1116 ("CFM", m_bUseCbfFastMode, false, "Cbf fast mode setting") 1117 ("ESD", m_useEarlySkipDetection, false, "Early SKIP detection setting") 1118 ( "RateControl", m_RCEnableRateControl, false, "Rate control: enable rate control" ) 1119 ( "TargetBitrate", m_RCTargetBitrate, 0, "Rate control: target bit-rate" ) 1120 ( "KeepHierarchicalBit", m_RCKeepHierarchicalBit, 0, "Rate control: 0: equal bit allocation; 1: fixed ratio bit allocation; 2: adaptive ratio bit allocation" ) 1121 ( "LCULevelRateControl", m_RCLCULevelRC, true, "Rate control: true: CTU level RC; false: picture level RC" ) 1122 ( "RCLCUSeparateModel", m_RCUseLCUSeparateModel, true, "Rate control: use CTU level separate R-lambda model" ) 1123 ( "InitialQP", m_RCInitialQP, 0, "Rate control: initial QP" ) 1124 ( "RCForceIntraQP", m_RCForceIntraQP, false, "Rate control: force intra QP to be equal to initial QP" ) 611 1125 612 1126 #if KWU_RC_VIEWRC_E0227 … … 617 1131 ("DepthMADPred, -dm", m_depthMADPred, (UInt)0, "Depth based MAD prediction on/off") 618 1132 #endif 619 #if H_MV1133 #if NH_MV 620 1134 // A lot of this stuff could should actually be derived by the encoder. 621 1135 // VPS VUI … … 626 1140 ("BitRatePresentVpsFlag" , m_bitRatePresentVpsFlag , false , "BitRatePresentVpsFlag ") 627 1141 ("PicRatePresentVpsFlag" , m_picRatePresentVpsFlag , false , "PicRatePresentVpsFlag ") 628 ("BitRatePresentFlag" , m_bitRatePresentFlag , std::vector< Bool >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "BitRatePresentFlag per sub layer for the N-th layer set")629 ("PicRatePresentFlag" , m_picRatePresentFlag , std::vector< Bool >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "PicRatePresentFlag per sub layer for the N-th layer set")1142 ("BitRatePresentFlag" , m_bitRatePresentFlag , BoolAry1d(1,0) ,MAX_VPS_OP_SETS_PLUS1, "BitRatePresentFlag per sub layer for the N-th layer set") 1143 ("PicRatePresentFlag" , m_picRatePresentFlag , BoolAry1d(1,0) ,MAX_VPS_OP_SETS_PLUS1, "PicRatePresentFlag per sub layer for the N-th layer set") 630 1144 ("AvgBitRate" , m_avgBitRate , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "AvgBitRate per sub layer for the N-th layer set") 631 1145 ("MaxBitRate" , m_maxBitRate , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "MaxBitRate per sub layer for the N-th layer set") … … 633 1147 ("AvgPicRate" , m_avgPicRate , std::vector< Int >(1,0) ,MAX_VPS_OP_SETS_PLUS1, "AvgPicRate per sub layer for the N-th layer set") 634 1148 ("TilesNotInUseFlag" , m_tilesNotInUseFlag , true , "TilesNotInUseFlag ") 635 ("TilesInUseFlag" , m_tilesInUseFlag , std::vector< Bool >(1,false) , "TilesInUseFlag ")636 ("LoopFilterNotAcrossTilesFlag" , m_loopFilterNotAcrossTilesFlag , std::vector< Bool >(1,false) , "LoopFilterNotAcrossTilesFlag ")1149 ("TilesInUseFlag" , m_tilesInUseFlag , BoolAry1d(1,false) , "TilesInUseFlag ") 1150 ("LoopFilterNotAcrossTilesFlag" , m_loopFilterNotAcrossTilesFlag , BoolAry1d(1,false) , "LoopFilterNotAcrossTilesFlag ") 637 1151 ("WppNotInUseFlag" , m_wppNotInUseFlag , true , "WppNotInUseFlag ") 638 ("WppInUseFlag" , m_wppInUseFlag , std::vector< Bool >(1,0) , "WppInUseFlag ")639 ("TileBoundariesAlignedFlag" , m_tileBoundariesAlignedFlag , std::vector< Bool >(1,0) ,MAX_NUM_LAYERS , "TileBoundariesAlignedFlag per direct reference for the N-th layer")1152 ("WppInUseFlag" , m_wppInUseFlag , BoolAry1d(1,0) , "WppInUseFlag ") 1153 ("TileBoundariesAlignedFlag" , m_tileBoundariesAlignedFlag , BoolAry1d(1,0) ,MAX_NUM_LAYERS , "TileBoundariesAlignedFlag per direct reference for the N-th layer") 640 1154 ("IlpRestrictedRefLayersFlag" , m_ilpRestrictedRefLayersFlag , false , "IlpRestrictedRefLayersFlag") 641 1155 ("MinSpatialSegmentOffsetPlus1", m_minSpatialSegmentOffsetPlus1, std::vector< Int >(1,0) ,MAX_NUM_LAYERS , "MinSpatialSegmentOffsetPlus1 per direct reference for the N-th layer") 642 ("CtuBasedOffsetEnabledFlag" , m_ctuBasedOffsetEnabledFlag , std::vector< Bool >(1,0) ,MAX_NUM_LAYERS , "CtuBasedOffsetEnabledFlag per direct reference for the N-th layer")1156 ("CtuBasedOffsetEnabledFlag" , m_ctuBasedOffsetEnabledFlag , BoolAry1d(1,0) ,MAX_NUM_LAYERS , "CtuBasedOffsetEnabledFlag per direct reference for the N-th layer") 643 1157 ("MinHorizontalCtuOffsetPlus1" , m_minHorizontalCtuOffsetPlus1 , std::vector< Int >(1,0) ,MAX_NUM_LAYERS , "MinHorizontalCtuOffsetPlus1 per direct reference for the N-th layer") 644 1158 ("SingleLayerForNonIrapFlag", m_singleLayerForNonIrapFlag, false , "SingleLayerForNonIrapFlag") … … 646 1160 #endif 647 1161 648 ("TransquantBypassEnableFlag", m_TransquantBypassEnableFlag, false, "transquant_bypass_enable_flag indicator in PPS") 649 ("CUTransquantBypassFlagForce", m_CUTransquantBypassFlagForce, false, "Force transquant bypass mode, when transquant_bypass_enable_flag is enabled") 650 ("RecalculateQPAccordingToLambda", m_recalculateQPAccordingToLambda, false, "Recalculate QP values according to lambda values. Do not suggest to be enabled in all intra case") 651 ("StrongIntraSmoothing,-sis", m_useStrongIntraSmoothing, true, "Enable strong intra smoothing for 32x32 blocks") 652 ("SEIActiveParameterSets", m_activeParameterSetsSEIEnabled, 0, "Enable generation of active parameter sets SEI messages") 653 ("VuiParametersPresent,-vui", m_vuiParametersPresentFlag, false, "Enable generation of vui_parameters()") 654 ("AspectRatioInfoPresent", m_aspectRatioInfoPresentFlag, false, "Signals whether aspect_ratio_idc is present") 655 ("AspectRatioIdc", m_aspectRatioIdc, 0, "aspect_ratio_idc") 656 ("SarWidth", m_sarWidth, 0, "horizontal size of the sample aspect ratio") 657 ("SarHeight", m_sarHeight, 0, "vertical size of the sample aspect ratio") 658 ("OverscanInfoPresent", m_overscanInfoPresentFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n") 659 ("OverscanAppropriate", m_overscanAppropriateFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n") 660 ("VideoSignalTypePresent", m_videoSignalTypePresentFlag, false, "Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present") 661 ("VideoFormat", m_videoFormat, 5, "Indicates representation of pictures") 662 ("VideoFullRange", m_videoFullRangeFlag, false, "Indicates the black level and range of luma and chroma signals") 663 ("ColourDescriptionPresent", m_colourDescriptionPresentFlag, false, "Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present") 664 ("ColourPrimaries", m_colourPrimaries, 2, "Indicates chromaticity coordinates of the source primaries") 665 ("TransferCharacteristics", m_transferCharacteristics, 2, "Indicates the opto-electronic transfer characteristics of the source") 666 ("MatrixCoefficients", m_matrixCoefficients, 2, "Describes the matrix coefficients used in deriving luma and chroma from RGB primaries") 667 ("ChromaLocInfoPresent", m_chromaLocInfoPresentFlag, false, "Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present") 668 ("ChromaSampleLocTypeTopField", m_chromaSampleLocTypeTopField, 0, "Specifies the location of chroma samples for top field") 669 ("ChromaSampleLocTypeBottomField", m_chromaSampleLocTypeBottomField, 0, "Specifies the location of chroma samples for bottom field") 670 ("NeutralChromaIndication", m_neutralChromaIndicationFlag, false, "Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)") 671 ("DefaultDisplayWindowFlag", m_defaultDisplayWindowFlag, false, "Indicates the presence of the Default Window parameters") 672 ("DefDispWinLeftOffset", m_defDispWinLeftOffset, 0, "Specifies the left offset of the default display window from the conformance window") 673 ("DefDispWinRightOffset", m_defDispWinRightOffset, 0, "Specifies the right offset of the default display window from the conformance window") 674 ("DefDispWinTopOffset", m_defDispWinTopOffset, 0, "Specifies the top offset of the default display window from the conformance window") 675 ("DefDispWinBottomOffset", m_defDispWinBottomOffset, 0, "Specifies the bottom offset of the default display window from the conformance window") 676 ("FrameFieldInfoPresentFlag", m_frameFieldInfoPresentFlag, false, "Indicates that pic_struct and field coding related values are present in picture timing SEI messages") 677 ("PocProportionalToTimingFlag", m_pocProportionalToTimingFlag, false, "Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS") 678 ("NumTicksPocDiffOneMinus1", m_numTicksPocDiffOneMinus1, 0, "Number of ticks minus 1 that for a POC difference of one") 679 ("BitstreamRestriction", m_bitstreamRestrictionFlag, false, "Signals whether bitstream restriction parameters are present") 680 ("TilesFixedStructure", m_tilesFixedStructureFlag, false, "Indicates that each active picture parameter set has the same values of the syntax elements related to tiles") 681 ("MotionVectorsOverPicBoundaries", m_motionVectorsOverPicBoundariesFlag, false, "Indicates that no samples outside the picture boundaries are used for inter prediction") 682 ("MaxBytesPerPicDenom", m_maxBytesPerPicDenom, 2, "Indicates a number of bytes not exceeded by the sum of the sizes of the VCL NAL units associated with any coded picture") 683 ("MaxBitsPerMinCuDenom", m_maxBitsPerMinCuDenom, 1, "Indicates an upper bound for the number of bits of coding_unit() data") 684 ("Log2MaxMvLengthHorizontal", m_log2MaxMvLengthHorizontal, 15, "Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units") 685 ("Log2MaxMvLengthVertical", m_log2MaxMvLengthVertical, 15, "Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units") 686 ("SEIRecoveryPoint", m_recoveryPointSEIEnabled, 0, "Control generation of recovery point SEI messages") 687 ("SEIBufferingPeriod", m_bufferingPeriodSEIEnabled, 0, "Control generation of buffering period SEI messages") 688 ("SEIPictureTiming", m_pictureTimingSEIEnabled, 0, "Control generation of picture timing SEI messages") 689 ("SEIToneMappingInfo", m_toneMappingInfoSEIEnabled, false, "Control generation of Tone Mapping SEI messages") 690 ("SEIToneMapId", m_toneMapId, 0, "Specifies Id of Tone Mapping SEI message for a given session") 691 ("SEIToneMapCancelFlag", m_toneMapCancelFlag, false, "Indicates that Tone Mapping SEI message cancels the persistance or follows") 692 ("SEIToneMapPersistenceFlag", m_toneMapPersistenceFlag, true, "Specifies the persistence of the Tone Mapping SEI message") 693 ("SEIToneMapCodedDataBitDepth", m_toneMapCodedDataBitDepth, 8, "Specifies Coded Data BitDepth of Tone Mapping SEI messages") 694 ("SEIToneMapTargetBitDepth", m_toneMapTargetBitDepth, 8, "Specifies Output BitDepth of Tome mapping function") 695 ("SEIToneMapModelId", m_toneMapModelId, 0, "Specifies Model utilized for mapping coded data into target_bit_depth range\n" 696 "\t0: linear mapping with clipping\n" 697 "\t1: sigmoidal mapping\n" 698 "\t2: user-defined table mapping\n" 699 "\t3: piece-wise linear mapping\n" 700 "\t4: luminance dynamic range information ") 701 ("SEIToneMapMinValue", m_toneMapMinValue, 0, "Specifies the minimum value in mode 0") 702 ("SEIToneMapMaxValue", m_toneMapMaxValue, 1023, "Specifies the maxmum value in mode 0") 703 ("SEIToneMapSigmoidMidpoint", m_sigmoidMidpoint, 512, "Specifies the centre point in mode 1") 704 ("SEIToneMapSigmoidWidth", m_sigmoidWidth, 960, "Specifies the distance between 5% and 95% values of the target_bit_depth in mode 1") 705 ("SEIToneMapStartOfCodedInterval", cfg_startOfCodedInterval, string(""), "Array of user-defined mapping table") 706 ("SEIToneMapNumPivots", m_numPivots, 0, "Specifies the number of pivot points in mode 3") 707 ("SEIToneMapCodedPivotValue", cfg_codedPivotValue, string(""), "Array of pivot point") 708 ("SEIToneMapTargetPivotValue", cfg_targetPivotValue, string(""), "Array of pivot point") 709 ("SEIToneMapCameraIsoSpeedIdc", m_cameraIsoSpeedIdc, 0, "Indicates the camera ISO speed for daylight illumination") 710 ("SEIToneMapCameraIsoSpeedValue", m_cameraIsoSpeedValue, 400, "Specifies the camera ISO speed for daylight illumination of Extended_ISO") 711 ("SEIToneMapExposureIndexIdc", m_exposureIndexIdc, 0, "Indicates the exposure index setting of the camera") 712 ("SEIToneMapExposureIndexValue", m_exposureIndexValue, 400, "Specifies the exposure index setting of the cameran of Extended_ISO") 713 ("SEIToneMapExposureCompensationValueSignFlag", m_exposureCompensationValueSignFlag, 0, "Specifies the sign of ExposureCompensationValue") 714 ("SEIToneMapExposureCompensationValueNumerator", m_exposureCompensationValueNumerator, 0, "Specifies the numerator of ExposureCompensationValue") 715 ("SEIToneMapExposureCompensationValueDenomIdc", m_exposureCompensationValueDenomIdc, 2, "Specifies the denominator of ExposureCompensationValue") 716 ("SEIToneMapRefScreenLuminanceWhite", m_refScreenLuminanceWhite, 350, "Specifies reference screen brightness setting in units of candela per square metre") 717 ("SEIToneMapExtendedRangeWhiteLevel", m_extendedRangeWhiteLevel, 800, "Indicates the luminance dynamic range") 718 ("SEIToneMapNominalBlackLevelLumaCodeValue", m_nominalBlackLevelLumaCodeValue, 16, "Specifies luma sample value of the nominal black level assigned decoded pictures") 719 ("SEIToneMapNominalWhiteLevelLumaCodeValue", m_nominalWhiteLevelLumaCodeValue, 235, "Specifies luma sample value of the nominal white level assigned decoded pictures") 720 ("SEIToneMapExtendedWhiteLevelLumaCodeValue", m_extendedWhiteLevelLumaCodeValue, 300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures") 721 ("SEIFramePacking", m_framePackingSEIEnabled, 0, "Control generation of frame packing SEI messages") 722 ("SEIFramePackingType", m_framePackingSEIType, 0, "Define frame packing arrangement\n" 723 "\t0: checkerboard - pixels alternatively represent either frames\n" 724 "\t1: column alternation - frames are interlaced by column\n" 725 "\t2: row alternation - frames are interlaced by row\n" 726 "\t3: side by side - frames are displayed horizontally\n" 727 "\t4: top bottom - frames are displayed vertically\n" 728 "\t5: frame alternation - one frame is alternated with the other") 729 ("SEIFramePackingId", m_framePackingSEIId, 0, "Id of frame packing SEI message for a given session") 730 ("SEIFramePackingQuincunx", m_framePackingSEIQuincunx, 0, "Indicate the presence of a Quincunx type video frame") 731 ("SEIFramePackingInterpretation", m_framePackingSEIInterpretation, 0, "Indicate the interpretation of the frame pair\n" 732 "\t0: unspecified\n" 733 "\t1: stereo pair, frame0 represents left view\n" 734 "\t2: stereo pair, frame0 represents right view") 735 ("SEIDisplayOrientation", m_displayOrientationSEIAngle, 0, "Control generation of display orientation SEI messages\n" 736 "\tN: 0 < N < (2^16 - 1) enable display orientation SEI message with anticlockwise_rotation = N and display_orientation_repetition_period = 1\n" 737 "\t0: disable") 738 ("SEITemporalLevel0Index", m_temporalLevel0IndexSEIEnabled, 0, "Control generation of temporal level 0 index SEI messages") 739 ("SEIGradualDecodingRefreshInfo", m_gradualDecodingRefreshInfoEnabled, 0, "Control generation of gradual decoding refresh information SEI message") 740 ("SEIDecodingUnitInfo", m_decodingUnitInfoSEIEnabled, 0, "Control generation of decoding unit information SEI message.") 741 ("SEISOPDescription", m_SOPDescriptionSEIEnabled, 0, "Control generation of SOP description SEI messages") 742 ("SEIScalableNesting", m_scalableNestingSEIEnabled, 0, "Control generation of scalable nesting SEI messages") 743 #if H_MV 744 ("SubBitstreamPropSEIEnabled", m_subBistreamPropSEIEnabled, false ,"Enable signaling of sub-bitstream property SEI message") 745 ("SEISubBitstreamNumAdditionalSubStreams", m_sbPropNumAdditionalSubStreams,0, "Number of substreams for which additional information is signalled") 746 ("SEISubBitstreamSubBitstreamMode", m_sbPropSubBitstreamMode, std::vector< Int >(1,0) ,"Specifies mode of generation of the i-th sub-bitstream (0 or 1)") 747 ("SEISubBitstreamOutputLayerSetIdxToVps", m_sbPropOutputLayerSetIdxToVps, std::vector< Int >(1,0) ,"Specifies output layer set index of the i-th sub-bitstream ") 748 ("SEISubBitstreamHighestSublayerId", m_sbPropHighestSublayerId, std::vector< Int >(1,0) ,"Specifies highest TemporalId of the i-th sub-bitstream") 749 ("SEISubBitstreamAvgBitRate", m_sbPropAvgBitRate, std::vector< Int >(1,0) ,"Specifies average bit rate of the i-th sub-bitstream") 750 ("SEISubBitstreamMaxBitRate", m_sbPropMaxBitRate, std::vector< Int >(1,0) ,"Specifies maximum bit rate of the i-th sub-bitstream") 751 752 ("OutputVpsInfo", m_outputVpsInfo, false ,"Output information about the layer dependencies and layer sets") 753 #endif 754 #if H_3D 755 ("CameraParameterFile,cpf", m_pchCameraParameterFile, (Char *) 0, "Camera Parameter File Name") 756 ("BaseViewCameraNumbers" , m_pchBaseViewCameraNumbers, (Char *) 0, "Numbers of base views") 757 ("CodedCamParsPrecision", m_iCodedCamParPrecision, STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" ) 758 /* View Synthesis Optimization */ 759 760 #if H_3D_VSO 761 ("VSOConfig", m_pchVSOConfig , (Char *) 0 , "VSO configuration") 762 ("VSO", m_bUseVSO , false , "Use VSO" ) 763 ("VSOMode", m_uiVSOMode , (UInt) 4 , "VSO Mode") 764 ("LambdaScaleVSO", m_dLambdaScaleVSO , (Double) 1 , "Lambda Scaling for VSO") 765 ("VSOLSTable", m_bVSOLSTable , true , "Depth QP dependent video/depth rate allocation by Lagrange multiplier" ) 766 ("ForceLambdaScaleVSO", m_bForceLambdaScaleVSO , false , "Force using Lambda Scale VSO also in non-VSO-Mode") 767 ("AllowNegDist", m_bAllowNegDist , true , "Allow negative Distortion in VSO") 768 769 ("UseEstimatedVSD", m_bUseEstimatedVSD , true , "Model based VSD estimation instead of rendering based for some encoder decisions" ) 770 ("VSOEarlySkip", m_bVSOEarlySkip , true , "Early skip of VSO computation if synthesis error assumed to be zero" ) 771 772 ("WVSO", m_bUseWVSO , true , "Use depth fidelity term for VSO" ) 773 ("VSOWeight", m_iVSOWeight , 10 , "Synthesized View Distortion Change weight" ) 774 ("VSDWeight", m_iVSDWeight , 1 , "View Synthesis Distortion estimate weight" ) 775 ("DWeight", m_iDWeight , 1 , "Depth Distortion weight" ) 776 1162 ("TransquantBypassEnableFlag", m_TransquantBypassEnableFlag, false, "transquant_bypass_enable_flag indicator in PPS") 1163 ("CUTransquantBypassFlagForce", m_CUTransquantBypassFlagForce, false, "Force transquant bypass mode, when transquant_bypass_enable_flag is enabled") 1164 ("CostMode", m_costMode, COST_STANDARD_LOSSY, "Use alternative cost functions: choose between 'lossy', 'sequence_level_lossless', 'lossless' (which forces QP to " MACRO_TO_STRING(LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP) ") and 'mixed_lossless_lossy' (which used QP'=" MACRO_TO_STRING(LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME) " for pre-estimates of transquant-bypass blocks).") 1165 ("RecalculateQPAccordingToLambda", m_recalculateQPAccordingToLambda, false, "Recalculate QP values according to lambda values. Do not suggest to be enabled in all intra case") 1166 ("StrongIntraSmoothing,-sis", m_useStrongIntraSmoothing, true, "Enable strong intra smoothing for 32x32 blocks") 1167 ("SEIActiveParameterSets", m_activeParameterSetsSEIEnabled, 0, "Enable generation of active parameter sets SEI messages") 1168 ("VuiParametersPresent,-vui", m_vuiParametersPresentFlag, false, "Enable generation of vui_parameters()") 1169 ("AspectRatioInfoPresent", m_aspectRatioInfoPresentFlag, false, "Signals whether aspect_ratio_idc is present") 1170 ("AspectRatioIdc", m_aspectRatioIdc, 0, "aspect_ratio_idc") 1171 ("SarWidth", m_sarWidth, 0, "horizontal size of the sample aspect ratio") 1172 ("SarHeight", m_sarHeight, 0, "vertical size of the sample aspect ratio") 1173 ("OverscanInfoPresent", m_overscanInfoPresentFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n") 1174 ("OverscanAppropriate", m_overscanAppropriateFlag, false, "Indicates whether conformant decoded pictures are suitable for display using overscan\n") 1175 ("VideoSignalTypePresent", m_videoSignalTypePresentFlag, false, "Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present") 1176 ("VideoFormat", m_videoFormat, 5, "Indicates representation of pictures") 1177 ("VideoFullRange", m_videoFullRangeFlag, false, "Indicates the black level and range of luma and chroma signals") 1178 ("ColourDescriptionPresent", m_colourDescriptionPresentFlag, false, "Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present") 1179 ("ColourPrimaries", m_colourPrimaries, 2, "Indicates chromaticity coordinates of the source primaries") 1180 ("TransferCharacteristics", m_transferCharacteristics, 2, "Indicates the opto-electronic transfer characteristics of the source") 1181 ("MatrixCoefficients", m_matrixCoefficients, 2, "Describes the matrix coefficients used in deriving luma and chroma from RGB primaries") 1182 ("ChromaLocInfoPresent", m_chromaLocInfoPresentFlag, false, "Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present") 1183 ("ChromaSampleLocTypeTopField", m_chromaSampleLocTypeTopField, 0, "Specifies the location of chroma samples for top field") 1184 ("ChromaSampleLocTypeBottomField", m_chromaSampleLocTypeBottomField, 0, "Specifies the location of chroma samples for bottom field") 1185 ("NeutralChromaIndication", m_neutralChromaIndicationFlag, false, "Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)") 1186 ("DefaultDisplayWindowFlag", m_defaultDisplayWindowFlag, false, "Indicates the presence of the Default Window parameters") 1187 ("DefDispWinLeftOffset", m_defDispWinLeftOffset, 0, "Specifies the left offset of the default display window from the conformance window") 1188 ("DefDispWinRightOffset", m_defDispWinRightOffset, 0, "Specifies the right offset of the default display window from the conformance window") 1189 ("DefDispWinTopOffset", m_defDispWinTopOffset, 0, "Specifies the top offset of the default display window from the conformance window") 1190 ("DefDispWinBottomOffset", m_defDispWinBottomOffset, 0, "Specifies the bottom offset of the default display window from the conformance window") 1191 ("FrameFieldInfoPresentFlag", m_frameFieldInfoPresentFlag, false, "Indicates that pic_struct and field coding related values are present in picture timing SEI messages") 1192 ("PocProportionalToTimingFlag", m_pocProportionalToTimingFlag, false, "Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS") 1193 ("NumTicksPocDiffOneMinus1", m_numTicksPocDiffOneMinus1, 0, "Number of ticks minus 1 that for a POC difference of one") 1194 ("BitstreamRestriction", m_bitstreamRestrictionFlag, false, "Signals whether bitstream restriction parameters are present") 1195 ("TilesFixedStructure", m_tilesFixedStructureFlag, false, "Indicates that each active picture parameter set has the same values of the syntax elements related to tiles") 1196 ("MotionVectorsOverPicBoundaries", m_motionVectorsOverPicBoundariesFlag, false, "Indicates that no samples outside the picture boundaries are used for inter prediction") 1197 ("MaxBytesPerPicDenom", m_maxBytesPerPicDenom, 2, "Indicates a number of bytes not exceeded by the sum of the sizes of the VCL NAL units associated with any coded picture") 1198 ("MaxBitsPerMinCuDenom", m_maxBitsPerMinCuDenom, 1, "Indicates an upper bound for the number of bits of coding_unit() data") 1199 ("Log2MaxMvLengthHorizontal", m_log2MaxMvLengthHorizontal, 15, "Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units") 1200 ("Log2MaxMvLengthVertical", m_log2MaxMvLengthVertical, 15, "Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units") 1201 ("SEIRecoveryPoint", m_recoveryPointSEIEnabled, 0, "Control generation of recovery point SEI messages") 1202 ("SEIBufferingPeriod", m_bufferingPeriodSEIEnabled, 0, "Control generation of buffering period SEI messages") 1203 ("SEIPictureTiming", m_pictureTimingSEIEnabled, 0, "Control generation of picture timing SEI messages") 1204 ("SEIToneMappingInfo", m_toneMappingInfoSEIEnabled, false, "Control generation of Tone Mapping SEI messages") 1205 ("SEIToneMapId", m_toneMapId, 0, "Specifies Id of Tone Mapping SEI message for a given session") 1206 ("SEIToneMapCancelFlag", m_toneMapCancelFlag, false, "Indicates that Tone Mapping SEI message cancels the persistence or follows") 1207 ("SEIToneMapPersistenceFlag", m_toneMapPersistenceFlag, true, "Specifies the persistence of the Tone Mapping SEI message") 1208 ("SEIToneMapCodedDataBitDepth", m_toneMapCodedDataBitDepth, 8, "Specifies Coded Data BitDepth of Tone Mapping SEI messages") 1209 ("SEIToneMapTargetBitDepth", m_toneMapTargetBitDepth, 8, "Specifies Output BitDepth of Tone mapping function") 1210 ("SEIToneMapModelId", m_toneMapModelId, 0, "Specifies Model utilized for mapping coded data into target_bit_depth range\n" 1211 "\t0: linear mapping with clipping\n" 1212 "\t1: sigmoidal mapping\n" 1213 "\t2: user-defined table mapping\n" 1214 "\t3: piece-wise linear mapping\n" 1215 "\t4: luminance dynamic range information ") 1216 ("SEIToneMapMinValue", m_toneMapMinValue, 0, "Specifies the minimum value in mode 0") 1217 ("SEIToneMapMaxValue", m_toneMapMaxValue, 1023, "Specifies the maximum value in mode 0") 1218 ("SEIToneMapSigmoidMidpoint", m_sigmoidMidpoint, 512, "Specifies the centre point in mode 1") 1219 ("SEIToneMapSigmoidWidth", m_sigmoidWidth, 960, "Specifies the distance between 5% and 95% values of the target_bit_depth in mode 1") 1220 ("SEIToneMapStartOfCodedInterval", cfg_startOfCodedInterval, cfg_startOfCodedInterval, "Array of user-defined mapping table") 1221 ("SEIToneMapNumPivots", m_numPivots, 0, "Specifies the number of pivot points in mode 3") 1222 ("SEIToneMapCodedPivotValue", cfg_codedPivotValue, cfg_codedPivotValue, "Array of pivot point") 1223 ("SEIToneMapTargetPivotValue", cfg_targetPivotValue, cfg_targetPivotValue, "Array of pivot point") 1224 ("SEIToneMapCameraIsoSpeedIdc", m_cameraIsoSpeedIdc, 0, "Indicates the camera ISO speed for daylight illumination") 1225 ("SEIToneMapCameraIsoSpeedValue", m_cameraIsoSpeedValue, 400, "Specifies the camera ISO speed for daylight illumination of Extended_ISO") 1226 ("SEIToneMapExposureIndexIdc", m_exposureIndexIdc, 0, "Indicates the exposure index setting of the camera") 1227 ("SEIToneMapExposureIndexValue", m_exposureIndexValue, 400, "Specifies the exposure index setting of the camera of Extended_ISO") 1228 ("SEIToneMapExposureCompensationValueSignFlag", m_exposureCompensationValueSignFlag, false, "Specifies the sign of ExposureCompensationValue") 1229 ("SEIToneMapExposureCompensationValueNumerator", m_exposureCompensationValueNumerator, 0, "Specifies the numerator of ExposureCompensationValue") 1230 ("SEIToneMapExposureCompensationValueDenomIdc", m_exposureCompensationValueDenomIdc, 2, "Specifies the denominator of ExposureCompensationValue") 1231 ("SEIToneMapRefScreenLuminanceWhite", m_refScreenLuminanceWhite, 350, "Specifies reference screen brightness setting in units of candela per square metre") 1232 ("SEIToneMapExtendedRangeWhiteLevel", m_extendedRangeWhiteLevel, 800, "Indicates the luminance dynamic range") 1233 ("SEIToneMapNominalBlackLevelLumaCodeValue", m_nominalBlackLevelLumaCodeValue, 16, "Specifies luma sample value of the nominal black level assigned decoded pictures") 1234 ("SEIToneMapNominalWhiteLevelLumaCodeValue", m_nominalWhiteLevelLumaCodeValue, 235, "Specifies luma sample value of the nominal white level assigned decoded pictures") 1235 ("SEIToneMapExtendedWhiteLevelLumaCodeValue", m_extendedWhiteLevelLumaCodeValue, 300, "Specifies luma sample value of the extended dynamic range assigned decoded pictures") 1236 ("SEIChromaSamplingFilterHint", m_chromaSamplingFilterSEIenabled, false, "Control generation of the chroma sampling filter hint SEI message") 1237 ("SEIChromaSamplingHorizontalFilterType", m_chromaSamplingHorFilterIdc, 2, "Defines the Index of the chroma sampling horizontal filter\n" 1238 "\t0: unspecified - Chroma filter is unknown or is determined by the application" 1239 "\t1: User-defined - Filter coefficients are specified in the chroma sampling filter hint SEI message" 1240 "\t2: Standards-defined - ITU-T Rec. T.800 | ISO/IEC15444-1, 5/3 filter") 1241 ("SEIChromaSamplingVerticalFilterType", m_chromaSamplingVerFilterIdc, 2, "Defines the Index of the chroma sampling vertical filter\n" 1242 "\t0: unspecified - Chroma filter is unknown or is determined by the application" 1243 "\t1: User-defined - Filter coefficients are specified in the chroma sampling filter hint SEI message" 1244 "\t2: Standards-defined - ITU-T Rec. T.800 | ISO/IEC15444-1, 5/3 filter") 1245 ("SEIFramePacking", m_framePackingSEIEnabled, 0, "Control generation of frame packing SEI messages") 1246 ("SEIFramePackingType", m_framePackingSEIType, 0, "Define frame packing arrangement\n" 1247 "\t3: side by side - frames are displayed horizontally\n" 1248 "\t4: top bottom - frames are displayed vertically\n" 1249 "\t5: frame alternation - one frame is alternated with the other") 1250 ("SEIFramePackingId", m_framePackingSEIId, 0, "Id of frame packing SEI message for a given session") 1251 ("SEIFramePackingQuincunx", m_framePackingSEIQuincunx, 0, "Indicate the presence of a Quincunx type video frame") 1252 ("SEIFramePackingInterpretation", m_framePackingSEIInterpretation, 0, "Indicate the interpretation of the frame pair\n" 1253 "\t0: unspecified\n" 1254 "\t1: stereo pair, frame0 represents left view\n" 1255 "\t2: stereo pair, frame0 represents right view") 1256 ("SEISegmentedRectFramePacking", m_segmentedRectFramePackingSEIEnabled, 0, "Controls generation of segmented rectangular frame packing SEI messages") 1257 ("SEISegmentedRectFramePackingCancel", m_segmentedRectFramePackingSEICancel, false, "If equal to 1, cancels the persistence of any previous SRFPA SEI message") 1258 ("SEISegmentedRectFramePackingType", m_segmentedRectFramePackingSEIType, 0, "Specifies the arrangement of the frames in the reconstructed picture") 1259 ("SEISegmentedRectFramePackingPersistence", m_segmentedRectFramePackingSEIPersistence, false, "If equal to 0, the SEI applies to the current frame only") 1260 ("SEIDisplayOrientation", m_displayOrientationSEIAngle, 0, "Control generation of display orientation SEI messages\n" 1261 "\tN: 0 < N < (2^16 - 1) enable display orientation SEI message with anticlockwise_rotation = N and display_orientation_repetition_period = 1\n" 1262 "\t0: disable") 1263 ("SEITemporalLevel0Index", m_temporalLevel0IndexSEIEnabled, 0, "Control generation of temporal level 0 index SEI messages") 1264 ("SEIGradualDecodingRefreshInfo", m_gradualDecodingRefreshInfoEnabled, 0, "Control generation of gradual decoding refresh information SEI message") 1265 ("SEINoDisplay", m_noDisplaySEITLayer, 0, "Control generation of no display SEI message\n" 1266 "\tN: 0 < N enable no display SEI message for temporal layer N or higher\n" 1267 "\t0: disable") 1268 ("SEIDecodingUnitInfo", m_decodingUnitInfoSEIEnabled, 0, "Control generation of decoding unit information SEI message.") 1269 ("SEISOPDescription", m_SOPDescriptionSEIEnabled, 0, "Control generation of SOP description SEI messages") 1270 ("SEIScalableNesting", m_scalableNestingSEIEnabled, 0, "Control generation of scalable nesting SEI messages") 1271 ("SEITempMotionConstrainedTileSets", m_tmctsSEIEnabled, false, "Control generation of temporal motion constrained tile sets SEI message") 1272 ("SEITimeCodeEnabled", m_timeCodeSEIEnabled, false, "Control generation of time code information SEI message") 1273 ("SEITimeCodeNumClockTs", m_timeCodeSEINumTs, 0, "Number of clock time sets [0..3]") 1274 ("SEITimeCodeTimeStampFlag", cfg_timeCodeSeiTimeStampFlag, cfg_timeCodeSeiTimeStampFlag, "Time stamp flag associated to each time set") 1275 ("SEITimeCodeFieldBasedFlag", cfg_timeCodeSeiNumUnitFieldBasedFlag, cfg_timeCodeSeiNumUnitFieldBasedFlag, "Field based flag associated to each time set") 1276 ("SEITimeCodeCountingType", cfg_timeCodeSeiCountingType, cfg_timeCodeSeiCountingType, "Counting type associated to each time set") 1277 ("SEITimeCodeFullTsFlag", cfg_timeCodeSeiFullTimeStampFlag, cfg_timeCodeSeiFullTimeStampFlag, "Full time stamp flag associated to each time set") 1278 ("SEITimeCodeDiscontinuityFlag", cfg_timeCodeSeiDiscontinuityFlag, cfg_timeCodeSeiDiscontinuityFlag, "Discontinuity flag associated to each time set") 1279 ("SEITimeCodeCntDroppedFlag", cfg_timeCodeSeiCntDroppedFlag, cfg_timeCodeSeiCntDroppedFlag, "Counter dropped flag associated to each time set") 1280 ("SEITimeCodeNumFrames", cfg_timeCodeSeiNumberOfFrames, cfg_timeCodeSeiNumberOfFrames, "Number of frames associated to each time set") 1281 ("SEITimeCodeSecondsValue", cfg_timeCodeSeiSecondsValue, cfg_timeCodeSeiSecondsValue, "Seconds value for each time set") 1282 ("SEITimeCodeMinutesValue", cfg_timeCodeSeiMinutesValue, cfg_timeCodeSeiMinutesValue, "Minutes value for each time set") 1283 ("SEITimeCodeHoursValue", cfg_timeCodeSeiHoursValue, cfg_timeCodeSeiHoursValue, "Hours value for each time set") 1284 ("SEITimeCodeSecondsFlag", cfg_timeCodeSeiSecondsFlag, cfg_timeCodeSeiSecondsFlag, "Flag to signal seconds value presence in each time set") 1285 ("SEITimeCodeMinutesFlag", cfg_timeCodeSeiMinutesFlag, cfg_timeCodeSeiMinutesFlag, "Flag to signal minutes value presence in each time set") 1286 ("SEITimeCodeHoursFlag", cfg_timeCodeSeiHoursFlag, cfg_timeCodeSeiHoursFlag, "Flag to signal hours value presence in each time set") 1287 ("SEITimeCodeOffsetLength", cfg_timeCodeSeiTimeOffsetLength, cfg_timeCodeSeiTimeOffsetLength, "Time offset length associated to each time set") 1288 ("SEITimeCodeTimeOffset", cfg_timeCodeSeiTimeOffsetValue, cfg_timeCodeSeiTimeOffsetValue, "Time offset associated to each time set") 1289 ("SEIKneeFunctionInfo", m_kneeSEIEnabled, false, "Control generation of Knee function SEI messages") 1290 ("SEIKneeFunctionId", m_kneeSEIId, 0, "Specifies Id of Knee function SEI message for a given session") 1291 ("SEIKneeFunctionCancelFlag", m_kneeSEICancelFlag, false, "Indicates that Knee function SEI message cancels the persistence or follows") 1292 ("SEIKneeFunctionPersistenceFlag", m_kneeSEIPersistenceFlag, true, "Specifies the persistence of the Knee function SEI message") 1293 ("SEIKneeFunctionInputDrange", m_kneeSEIInputDrange, 1000, "Specifies the peak luminance level for the input picture of Knee function SEI messages") 1294 ("SEIKneeFunctionInputDispLuminance", m_kneeSEIInputDispLuminance, 100, "Specifies the expected display brightness for the input picture of Knee function SEI messages") 1295 ("SEIKneeFunctionOutputDrange", m_kneeSEIOutputDrange, 4000, "Specifies the peak luminance level for the output picture of Knee function SEI messages") 1296 ("SEIKneeFunctionOutputDispLuminance", m_kneeSEIOutputDispLuminance, 800, "Specifies the expected display brightness for the output picture of Knee function SEI messages") 1297 ("SEIKneeFunctionNumKneePointsMinus1", m_kneeSEINumKneePointsMinus1, 2, "Specifies the number of knee points - 1") 1298 ("SEIKneeFunctionInputKneePointValue", cfg_kneeSEIInputKneePointValue, cfg_kneeSEIInputKneePointValue, "Array of input knee point") 1299 ("SEIKneeFunctionOutputKneePointValue", cfg_kneeSEIOutputKneePointValue, cfg_kneeSEIOutputKneePointValue, "Array of output knee point") 1300 ("SEIMasteringDisplayColourVolume", m_masteringDisplay.colourVolumeSEIEnabled, false, "Control generation of mastering display colour volume SEI messages") 1301 ("SEIMasteringDisplayMaxLuminance", m_masteringDisplay.maxLuminance, 10000u, "Specifies the mastering display maximum luminance value in units of 1/10000 candela per square metre (32-bit code value)") 1302 ("SEIMasteringDisplayMinLuminance", m_masteringDisplay.minLuminance, 0u, "Specifies the mastering display minimum luminance value in units of 1/10000 candela per square metre (32-bit code value)") 1303 ("SEIMasteringDisplayPrimaries", cfg_DisplayPrimariesCode, cfg_DisplayPrimariesCode, "Mastering display primaries for all three colour planes in CIE xy coordinates in increments of 1/50000 (results in the ranges 0 to 50000 inclusive)") 1304 ("SEIMasteringDisplayWhitePoint", cfg_DisplayWhitePointCode, cfg_DisplayWhitePointCode, "Mastering display white point CIE xy coordinates in normalised increments of 1/50000 (e.g. 0.333 = 16667)") 1305 #if NH_MV 1306 ("SubBitstreamPropSEIEnabled", m_subBistreamPropSEIEnabled, false ,"Enable signaling of sub-bitstream property SEI message") 1307 ("SEISubBitstreamNumAdditionalSubStreams", m_sbPropNumAdditionalSubStreams,0 ,"Number of substreams for which additional information is signalled") 1308 ("SEISubBitstreamSubBitstreamMode", m_sbPropSubBitstreamMode, std::vector< Int >(1,0) ,"Specifies mode of generation of the i-th sub-bitstream (0 or 1)") 1309 ("SEISubBitstreamOutputLayerSetIdxToVps", m_sbPropOutputLayerSetIdxToVps, std::vector< Int >(1,0) ,"Specifies output layer set index of the i-th sub-bitstream ") 1310 ("SEISubBitstreamHighestSublayerId", m_sbPropHighestSublayerId, std::vector< Int >(1,0) ,"Specifies highest TemporalId of the i-th sub-bitstream") 1311 ("SEISubBitstreamAvgBitRate", m_sbPropAvgBitRate, std::vector< Int >(1,0) ,"Specifies average bit rate of the i-th sub-bitstream") 1312 ("SEISubBitstreamMaxBitRate", m_sbPropMaxBitRate, std::vector< Int >(1,0) ,"Specifies maximum bit rate of the i-th sub-bitstream") 1313 1314 ("OutputVpsInfo", m_outputVpsInfo, false ,"Output information about the layer dependencies and layer sets") 1315 #endif 1316 #if NH_3D 1317 /* Camera parameters */ 1318 ("Depth420OutputFlag", m_depth420OutputFlag, true , "Output depth layers in 4:2:0 ") 1319 ("CameraParameterFile,cpf", m_pchCameraParameterFile, (Char *) 0, "Camera Parameter File Name") 1320 ("BaseViewCameraNumbers", m_pchBaseViewCameraNumbers, (Char *) 0, "Numbers of base views") 1321 ("CodedCamParsPrecision", m_iCodedCamParPrecision, STD_CAM_PARAMETERS_PRECISION, "precision for coding of camera parameters (in units of 2^(-x) luma samples)" ) 1322 1323 #if NH_3D_VSO 1324 /* View Synthesis Optimization */ 1325 ("VSOConfig", m_pchVSOConfig , (Char *) 0 ,"VSO configuration") 1326 ("VSO", m_bUseVSO , false ,"Use VSO" ) 1327 ("VSOMode", m_uiVSOMode , (UInt) 4 ,"VSO Mode") 1328 ("LambdaScaleVSO", m_dLambdaScaleVSO , (Double) 1 ,"Lambda Scaling for VSO") 1329 ("VSOLSTable", m_bVSOLSTable , true ,"Depth QP dependent video/depth rate allocation by Lagrange multiplier" ) 1330 ("ForceLambdaScaleVSO", m_bForceLambdaScaleVSO , false ,"Force using Lambda Scale VSO also in non-VSO-Mode") 1331 ("AllowNegDist", m_bAllowNegDist , true ,"Allow negative Distortion in VSO") 1332 1333 ("UseEstimatedVSD", m_bUseEstimatedVSD , true ,"Model based VSD estimation instead of rendering based for some encoder decisions" ) 1334 ("VSOEarlySkip", m_bVSOEarlySkip , true ,"Early skip of VSO computation if synthesis error assumed to be zero" ) 1335 1336 ("WVSO", m_bUseWVSO , true ,"Use depth fidelity term for VSO" ) 1337 ("VSOWeight", m_iVSOWeight , 10 ,"Synthesized View Distortion Change weight" ) 1338 ("VSDWeight", m_iVSDWeight , 1 ,"View Synthesis Distortion estimate weight" ) 1339 ("DWeight", m_iDWeight , 1 ,"Depth Distortion weight" ) 777 1340 #endif //HHI_VSO 778 ("QTL", m_bUseQTL , true , "Use depth quad tree limitation (encoder only)" ) 779 780 ("IvMvPredFlag" , m_ivMvPredFlag , std::vector< Bool >(2,true) , "Inter-view motion prediction" ) 781 ("IvMvScalingFlag" , m_ivMvScalingFlag , std::vector< Bool >(2,true) , "Inter-view motion vector scaling" ) 782 ("Log2SubPbSizeMinus3" , m_log2SubPbSizeMinus3 , 0 , "Log2 minus 3 of sub Pb size" ) 783 ("IvResPredFlag" , m_ivResPredFlag , true , "Inter-view residual prediction" ) 784 ("DepthRefinementFlag" , m_depthRefinementFlag , true , "Depth to refine disparity" ) 785 ("ViewSynthesisPredFlag" , m_viewSynthesisPredFlag , true , "View synthesis prediction" ) 786 ("DepthBasedBlkPartFlag" , m_depthBasedBlkPartFlag , true , "Depth base block partitioning" ) 787 ("MpiFlag" , m_mpiFlag , true , "Motion inheritance from texture to depth" ) 788 ("Log2MpiSubPbSizeMinus3", m_log2MpiSubPbSizeMinus3, 0 , "Log2 minus 3 of sub Pb size for MPI" ) 789 ("IntraContourFlag" , m_intraContourFlag , true , "Intra contour mode" ) 790 ("IntraWedgeFlag" , m_intraWedgeFlag , true , "Intra wedge mode and segmental depth DCs" ) 791 ("IntraSdcFlag" , m_intraSdcFlag , true , "Intra depth DCs" ) 792 ("QtPredFlag" , m_qtPredFlag , true , "Quad tree prediction from texture to depth") 793 ("InterSdcFlag" , m_interSdcFlag , true , "Inter depth DCs" ) 794 ("DepthIntraSkip" , m_depthIntraSkipFlag , true , "Depth intra skip mode" ) 1341 /* 3D- HEVC Tools */ 1342 ("QTL" , m_bUseQTL , true , "Use depth quad tree limitation (encoder only)" ) 1343 ("IvMvPredFlag" , m_ivMvPredFlag , BoolAry1d(2,true) , "Inter-view motion prediction" ) 1344 ("IvMvScalingFlag" , m_ivMvScalingFlag , BoolAry1d(2,true) , "Inter-view motion vector scaling" ) 1345 ("Log2SubPbSizeMinus3" , m_log2SubPbSizeMinus3 , 0 , "Log2 minus 3 of sub Pb size" ) 1346 ("IvResPredFlag" , m_ivResPredFlag , true , "Inter-view residual prediction" ) 1347 ("DepthRefinementFlag" , m_depthRefinementFlag , true , "Depth to refine disparity" ) 1348 ("ViewSynthesisPredFlag" , m_viewSynthesisPredFlag , true , "View synthesis prediction" ) 1349 ("DepthBasedBlkPartFlag" , m_depthBasedBlkPartFlag , true , "Depth base block partitioning" ) 1350 ("MpiFlag" , m_mpiFlag , true , "Motion inheritance from texture to depth" ) 1351 ("Log2MpiSubPbSizeMinus3", m_log2MpiSubPbSizeMinus3 , 0 , "Log2 minus 3 of sub Pb size for MPI" ) 1352 ("IntraContourFlag" , m_intraContourFlag , true , "Intra contour mode" ) 1353 ("IntraWedgeFlag" , m_intraWedgeFlag , true , "Intra wedge mode and segmental depth DCs" ) 1354 ("IntraSdcFlag" , m_intraSdcFlag , true , "Intra depth DCs" ) 1355 ("QtPredFlag" , m_qtPredFlag , true , "Quad tree prediction from texture to depth") 1356 ("InterSdcFlag" , m_interSdcFlag , true , "Inter depth DCs" ) 1357 ("DepthIntraSkip" , m_depthIntraSkipFlag , true , "Depth intra skip mode" ) 1358 ("DLT" , m_useDLT , true , "Depth lookup table" ) 1359 ("IlluCompEnable" , m_abUseIC , true , "Enable illumination compensation" ) 1360 ("IlluCompLowLatencyEnc" , m_bUseLowLatencyICEnc , false , "Enable low-latency illumination compensation encoding") 795 1361 #endif //H_3D 1362 796 1363 ; 797 1364 798 #if H_MV1365 #if NH_MV 799 1366 // parse coding structure 800 1367 for( Int k = 0; k < MAX_NUM_LAYERS; k++ ) … … 827 1394 828 1395 829 for( Int i = 1; i < MAX_GOP + 1; i++ )830 1396 for(Int i=1; i<MAX_GOP+1; i++) 1397 { 831 1398 std::ostringstream cOSS2; 832 1399 cOSS2<<"Frame"<<i<<"_l"<<k; … … 840 1407 } 841 1408 #else 842 for(Int i=1; i<MAX_GOP+1; i++) { 1409 for(Int i=1; i<MAX_GOP+1; i++) 1410 { 843 1411 std::ostringstream cOSS; 844 1412 cOSS<<"Frame"<<i; … … 847 1415 #endif 848 1416 po::setDefaults(opts); 849 const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv); 1417 po::ErrorReporter err; 1418 const list<const Char*>& argv_unhandled = po::scanArgv(opts, argc, (const Char**) argv, err); 1419 1420 for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++) 1421 { 1422 fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it); 1423 } 1424 1425 if (argc == 1 || do_help) 1426 { 1427 /* argc == 1: no options have been specified */ 1428 po::doHelp(cout, opts); 1429 return false; 1430 } 1431 1432 if (err.is_errored) 1433 { 1434 if (!warnUnknowParameter) 1435 { 1436 /* error report has already been printed on stderr */ 1437 return false; 1438 } 1439 } 1440 1441 /* 1442 * Set any derived parameters 1443 */ 1444 /* convert std::string to c string for compatability */ 1445 #if !NH_MV 1446 m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str()); 1447 #endif 1448 m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str()); 1449 #if !NH_MV 1450 m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str()); 1451 #endif 1452 m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str()); 850 1453 851 1454 if(m_isField) … … 858 1461 m_framesToBeEncoded *= 2; 859 1462 } 860 861 for (list<const Char*>::const_iterator it = argv_unhandled.begin(); it != argv_unhandled.end(); it++)862 {863 fprintf(stderr, "Unhandled argument ignored: `%s'\n", *it);864 }865 866 if (argc == 1 || do_help)867 {868 /* argc == 1: no options have been specified */869 po::doHelp(cout, opts);870 return false;871 }872 873 /*874 * Set any derived parameters875 */876 /* convert std::string to c string for compatability */877 #if !H_MV878 m_pchInputFile = cfg_InputFile.empty() ? NULL : strdup(cfg_InputFile.c_str());879 #endif880 m_pchBitstreamFile = cfg_BitstreamFile.empty() ? NULL : strdup(cfg_BitstreamFile.c_str());881 #if !H_MV882 m_pchReconFile = cfg_ReconFile.empty() ? NULL : strdup(cfg_ReconFile.c_str());883 #endif884 m_pchdQPFile = cfg_dQPFile.empty() ? NULL : strdup(cfg_dQPFile.c_str());885 886 Char* pColumnWidth = cfgColumnWidth.empty() ? NULL: strdup(cfgColumnWidth.c_str());887 Char* pRowHeight = cfgRowHeight.empty() ? NULL : strdup(cfgRowHeight.c_str());888 1463 889 1464 if( !m_tileUniformSpacingFlag && m_numTileColumnsMinus1 > 0 ) 890 1465 { 891 char *str; 892 int i=0; 893 m_tileColumnWidth.resize( m_numTileColumnsMinus1 ); 894 str = strtok(pColumnWidth, " ,-"); 895 while(str!=NULL) 896 { 897 if( i >= m_numTileColumnsMinus1 ) 898 { 899 printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" ); 900 exit( EXIT_FAILURE ); 901 } 902 m_tileColumnWidth[i] = atoi( str ); 903 str = strtok(NULL, " ,-"); 904 i++; 905 } 906 if( i < m_numTileColumnsMinus1 ) 1466 if (cfg_ColumnWidth.values.size() > m_numTileColumnsMinus1) 1467 { 1468 printf( "The number of columns whose width are defined is larger than the allowed number of columns.\n" ); 1469 exit( EXIT_FAILURE ); 1470 } 1471 else if (cfg_ColumnWidth.values.size() < m_numTileColumnsMinus1) 907 1472 { 908 1473 printf( "The width of some columns is not defined.\n" ); 909 1474 exit( EXIT_FAILURE ); 910 1475 } 1476 else 1477 { 1478 m_tileColumnWidth.resize(m_numTileColumnsMinus1); 1479 for(UInt i=0; i<cfg_ColumnWidth.values.size(); i++) 1480 { 1481 m_tileColumnWidth[i]=cfg_ColumnWidth.values[i]; 1482 } 1483 } 911 1484 } 912 1485 else … … 917 1490 if( !m_tileUniformSpacingFlag && m_numTileRowsMinus1 > 0 ) 918 1491 { 919 char *str; 920 int i=0; 921 m_tileRowHeight.resize(m_numTileRowsMinus1); 922 str = strtok(pRowHeight, " ,-"); 923 while(str!=NULL) 924 { 925 if( i>=m_numTileRowsMinus1 ) 926 { 927 printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" ); 928 exit( EXIT_FAILURE ); 929 } 930 m_tileRowHeight[i] = atoi( str ); 931 str = strtok(NULL, " ,-"); 932 i++; 933 } 934 if( i < m_numTileRowsMinus1 ) 1492 if (cfg_RowHeight.values.size() > m_numTileRowsMinus1) 1493 { 1494 printf( "The number of rows whose height are defined is larger than the allowed number of rows.\n" ); 1495 exit( EXIT_FAILURE ); 1496 } 1497 else if (cfg_RowHeight.values.size() < m_numTileRowsMinus1) 935 1498 { 936 1499 printf( "The height of some rows is not defined.\n" ); 937 1500 exit( EXIT_FAILURE ); 938 } 1501 } 1502 else 1503 { 1504 m_tileRowHeight.resize(m_numTileRowsMinus1); 1505 for(UInt i=0; i<cfg_RowHeight.values.size(); i++) 1506 { 1507 m_tileRowHeight[i]=cfg_RowHeight.values[i]; 1508 } 1509 } 939 1510 } 940 1511 else … … 942 1513 m_tileRowHeight.clear(); 943 1514 } 944 #if H_MV 945 free ( pColumnWidth ); 946 free ( pRowHeight ); 947 #endif 1515 948 1516 m_scalingListFile = cfg_ScalingListFile.empty() ? NULL : strdup(cfg_ScalingListFile.c_str()); 949 1517 950 1518 /* rules for input, output and internal bitdepths as per help text */ 951 if (!m_internalBitDepthY) { m_internalBitDepthY = m_inputBitDepthY; } 952 if (!m_internalBitDepthC) { m_internalBitDepthC = m_internalBitDepthY; } 953 if (!m_inputBitDepthC) { m_inputBitDepthC = m_inputBitDepthY; } 954 if (!m_outputBitDepthY) { m_outputBitDepthY = m_internalBitDepthY; } 955 if (!m_outputBitDepthC) { m_outputBitDepthC = m_internalBitDepthC; } 956 957 // TODO:ChromaFmt assumes 4:2:0 below 1519 if (m_MSBExtendedBitDepth[CHANNEL_TYPE_LUMA ] == 0) 1520 { 1521 m_MSBExtendedBitDepth[CHANNEL_TYPE_LUMA ] = m_inputBitDepth [CHANNEL_TYPE_LUMA ]; 1522 } 1523 if (m_MSBExtendedBitDepth[CHANNEL_TYPE_CHROMA] == 0) 1524 { 1525 m_MSBExtendedBitDepth[CHANNEL_TYPE_CHROMA] = m_MSBExtendedBitDepth[CHANNEL_TYPE_LUMA ]; 1526 } 1527 if (m_internalBitDepth [CHANNEL_TYPE_LUMA ] == 0) 1528 { 1529 m_internalBitDepth [CHANNEL_TYPE_LUMA ] = m_MSBExtendedBitDepth[CHANNEL_TYPE_LUMA ]; 1530 } 1531 if (m_internalBitDepth [CHANNEL_TYPE_CHROMA] == 0) 1532 { 1533 m_internalBitDepth [CHANNEL_TYPE_CHROMA] = m_internalBitDepth [CHANNEL_TYPE_LUMA ]; 1534 } 1535 if (m_inputBitDepth [CHANNEL_TYPE_CHROMA] == 0) 1536 { 1537 m_inputBitDepth [CHANNEL_TYPE_CHROMA] = m_inputBitDepth [CHANNEL_TYPE_LUMA ]; 1538 } 1539 if (m_outputBitDepth [CHANNEL_TYPE_LUMA ] == 0) 1540 { 1541 m_outputBitDepth [CHANNEL_TYPE_LUMA ] = m_internalBitDepth [CHANNEL_TYPE_LUMA ]; 1542 } 1543 if (m_outputBitDepth [CHANNEL_TYPE_CHROMA] == 0) 1544 { 1545 m_outputBitDepth [CHANNEL_TYPE_CHROMA] = m_internalBitDepth [CHANNEL_TYPE_CHROMA]; 1546 } 1547 1548 m_InputChromaFormatIDC = numberToChromaFormat(tmpInputChromaFormat); 1549 m_chromaFormatIDC = ((tmpChromaFormat == 0) ? (m_InputChromaFormatIDC) : (numberToChromaFormat(tmpChromaFormat))); 1550 1551 #if NH_MV 1552 // parse PTL 1553 Bool anyEmpty = false; 1554 if( cfg_profiles.empty() ) 1555 { 1556 #if NH_3D 1557 cfg_profiles = string("main main 3d-main"); 1558 #else 1559 cfg_profiles = string("main main multiview-main"); 1560 #endif 1561 fprintf(stderr, "\nWarning: No profiles given, using defaults: %s", cfg_profiles.c_str() ); 1562 anyEmpty = true; 1563 } 1564 1565 if( cfg_levels.empty() ) 1566 { 1567 cfg_levels = string("5.1 5.1 5.1"); 1568 fprintf(stderr, "\nWarning: No levels given, using defaults: %s", cfg_levels.c_str() ); 1569 anyEmpty = true; 1570 } 1571 1572 if( cfg_tiers.empty() ) 1573 { 1574 cfg_tiers = string("main main main"); 1575 fprintf(stderr, "\nWarning: No tiers given, using defaults: %s", cfg_tiers.c_str()); 1576 anyEmpty = true; 1577 } 1578 1579 if( m_inblFlag.empty() ) 1580 { 1581 fprintf(stderr, "\nWarning: No inblFlags given, using defaults:"); 1582 for( Int i = 0; i < 3; i++) 1583 { 1584 m_inblFlag.push_back( false ); 1585 fprintf(stderr," %d", (Int) m_inblFlag[i]); 1586 } 1587 anyEmpty = true; 1588 } 1589 1590 if ( anyEmpty ) 1591 { 1592 fprintf( stderr, "\n" ); 1593 } 1594 1595 xReadStrToEnum( cfg_profiles, extendedProfiles ); 1596 xReadStrToEnum( cfg_levels, m_level ); 1597 xReadStrToEnum( cfg_tiers , m_levelTier ); 1598 1599 1600 #if NH_MV 1601 m_profiles.resize( extendedProfiles.size()); 1602 1603 for (Int i = 0; i < m_profiles.size(); i++) 1604 { 1605 Profile::Name& m_profile = m_profiles [i]; 1606 ExtendedProfileName& extendedProfile = extendedProfiles[i]; 1607 #endif 1608 #endif 1609 1610 if (extendedProfile >= 1000 && extendedProfile <= 12316) 1611 { 1612 m_profile = Profile::MAINREXT; 1613 if (m_bitDepthConstraint != 0 || tmpConstraintChromaFormat != 0) 1614 { 1615 fprintf(stderr, "Error: The bit depth and chroma format constraints are not used when an explicit RExt profile is specified\n"); 1616 exit(EXIT_FAILURE); 1617 } 1618 m_bitDepthConstraint = (extendedProfile%100); 1619 m_intraConstraintFlag = ((extendedProfile%10000)>=2000); 1620 m_onePictureOnlyConstraintFlag = (extendedProfile >= 10000); 1621 switch ((extendedProfile/100)%10) 1622 { 1623 case 0: tmpConstraintChromaFormat=400; break; 1624 case 1: tmpConstraintChromaFormat=420; break; 1625 case 2: tmpConstraintChromaFormat=422; break; 1626 default: tmpConstraintChromaFormat=444; break; 1627 } 1628 } 1629 else 1630 { 1631 m_profile = Profile::Name(extendedProfile); 1632 } 1633 1634 if (m_profile == Profile::HIGHTHROUGHPUTREXT ) 1635 { 1636 if (m_bitDepthConstraint == 0) 1637 { 1638 m_bitDepthConstraint = 16; 1639 } 1640 m_chromaFormatConstraint = (tmpConstraintChromaFormat == 0) ? CHROMA_444 : numberToChromaFormat(tmpConstraintChromaFormat); 1641 } 1642 else if (m_profile == Profile::MAINREXT) 1643 { 1644 if (m_bitDepthConstraint == 0 && tmpConstraintChromaFormat == 0) 1645 { 1646 // produce a valid combination, if possible. 1647 const Bool bUsingGeneralRExtTools = m_transformSkipRotationEnabledFlag || 1648 m_transformSkipContextEnabledFlag || 1649 m_rdpcmEnabledFlag[RDPCM_SIGNAL_IMPLICIT] || 1650 m_rdpcmEnabledFlag[RDPCM_SIGNAL_EXPLICIT] || 1651 !m_enableIntraReferenceSmoothing || 1652 m_persistentRiceAdaptationEnabledFlag || 1653 m_log2MaxTransformSkipBlockSize!=2; 1654 const Bool bUsingChromaQPAdjustment= m_diffCuChromaQpOffsetDepth >= 0; 1655 const Bool bUsingExtendedPrecision = m_extendedPrecisionProcessingFlag; 1656 if (m_onePictureOnlyConstraintFlag) 1657 { 1658 m_chromaFormatConstraint = CHROMA_444; 1659 if (m_intraConstraintFlag != true) 1660 { 1661 fprintf(stderr, "Error: Intra constraint flag must be true when one_picture_only_constraint_flag is true\n"); 1662 exit(EXIT_FAILURE); 1663 } 1664 const Int maxBitDepth = m_chromaFormatIDC==CHROMA_400 ? m_internalBitDepth[CHANNEL_TYPE_LUMA] : std::max(m_internalBitDepth[CHANNEL_TYPE_LUMA], m_internalBitDepth[CHANNEL_TYPE_CHROMA]); 1665 m_bitDepthConstraint = maxBitDepth>8 ? 16:8; 1666 } 1667 else 1668 { 1669 m_chromaFormatConstraint = NUM_CHROMA_FORMAT; 1670 automaticallySelectRExtProfile(bUsingGeneralRExtTools, 1671 bUsingChromaQPAdjustment, 1672 bUsingExtendedPrecision, 1673 m_intraConstraintFlag, 1674 m_bitDepthConstraint, 1675 m_chromaFormatConstraint, 1676 m_chromaFormatIDC==CHROMA_400 ? m_internalBitDepth[CHANNEL_TYPE_LUMA] : std::max(m_internalBitDepth[CHANNEL_TYPE_LUMA], m_internalBitDepth[CHANNEL_TYPE_CHROMA]), 1677 m_chromaFormatIDC); 1678 } 1679 } 1680 else if (m_bitDepthConstraint == 0 || tmpConstraintChromaFormat == 0) 1681 { 1682 fprintf(stderr, "Error: The bit depth and chroma format constraints must either both be specified or both be configured automatically\n"); 1683 exit(EXIT_FAILURE); 1684 } 1685 else 1686 { 1687 m_chromaFormatConstraint = numberToChromaFormat(tmpConstraintChromaFormat); 1688 } 1689 } 1690 else 1691 { 1692 m_chromaFormatConstraint = (tmpConstraintChromaFormat == 0) ? m_chromaFormatIDC : numberToChromaFormat(tmpConstraintChromaFormat); 1693 m_bitDepthConstraint = (m_profile == Profile::MAIN10?10:8); 1694 } 1695 #if NH_MV 1696 } 1697 1698 if ( m_numberOfLayers != 0 && ( m_profiles[0] != Profile::MAIN || m_profiles[1] != Profile::MAIN ) ) 1699 { 1700 fprintf(stderr, "Error: The base layer must conform to the Main profile for Multilayer coding.\n"); 1701 exit(EXIT_FAILURE); 1702 } 1703 #endif 1704 1705 1706 m_inputColourSpaceConvert = stringToInputColourSpaceConvert(inputColourSpaceConvert, true); 1707 958 1708 switch (m_conformanceWindowMode) 959 1709 { … … 984 1734 } 985 1735 } 986 if (m_aiPad[0] % TComSPS::getWinUnitX( CHROMA_420) != 0)1736 if (m_aiPad[0] % TComSPS::getWinUnitX(m_chromaFormatIDC) != 0) 987 1737 { 988 1738 fprintf(stderr, "Error: picture width is not an integer multiple of the specified chroma subsampling\n"); 989 1739 exit(EXIT_FAILURE); 990 1740 } 991 if (m_aiPad[1] % TComSPS::getWinUnitY( CHROMA_420) != 0)1741 if (m_aiPad[1] % TComSPS::getWinUnitY(m_chromaFormatIDC) != 0) 992 1742 { 993 1743 fprintf(stderr, "Error: picture height is not an integer multiple of the specified chroma subsampling\n"); … … 1020 1770 } 1021 1771 } 1022 1772 1023 1773 // allocate slice-based dQP values 1024 #if H_MV 1774 #if NH_MV 1775 for (Int i = m_layerIdInNuh.size(); i < m_numberOfLayers; i++ ) 1776 { 1777 m_layerIdInNuh.push_back( i == 0 ? 0 : m_layerIdInNuh[ i - 1 ] + 1 ); 1778 } 1779 xResizeVector( m_layerIdInNuh ); 1780 1025 1781 xResizeVector( m_viewOrderIndex ); 1026 1782 … … 1041 1797 xResizeVector( m_auxId ); 1042 1798 1043 #if H_3D1799 #if NH_3D 1044 1800 xResizeVector( m_depthFlag ); 1045 1801 #endif … … 1062 1818 { 1063 1819 m_aidQP[layer][i] = 1; 1820 } 1821 } 1822 1823 for(UInt ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++) 1824 { 1825 if (saoOffsetBitShift[ch]<0) 1826 { 1827 if (m_internalBitDepth[ch]>10) 1828 { 1829 m_log2SaoOffsetScale[layer][ch]=UInt(Clip3<Int>(0, m_internalBitDepth[ch]-10, Int(m_internalBitDepth[ch]-10 + 0.165*m_iQP[layer] - 3.22 + 0.5) ) ); 1830 } 1831 else 1832 { 1833 m_log2SaoOffsetScale[layer][ch]=0; 1834 } 1835 } 1836 else 1837 { 1838 m_log2SaoOffsetScale[layer][ch]=UInt(saoOffsetBitShift[ch]); 1064 1839 } 1065 1840 } … … 1080 1855 m_aidQP = new Int[ m_framesToBeEncoded + m_iGOPSize + 1 ]; 1081 1856 ::memset( m_aidQP, 0, sizeof(Int)*( m_framesToBeEncoded + m_iGOPSize + 1 ) ); 1082 1857 1083 1858 // handling of floating-point QP values 1084 1859 // if QP is not integer, sequence is split into two sections having QP and QP+1 … … 1087 1862 { 1088 1863 Int iSwitchPOC = (Int)( m_framesToBeEncoded - (m_fQP - m_iQP)*m_framesToBeEncoded + 0.5 ); 1089 1864 1090 1865 iSwitchPOC = (Int)( (Double)iSwitchPOC / m_iGOPSize + 0.5 )*m_iGOPSize; 1091 1866 for ( Int i=iSwitchPOC; i<m_framesToBeEncoded + m_iGOPSize + 1; i++ ) … … 1094 1869 } 1095 1870 } 1096 #endif 1097 1871 1872 for(UInt ch=0; ch<MAX_NUM_CHANNEL_TYPE; ch++) 1873 { 1874 if (saoOffsetBitShift[ch]<0) 1875 { 1876 if (m_internalBitDepth[ch]>10) 1877 { 1878 m_log2SaoOffsetScale[ch]=UInt(Clip3<Int>(0, m_internalBitDepth[ch]-10, Int(m_internalBitDepth[ch]-10 + 0.165*m_iQP - 3.22 + 0.5) ) ); 1879 } 1880 else 1881 { 1882 m_log2SaoOffsetScale[ch]=0; 1883 } 1884 } 1885 else 1886 { 1887 m_log2SaoOffsetScale[ch]=UInt(saoOffsetBitShift[ch]); 1888 } 1889 } 1890 1891 #endif 1892 1098 1893 // reading external dQP description from file 1099 1894 if ( m_pchdQPFile ) … … 1102 1897 if ( fpt ) 1103 1898 { 1104 #if H_MV1899 #if NH_MV 1105 1900 for( Int layer = 0; layer < m_numberOfLayers; layer++ ) 1106 1901 { … … 1110 1905 while ( iPOC < m_framesToBeEncoded ) 1111 1906 { 1112 if ( fscanf(fpt, "%d", &iValue ) == EOF ) break; 1113 #if H_MV 1907 if ( fscanf(fpt, "%d", &iValue ) == EOF ) 1908 { 1909 break; 1910 } 1911 #if NH_MV 1114 1912 m_aidQP[layer][ iPOC ] = iValue; 1115 1913 iPOC++; … … 1123 1921 } 1124 1922 } 1125 m_iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1; 1126 1923 1924 if( m_masteringDisplay.colourVolumeSEIEnabled ) 1925 { 1926 for(UInt idx=0; idx<6; idx++) 1927 { 1928 m_masteringDisplay.primaries[idx/2][idx%2] = UShort((cfg_DisplayPrimariesCode.values.size() > idx) ? cfg_DisplayPrimariesCode.values[idx] : 0); 1929 } 1930 for(UInt idx=0; idx<2; idx++) 1931 { 1932 m_masteringDisplay.whitePoint[idx] = UShort((cfg_DisplayWhitePointCode.values.size() > idx) ? cfg_DisplayWhitePointCode.values[idx] : 0); 1933 } 1934 } 1935 1127 1936 if( m_toneMappingInfoSEIEnabled && !m_toneMapCancelFlag ) 1128 1937 { 1129 Char* pcStartOfCodedInterval = cfg_startOfCodedInterval.empty() ? NULL: strdup(cfg_startOfCodedInterval.c_str()); 1130 Char* pcCodedPivotValue = cfg_codedPivotValue.empty() ? NULL: strdup(cfg_codedPivotValue.c_str()); 1131 Char* pcTargetPivotValue = cfg_targetPivotValue.empty() ? NULL: strdup(cfg_targetPivotValue.c_str()); 1132 if( m_toneMapModelId == 2 && pcStartOfCodedInterval ) 1133 { 1134 char *startOfCodedInterval; 1135 UInt num = 1u<< m_toneMapTargetBitDepth; 1938 if( m_toneMapModelId == 2 && !cfg_startOfCodedInterval.values.empty() ) 1939 { 1940 const UInt num = 1u<< m_toneMapTargetBitDepth; 1136 1941 m_startOfCodedInterval = new Int[num]; 1137 ::memset( m_startOfCodedInterval, 0, sizeof(Int)*num ); 1138 startOfCodedInterval = strtok(pcStartOfCodedInterval, " ."); 1139 int i = 0; 1140 while( startOfCodedInterval && ( i < num ) ) 1141 { 1142 m_startOfCodedInterval[i] = atoi( startOfCodedInterval ); 1143 startOfCodedInterval = strtok(NULL, " ."); 1144 i++; 1145 } 1146 } 1942 for(UInt i=0; i<num; i++) 1943 { 1944 m_startOfCodedInterval[i] = cfg_startOfCodedInterval.values.size() > i ? cfg_startOfCodedInterval.values[i] : 0; 1945 } 1946 } 1147 1947 else 1148 1948 { … … 1151 1951 if( ( m_toneMapModelId == 3 ) && ( m_numPivots > 0 ) ) 1152 1952 { 1153 if( pcCodedPivotValue && pcTargetPivotValue ) 1154 { 1155 char *codedPivotValue; 1156 char *targetPivotValue; 1157 m_codedPivotValue = new Int[m_numPivots]; 1953 if( !cfg_codedPivotValue.values.empty() && !cfg_targetPivotValue.values.empty() ) 1954 { 1955 m_codedPivotValue = new Int[m_numPivots]; 1158 1956 m_targetPivotValue = new Int[m_numPivots]; 1159 ::memset( m_codedPivotValue, 0, sizeof(Int)*( m_numPivots ) ); 1160 ::memset( m_targetPivotValue, 0, sizeof(Int)*( m_numPivots ) ); 1161 codedPivotValue = strtok(pcCodedPivotValue, " ."); 1162 int i=0; 1163 while(codedPivotValue&&i<m_numPivots) 1957 for(UInt i=0; i<m_numPivots; i++) 1164 1958 { 1165 m_codedPivotValue[i] = atoi( codedPivotValue ); 1166 codedPivotValue = strtok(NULL, " ."); 1167 i++; 1168 } 1169 i=0; 1170 targetPivotValue = strtok(pcTargetPivotValue, " ."); 1171 while(targetPivotValue&&i<m_numPivots) 1172 { 1173 m_targetPivotValue[i]= atoi( targetPivotValue ); 1174 targetPivotValue = strtok(NULL, " ."); 1175 i++; 1959 m_codedPivotValue[i] = cfg_codedPivotValue.values.size() > i ? cfg_codedPivotValue.values [i] : 0; 1960 m_targetPivotValue[i] = cfg_targetPivotValue.values.size() > i ? cfg_targetPivotValue.values[i] : 0; 1176 1961 } 1177 1962 } … … 1184 1969 } 1185 1970 1186 #if H_MV 1187 // parse PTL 1188 Bool anyEmpty = false; 1189 if( cfg_profiles.empty() ) 1190 { 1191 #if H_3D 1192 cfg_profiles = string("main main 3d-main"); 1193 #else 1194 cfg_profiles = string("main main multiview-main"); 1195 #endif 1196 fprintf(stderr, "\nWarning: No profiles given, using defaults: %s", cfg_profiles.c_str() ); 1197 anyEmpty = true; 1198 } 1199 1200 if( cfg_levels.empty() ) 1201 { 1202 cfg_levels = string("none none none"); 1203 fprintf(stderr, "\nWarning: No levels given, using defaults: %s", cfg_levels.c_str() ); 1204 anyEmpty = true; 1205 } 1206 1207 if( cfg_tiers.empty() ) 1208 { 1209 cfg_tiers = string("main main main"); 1210 fprintf(stderr, "\nWarning: No tiers given, using defaults: %s", cfg_tiers.c_str()); 1211 anyEmpty = true; 1212 } 1213 1214 if( m_inblFlag.empty() ) 1215 { 1216 fprintf(stderr, "\nWarning: No inblFlags given, using defaults:"); 1217 for( Int i = 0; i < 3; i++) 1218 { 1219 m_inblFlag.push_back( false ); 1220 fprintf(stderr," %d", (Int) m_inblFlag[i]); 1221 } 1222 anyEmpty = true; 1223 } 1224 1225 if ( anyEmpty ) 1226 { 1227 fprintf( stderr, "\n" ); 1228 } 1229 1230 xReadStrToEnum( cfg_profiles, m_profile ); 1231 xReadStrToEnum( cfg_levels, m_level ); 1232 xReadStrToEnum( cfg_tiers , m_levelTier ); 1233 #endif 1234 #if H_3D 1235 // set global varibles 1236 xSetGlobal(); 1237 #if H_3D_VSO 1238 // Table base optimization 1971 if( m_kneeSEIEnabled && !m_kneeSEICancelFlag ) 1972 { 1973 assert ( m_kneeSEINumKneePointsMinus1 >= 0 && m_kneeSEINumKneePointsMinus1 < 999 ); 1974 m_kneeSEIInputKneePoint = new Int[m_kneeSEINumKneePointsMinus1+1]; 1975 m_kneeSEIOutputKneePoint = new Int[m_kneeSEINumKneePointsMinus1+1]; 1976 for(Int i=0; i<(m_kneeSEINumKneePointsMinus1+1); i++) 1977 { 1978 m_kneeSEIInputKneePoint[i] = cfg_kneeSEIInputKneePointValue.values.size() > i ? cfg_kneeSEIInputKneePointValue.values[i] : 1; 1979 m_kneeSEIOutputKneePoint[i] = cfg_kneeSEIOutputKneePointValue.values.size() > i ? cfg_kneeSEIOutputKneePointValue.values[i] : 0; 1980 } 1981 } 1982 1983 if(m_timeCodeSEIEnabled) 1984 { 1985 for(Int i = 0; i < m_timeCodeSEINumTs && i < MAX_TIMECODE_SEI_SETS; i++) 1986 { 1987 m_timeSetArray[i].clockTimeStampFlag = cfg_timeCodeSeiTimeStampFlag .values.size()>i ? cfg_timeCodeSeiTimeStampFlag .values [i] : false; 1988 m_timeSetArray[i].numUnitFieldBasedFlag = cfg_timeCodeSeiNumUnitFieldBasedFlag.values.size()>i ? cfg_timeCodeSeiNumUnitFieldBasedFlag.values [i] : 0; 1989 m_timeSetArray[i].countingType = cfg_timeCodeSeiCountingType .values.size()>i ? cfg_timeCodeSeiCountingType .values [i] : 0; 1990 m_timeSetArray[i].fullTimeStampFlag = cfg_timeCodeSeiFullTimeStampFlag .values.size()>i ? cfg_timeCodeSeiFullTimeStampFlag .values [i] : 0; 1991 m_timeSetArray[i].discontinuityFlag = cfg_timeCodeSeiDiscontinuityFlag .values.size()>i ? cfg_timeCodeSeiDiscontinuityFlag .values [i] : 0; 1992 m_timeSetArray[i].cntDroppedFlag = cfg_timeCodeSeiCntDroppedFlag .values.size()>i ? cfg_timeCodeSeiCntDroppedFlag .values [i] : 0; 1993 m_timeSetArray[i].numberOfFrames = cfg_timeCodeSeiNumberOfFrames .values.size()>i ? cfg_timeCodeSeiNumberOfFrames .values [i] : 0; 1994 m_timeSetArray[i].secondsValue = cfg_timeCodeSeiSecondsValue .values.size()>i ? cfg_timeCodeSeiSecondsValue .values [i] : 0; 1995 m_timeSetArray[i].minutesValue = cfg_timeCodeSeiMinutesValue .values.size()>i ? cfg_timeCodeSeiMinutesValue .values [i] : 0; 1996 m_timeSetArray[i].hoursValue = cfg_timeCodeSeiHoursValue .values.size()>i ? cfg_timeCodeSeiHoursValue .values [i] : 0; 1997 m_timeSetArray[i].secondsFlag = cfg_timeCodeSeiSecondsFlag .values.size()>i ? cfg_timeCodeSeiSecondsFlag .values [i] : 0; 1998 m_timeSetArray[i].minutesFlag = cfg_timeCodeSeiMinutesFlag .values.size()>i ? cfg_timeCodeSeiMinutesFlag .values [i] : 0; 1999 m_timeSetArray[i].hoursFlag = cfg_timeCodeSeiHoursFlag .values.size()>i ? cfg_timeCodeSeiHoursFlag .values [i] : 0; 2000 m_timeSetArray[i].timeOffsetLength = cfg_timeCodeSeiTimeOffsetLength .values.size()>i ? cfg_timeCodeSeiTimeOffsetLength .values [i] : 0; 2001 m_timeSetArray[i].timeOffsetValue = cfg_timeCodeSeiTimeOffsetValue .values.size()>i ? cfg_timeCodeSeiTimeOffsetValue .values [i] : 0; 2002 } 2003 } 2004 2005 #if NH_3D 2006 #if NH_3D_VSO 2007 // Table base optimization 1239 2008 // Q&D 1240 2009 Double adLambdaScaleTable[] = 1241 2010 { 0.031250, 0.031639, 0.032029, 0.032418, 0.032808, 0.033197, 0.033586, 0.033976, 0.034365, 0.034755, 1242 1243 1244 1245 1246 2011 0.035144, 0.035533, 0.035923, 0.036312, 0.036702, 0.037091, 0.037480, 0.037870, 0.038259, 0.038648, 2012 0.039038, 0.039427, 0.039817, 0.040206, 0.040595, 0.040985, 0.041374, 0.041764, 0.042153, 0.042542, 2013 0.042932, 0.043321, 0.043711, 0.044100, 0.044194, 0.053033, 0.061872, 0.070711, 0.079550, 0.088388, 2014 0.117851, 0.147314, 0.176777, 0.235702, 0.294628, 0.353553, 0.471405, 0.589256, 0.707107, 0.707100, 2015 0.753550, 0.800000 1247 2016 }; 1248 2017 if ( m_bUseVSO && m_bVSOLSTable ) … … 1261 2030 m_dLambdaScaleVSO *= adLambdaScaleTable[m_iQP[firstDepthLayer]]; 1262 2031 } 1263 #endif 1264 #if H_3D_VSO 1265 if ( m_bUseVSO && m_uiVSOMode == 4) 1266 { 1267 m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig ); 2032 if ( m_bUseVSO && m_uiVSOMode == 4) 2033 { 2034 m_cRenModStrParser.setString( m_iNumberOfViews, m_pchVSOConfig ); 2035 m_cCameraData .init ( ((UInt) m_iNumberOfViews ), 2036 m_internalBitDepth[ CHANNEL_TYPE_LUMA], 2037 (UInt)m_iCodedCamParPrecision, 2038 m_FrameSkip, 2039 (UInt)m_framesToBeEncoded, 2040 m_pchCameraParameterFile, 2041 m_pchBaseViewCameraNumbers, 2042 NULL, 2043 m_cRenModStrParser.getSynthViews(), 2044 LOG2_DISP_PREC_LUT ); 2045 } 2046 else if ( m_bUseVSO && m_uiVSOMode != 4 ) 2047 { 2048 m_cCameraData .init ( ((UInt) m_iNumberOfViews ), 2049 m_internalBitDepth[ CHANNEL_TYPE_LUMA], 2050 (UInt)m_iCodedCamParPrecision, 2051 m_FrameSkip, 2052 (UInt)m_framesToBeEncoded, 2053 m_pchCameraParameterFile, 2054 m_pchBaseViewCameraNumbers, 2055 m_pchVSOConfig, 2056 NULL, 2057 LOG2_DISP_PREC_LUT ); 2058 } 2059 else 2060 { 2061 m_cCameraData .init ( ((UInt) m_iNumberOfViews ), 2062 m_internalBitDepth[ CHANNEL_TYPE_LUMA], 2063 (UInt) m_iCodedCamParPrecision, 2064 m_FrameSkip, 2065 (UInt) m_framesToBeEncoded, 2066 m_pchCameraParameterFile, 2067 m_pchBaseViewCameraNumbers, 2068 NULL, 2069 NULL, 2070 LOG2_DISP_PREC_LUT ); 2071 } 2072 #else 1268 2073 m_cCameraData .init ( ((UInt) m_iNumberOfViews ), 1269 g_bitDepthY, 1270 (UInt)m_iCodedCamParPrecision, 1271 m_FrameSkip, 1272 (UInt)m_framesToBeEncoded, 1273 m_pchCameraParameterFile, 1274 m_pchBaseViewCameraNumbers, 1275 NULL, 1276 m_cRenModStrParser.getSynthViews(), 1277 LOG2_DISP_PREC_LUT ); 1278 } 1279 else if ( m_bUseVSO && m_uiVSOMode != 4 ) 1280 { 1281 m_cCameraData .init ( ((UInt) m_iNumberOfViews ), 1282 g_bitDepthY, 1283 (UInt)m_iCodedCamParPrecision, 1284 m_FrameSkip, 1285 (UInt)m_framesToBeEncoded, 1286 m_pchCameraParameterFile, 1287 m_pchBaseViewCameraNumbers, 1288 m_pchVSOConfig, 1289 NULL, 1290 LOG2_DISP_PREC_LUT ); 1291 } 1292 else 1293 { 1294 m_cCameraData .init ( ((UInt) m_iNumberOfViews ), 1295 g_bitDepthY, 2074 m_internalBitDepth[ CHANNEL_TYPE_LUMA], 1296 2075 (UInt) m_iCodedCamParPrecision, 1297 2076 m_FrameSkip, … … 1302 2081 NULL, 1303 2082 LOG2_DISP_PREC_LUT ); 1304 }1305 #else1306 m_cCameraData .init ( ((UInt) m_iNumberOfViews ),1307 g_bitDepthY,1308 (UInt) m_iCodedCamParPrecision,1309 m_FrameSkip,1310 (UInt) m_framesToBeEncoded,1311 m_pchCameraParameterFile,1312 m_pchBaseViewCameraNumbers,1313 NULL,1314 NULL,1315 LOG2_DISP_PREC_LUT );1316 2083 #endif 1317 2084 m_cCameraData.check( false, true ); 1318 2085 #endif 2086 1319 2087 // check validity of input parameters 1320 2088 xCheckParameter(); 1321 2089 1322 #if !H_3D 1323 // set global varibles 1324 xSetGlobal(); 1325 #endif 1326 2090 // compute actual CU depth with respect to config depth and max transform size 2091 UInt uiAddCUDepth = 0; 2092 while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + uiAddCUDepth ) ) ) 2093 { 2094 uiAddCUDepth++; 2095 } 2096 2097 m_uiMaxTotalCUDepth = m_uiMaxCUDepth + uiAddCUDepth + getMaxCUDepthOffset(m_chromaFormatIDC, m_uiQuadtreeTULog2MinSize); // if minimum TU larger than 4x4, allow for additional part indices for 4:2:2 SubTUs. 2098 uiAddCUDepth++; 2099 m_uiLog2DiffMaxMinCodingBlockSize = m_uiMaxCUDepth - 1; 2100 1327 2101 // print-out parameters 1328 2102 xPrintParameter(); 1329 2103 1330 2104 return true; 1331 2105 } 2106 2107 1332 2108 // ==================================================================================================================== 1333 2109 // Private member functions 1334 2110 // ==================================================================================================================== 1335 1336 Bool confirmPara(Bool bflag, const Char* message);1337 2111 1338 2112 Void TAppEncCfg::xCheckParameter() … … 1348 2122 1349 2123 1350 #if ! H_MV2124 #if !NH_MV 1351 2125 if( m_profile==Profile::NONE ) 1352 2126 { … … 1365 2139 Bool check_failed = false; /* abort if there is a fatal configuration problem */ 1366 2140 #define xConfirmPara(a,b) check_failed |= confirmPara(a,b) 2141 2142 const UInt maxBitDepth=(m_chromaFormatIDC==CHROMA_400) ? m_internalBitDepth[CHANNEL_TYPE_LUMA] : std::max(m_internalBitDepth[CHANNEL_TYPE_LUMA], m_internalBitDepth[CHANNEL_TYPE_CHROMA]); 2143 xConfirmPara(m_bitDepthConstraint<maxBitDepth, "The internalBitDepth must not be greater than the bitDepthConstraint value"); 2144 xConfirmPara(m_chromaFormatConstraint<m_chromaFormatIDC, "The chroma format used must not be greater than the chromaFormatConstraint value"); 2145 #if NH_MV 2146 Profile::Name & m_profile = m_profiles[0]; 2147 #endif 2148 2149 if (m_profile==Profile::MAINREXT || m_profile==Profile::HIGHTHROUGHPUTREXT) 2150 { 2151 xConfirmPara(m_lowerBitRateConstraintFlag==false && m_intraConstraintFlag==false, "The lowerBitRateConstraint flag cannot be false when intraConstraintFlag is false"); 2152 xConfirmPara(m_cabacBypassAlignmentEnabledFlag && m_profile!=Profile::HIGHTHROUGHPUTREXT, "AlignCABACBeforeBypass must not be enabled unless the high throughput profile is being used."); 2153 if (m_profile == Profile::MAINREXT) 2154 { 2155 const UInt intraIdx = m_intraConstraintFlag ? 1:0; 2156 const UInt bitDepthIdx = (m_bitDepthConstraint == 8 ? 0 : (m_bitDepthConstraint ==10 ? 1 : (m_bitDepthConstraint == 12 ? 2 : (m_bitDepthConstraint == 16 ? 3 : 4 )))); 2157 const UInt chromaFormatIdx = UInt(m_chromaFormatConstraint); 2158 const Bool bValidProfile = (bitDepthIdx > 3 || chromaFormatIdx>3) ? false : (validRExtProfileNames[intraIdx][bitDepthIdx][chromaFormatIdx] != NONE); 2159 xConfirmPara(!bValidProfile, "Invalid intra constraint flag, bit depth constraint flag and chroma format constraint flag combination for a RExt profile"); 2160 const Bool bUsingGeneralRExtTools = m_transformSkipRotationEnabledFlag || 2161 m_transformSkipContextEnabledFlag || 2162 m_rdpcmEnabledFlag[RDPCM_SIGNAL_IMPLICIT] || 2163 m_rdpcmEnabledFlag[RDPCM_SIGNAL_EXPLICIT] || 2164 !m_enableIntraReferenceSmoothing || 2165 m_persistentRiceAdaptationEnabledFlag || 2166 m_log2MaxTransformSkipBlockSize!=2; 2167 const Bool bUsingChromaQPTool = m_diffCuChromaQpOffsetDepth >= 0; 2168 const Bool bUsingExtendedPrecision = m_extendedPrecisionProcessingFlag; 2169 2170 xConfirmPara((m_chromaFormatConstraint==CHROMA_420 || m_chromaFormatConstraint==CHROMA_400) && bUsingChromaQPTool, "CU Chroma QP adjustment cannot be used for 4:0:0 or 4:2:0 RExt profiles"); 2171 xConfirmPara(m_bitDepthConstraint != 16 && bUsingExtendedPrecision, "Extended precision can only be used in 16-bit RExt profiles"); 2172 if (!(m_chromaFormatConstraint == CHROMA_400 && m_bitDepthConstraint == 16) && m_chromaFormatConstraint!=CHROMA_444) 2173 { 2174 xConfirmPara(bUsingGeneralRExtTools, "Combination of tools and profiles are not possible in the specified RExt profile."); 2175 } 2176 xConfirmPara( m_onePictureOnlyConstraintFlag && m_chromaFormatConstraint!=CHROMA_444, "chroma format constraint must be 4:4:4 when one-picture-only constraint flag is 1"); 2177 xConfirmPara( m_onePictureOnlyConstraintFlag && m_bitDepthConstraint != 8 && m_bitDepthConstraint != 16, "bit depth constraint must be 8 or 16 when one-picture-only constraint flag is 1"); 2178 xConfirmPara( m_onePictureOnlyConstraintFlag && m_framesToBeEncoded > 1, "Number of frames to be encoded must be 1 when one-picture-only constraint flag is 1."); 2179 2180 if (!m_intraConstraintFlag && m_bitDepthConstraint==16 && m_chromaFormatConstraint==CHROMA_444) 2181 { 2182 fprintf(stderr, "********************************************************************************************************\n"); 2183 fprintf(stderr, "** WARNING: The RExt constraint flags describe a non standard combination (used for development only) **\n"); 2184 fprintf(stderr, "********************************************************************************************************\n"); 2185 } 2186 } 2187 else 2188 { 2189 xConfirmPara( m_chromaFormatConstraint != CHROMA_444, "chroma format constraint must be 4:4:4 in the High Throughput 4:4:4 16-bit Intra profile."); 2190 xConfirmPara( m_bitDepthConstraint != 16, "bit depth constraint must be 4:4:4 in the High Throughput 4:4:4 16-bit Intra profile."); 2191 xConfirmPara( m_intraConstraintFlag != 1, "intra constraint flag must be 1 in the High Throughput 4:4:4 16-bit Intra profile."); 2192 } 2193 } 2194 else 2195 { 2196 xConfirmPara(m_bitDepthConstraint!=((m_profile==Profile::MAIN10)?10:8), "BitDepthConstraint must be 8 for MAIN profile and 10 for MAIN10 profile."); 2197 xConfirmPara(m_chromaFormatConstraint!=CHROMA_420, "ChromaFormatConstraint must be 420 for non main-RExt profiles."); 2198 xConfirmPara(m_intraConstraintFlag==true, "IntraConstraintFlag must be false for non main_RExt profiles."); 2199 xConfirmPara(m_lowerBitRateConstraintFlag==false, "LowerBitrateConstraintFlag must be true for non main-RExt profiles."); 2200 xConfirmPara(m_profile == Profile::MAINSTILLPICTURE && m_framesToBeEncoded > 1, "Number of frames to be encoded must be 1 when main still picture profile is used."); 2201 2202 xConfirmPara(m_crossComponentPredictionEnabledFlag==true, "CrossComponentPrediction must not be used for non main-RExt profiles."); 2203 xConfirmPara(m_log2MaxTransformSkipBlockSize!=2, "Transform Skip Log2 Max Size must be 2 for V1 profiles."); 2204 xConfirmPara(m_transformSkipRotationEnabledFlag==true, "UseResidualRotation must not be enabled for non main-RExt profiles."); 2205 xConfirmPara(m_transformSkipContextEnabledFlag==true, "UseSingleSignificanceMapContext must not be enabled for non main-RExt profiles."); 2206 xConfirmPara(m_rdpcmEnabledFlag[RDPCM_SIGNAL_IMPLICIT]==true, "ImplicitResidualDPCM must not be enabled for non main-RExt profiles."); 2207 xConfirmPara(m_rdpcmEnabledFlag[RDPCM_SIGNAL_EXPLICIT]==true, "ExplicitResidualDPCM must not be enabled for non main-RExt profiles."); 2208 xConfirmPara(m_persistentRiceAdaptationEnabledFlag==true, "GolombRiceParameterAdaption must not be enabled for non main-RExt profiles."); 2209 xConfirmPara(m_extendedPrecisionProcessingFlag==true, "UseExtendedPrecision must not be enabled for non main-RExt profiles."); 2210 xConfirmPara(m_highPrecisionOffsetsEnabledFlag==true, "UseHighPrecisionPredictionWeighting must not be enabled for non main-RExt profiles."); 2211 xConfirmPara(m_enableIntraReferenceSmoothing==false, "EnableIntraReferenceSmoothing must be enabled for non main-RExt profiles."); 2212 xConfirmPara(m_cabacBypassAlignmentEnabledFlag, "AlignCABACBeforeBypass cannot be enabled for non main-RExt profiles."); 2213 } 2214 1367 2215 // check range of parameters 1368 xConfirmPara( m_inputBitDepthY < 8, "InputBitDepth must be at least 8" ); 1369 xConfirmPara( m_inputBitDepthC < 8, "InputBitDepthC must be at least 8" ); 2216 xConfirmPara( m_inputBitDepth[CHANNEL_TYPE_LUMA ] < 8, "InputBitDepth must be at least 8" ); 2217 xConfirmPara( m_inputBitDepth[CHANNEL_TYPE_CHROMA] < 8, "InputBitDepthC must be at least 8" ); 2218 2219 #if !RExt__HIGH_BIT_DEPTH_SUPPORT 2220 if (m_extendedPrecisionProcessingFlag) 2221 { 2222 for (UInt channelType = 0; channelType < MAX_NUM_CHANNEL_TYPE; channelType++) 2223 { 2224 xConfirmPara((m_internalBitDepth[channelType] > 8) , "Model is not configured to support high enough internal accuracies - enable RExt__HIGH_BIT_DEPTH_SUPPORT to use increased precision internal data types etc..."); 2225 } 2226 } 2227 else 2228 { 2229 for (UInt channelType = 0; channelType < MAX_NUM_CHANNEL_TYPE; channelType++) 2230 { 2231 xConfirmPara((m_internalBitDepth[channelType] > 12) , "Model is not configured to support high enough internal accuracies - enable RExt__HIGH_BIT_DEPTH_SUPPORT to use increased precision internal data types etc..."); 2232 } 2233 } 2234 #endif 2235 2236 xConfirmPara( (m_MSBExtendedBitDepth[CHANNEL_TYPE_LUMA ] < m_inputBitDepth[CHANNEL_TYPE_LUMA ]), "MSB-extended bit depth for luma channel (--MSBExtendedBitDepth) must be greater than or equal to input bit depth for luma channel (--InputBitDepth)" ); 2237 xConfirmPara( (m_MSBExtendedBitDepth[CHANNEL_TYPE_CHROMA] < m_inputBitDepth[CHANNEL_TYPE_CHROMA]), "MSB-extended bit depth for chroma channel (--MSBExtendedBitDepthC) must be greater than or equal to input bit depth for chroma channel (--InputBitDepthC)" ); 2238 2239 #if NH_MV 2240 for (Int i = 0; i < m_numberOfLayers; i++) 2241 { 2242 xConfirmPara( m_log2SaoOffsetScale[i][CHANNEL_TYPE_LUMA] > (m_internalBitDepth[CHANNEL_TYPE_LUMA ]<10?0:(m_internalBitDepth[CHANNEL_TYPE_LUMA ]-10)), "SaoLumaOffsetBitShift must be in the range of 0 to InternalBitDepth-10, inclusive"); 2243 xConfirmPara( m_log2SaoOffsetScale[i][CHANNEL_TYPE_CHROMA] > (m_internalBitDepth[CHANNEL_TYPE_CHROMA]<10?0:(m_internalBitDepth[CHANNEL_TYPE_CHROMA]-10)), "SaoChromaOffsetBitShift must be in the range of 0 to InternalBitDepthC-10, inclusive"); 2244 } 2245 #else 2246 xConfirmPara( m_log2SaoOffsetScale[CHANNEL_TYPE_LUMA] > (m_internalBitDepth[CHANNEL_TYPE_LUMA ]<10?0:(m_internalBitDepth[CHANNEL_TYPE_LUMA ]-10)), "SaoLumaOffsetBitShift must be in the range of 0 to InternalBitDepth-10, inclusive"); 2247 xConfirmPara( m_log2SaoOffsetScale[CHANNEL_TYPE_CHROMA] > (m_internalBitDepth[CHANNEL_TYPE_CHROMA]<10?0:(m_internalBitDepth[CHANNEL_TYPE_CHROMA]-10)), "SaoChromaOffsetBitShift must be in the range of 0 to InternalBitDepthC-10, inclusive"); 2248 #endif 2249 2250 xConfirmPara( m_chromaFormatIDC >= NUM_CHROMA_FORMAT, "ChromaFormatIDC must be either 400, 420, 422 or 444" ); 2251 std::string sTempIPCSC="InputColourSpaceConvert must be empty, "+getListOfColourSpaceConverts(true); 2252 xConfirmPara( m_inputColourSpaceConvert >= NUMBER_INPUT_COLOUR_SPACE_CONVERSIONS, sTempIPCSC.c_str() ); 2253 xConfirmPara( m_InputChromaFormatIDC >= NUM_CHROMA_FORMAT, "InputChromaFormatIDC must be either 400, 420, 422 or 444" ); 1370 2254 xConfirmPara( m_iFrameRate <= 0, "Frame rate must be more than 1" ); 1371 2255 xConfirmPara( m_framesToBeEncoded <= 0, "Total Number Of Frames encoded must be more than 0" ); 1372 #if H_MV2256 #if NH_MV 1373 2257 xConfirmPara( m_numberOfLayers > MAX_NUM_LAYER_IDS , "NumberOfLayers must be less than or equal to MAX_NUM_LAYER_IDS"); 1374 2258 … … 1376 2260 xConfirmPara( m_layerIdInNuh[0] != 0 , "LayerIdInNuh must be 0 for the first layer. "); 1377 2261 xConfirmPara( (m_layerIdInNuh.size()!=1) && (m_layerIdInNuh.size() < m_numberOfLayers) , "LayerIdInNuh must be given for all layers. "); 1378 1379 #if H_3D2262 2263 #if NH_3D 1380 2264 xConfirmPara( m_scalabilityMask != 2 && m_scalabilityMask != 3, "Scalability Mask must be equal to 2 or 3. "); 1381 2265 #else … … 1383 2267 #endif 1384 2268 1385 #if H_3D2269 #if NH_3D 1386 2270 if ( m_scalabilityMask & ( 1 << DEPTH_ID ) ) 1387 2271 { … … 1404 2288 dimBitOffset[ 0 ] = 0; 1405 2289 for (Int j = 1; j <= ((Int) m_dimIds.size() - m_splittingFlag ? 1 : 0); j++ ) 1406 {2290 { 1407 2291 dimBitOffset[ j ] = dimBitOffset[ j - 1 ] + m_dimensionIdLen[ j - 1]; 1408 2292 } … … 1412 2296 dimBitOffset[ (Int) m_dimIds.size() ] = 6; 1413 2297 } 1414 2298 1415 2299 for( Int j = 0; j < m_dimIds.size(); j++ ) 1416 2300 { … … 1418 2302 xConfirmPara( (m_dimIds[j][0] != 0) , "DimensionId of layer 0 must be 0. " ); 1419 2303 xConfirmPara( m_dimensionIdLen[j] < 1 || m_dimensionIdLen[j] > 8, "DimensionIdLen must be greater than 0 and less than 9 in all dimensions. " ); 1420 1421 1422 for( Int i = 1; i < m_numberOfLayers; i++ )1423 {2304 2305 2306 for( Int i = 1; i < m_numberOfLayers; i++ ) 2307 { 1424 2308 xConfirmPara( ( m_dimIds[j][i] < 0 ) || ( m_dimIds[j][i] > ( ( 1 << m_dimensionIdLen[j] ) - 1 ) ) , "DimensionId shall be in the range of 0 to 2^DimensionIdLen - 1. " ); 1425 2309 if ( m_splittingFlag ) … … 1428 2312 xConfirmPara( ( ( layerIdInNuh & ( (1 << dimBitOffset[ j + 1 ] ) - 1) ) >> dimBitOffset[ j ] ) != m_dimIds[j][ i ] , "When Splitting Flag is equal to 1 dimension ids shall match values derived from layer ids. "); 1429 2313 } 1430 }1431 }1432 1433 for( Int i = 0; i < m_numberOfLayers; i++ )1434 {1435 for( Int j = 0; j < i; j++ )1436 {1437 Int numDiff = 0;1438 Int lastDiff = -1;1439 for( Int dim = 0; dim < m_dimIds.size(); dim++ )1440 {1441 if ( m_dimIds[dim][i] != m_dimIds[dim][j] )1442 {1443 numDiff ++;1444 lastDiff = dim;1445 }1446 }1447 1448 Bool allEqual = ( numDiff == 0 );1449 1450 if ( allEqual )1451 {1452 printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j);1453 }1454 1455 xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." );2314 } 2315 } 2316 2317 for( Int i = 0; i < m_numberOfLayers; i++ ) 2318 { 2319 for( Int j = 0; j < i; j++ ) 2320 { 2321 Int numDiff = 0; 2322 Int lastDiff = -1; 2323 for( Int dim = 0; dim < m_dimIds.size(); dim++ ) 2324 { 2325 if ( m_dimIds[dim][i] != m_dimIds[dim][j] ) 2326 { 2327 numDiff ++; 2328 lastDiff = dim; 2329 } 2330 } 2331 2332 Bool allEqual = ( numDiff == 0 ); 2333 2334 if ( allEqual ) 2335 { 2336 printf( "\nError: Positions of Layers %d and %d are identical in scalability space\n", i, j); 2337 } 2338 2339 xConfirmPara( allEqual , "Each layer shall have a different position in scalability space." ); 1456 2340 1457 2341 #if !H_3D_FCO 1458 if ( numDiff == 1 )1459 {1460 Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ];1461 Bool shallBeButIsNotIncreasing = ( !inc ) ;1462 if ( shallBeButIsNotIncreasing )1463 {1464 printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff);1465 }1466 xConfirmPara( shallBeButIsNotIncreasing, "DimensionIds shall be increasing within one dimension. " );1467 }1468 #endif 1469 }1470 }1471 1472 /// ViewId1473 xConfirmPara( m_viewId.size() != m_iNumberOfViews, "The number of ViewIds must be equal to the number of views." );2342 if ( numDiff == 1 ) 2343 { 2344 Bool inc = m_dimIds[ lastDiff ][ i ] > m_dimIds[ lastDiff ][ j ]; 2345 Bool shallBeButIsNotIncreasing = ( !inc ) ; 2346 if ( shallBeButIsNotIncreasing ) 2347 { 2348 printf( "\nError: Positions of Layers %d and %d is not increasing in dimension %d \n", i, j, lastDiff); 2349 } 2350 xConfirmPara( shallBeButIsNotIncreasing, "DimensionIds shall be increasing within one dimension. " ); 2351 } 2352 #endif 2353 } 2354 } 2355 2356 /// ViewId 2357 xConfirmPara( m_viewId.size() != m_iNumberOfViews, "The number of ViewIds must be equal to the number of views." ); 1474 2358 1475 2359 /// Layer sets … … 1532 2416 1533 2417 // PTL 1534 xConfirmPara( ( m_profile.size() != m_inblFlag.size() || m_profile.size() != m_level.size() || m_profile.size() != m_levelTier.size() ), "The number of Profiles, Levels, Tiers and InblFlags must be equal." );1535 1536 1537 1538 xConfirmPara( m_profile.size() <= 1, "The number of profiles, tiers, levels, and inblFlags must be greater than 1.");1539 1540 if (m_profile.size() > 1 )1541 1542 xConfirmPara( m_profile[0] != m_profile[1], "The profile in VpsProfileTierLevel[1] must be equal to the profile in VpsProfileTierLevel[0].");1543 1544 1545 1546 1547 2418 xConfirmPara( ( m_profiles.size() != m_inblFlag.size() || m_profiles.size() != m_level.size() || m_profiles.size() != m_levelTier.size() ), "The number of Profiles, Levels, Tiers and InblFlags must be equal." ); 2419 2420 if ( m_numberOfLayers > 1) 2421 { 2422 xConfirmPara( m_profiles.size() <= 1, "The number of profiles, tiers, levels, and inblFlags must be greater than 1."); 2423 xConfirmPara( m_inblFlag[0], "VpsProfileTierLevel[0] must have inblFlag equal to 0"); 2424 if (m_profiles.size() > 1 ) 2425 { 2426 xConfirmPara( m_profiles[0] != m_profiles[1], "The profile in VpsProfileTierLevel[1] must be equal to the profile in VpsProfileTierLevel[0]."); 2427 xConfirmPara( m_inblFlag[0] != m_inblFlag[1], "inblFlag in VpsProfileTierLevel[1] must be equal to the inblFlag in VpsProfileTierLevel[0]."); 2428 } 2429 } 2430 2431 // Layer Dependencies 1548 2432 for (Int i = 0; i < m_numberOfLayers; i++ ) 1549 2433 { … … 1557 2441 } 1558 2442 #endif 2443 1559 2444 xConfirmPara( m_iGOPSize < 1 , "GOP Size must be greater or equal to 1" ); 1560 2445 xConfirmPara( m_iGOPSize > 1 && m_iGOPSize % 2, "GOP Size must be a multiple of 2, if GOP Size is greater than 1" ); 1561 #if H_MV2446 #if NH_MV 1562 2447 for( Int layer = 0; layer < m_numberOfLayers; layer++ ) 1563 2448 { … … 1567 2452 xConfirmPara( (m_iIntraPeriod > 0 && m_iIntraPeriod < m_iGOPSize) || m_iIntraPeriod == 0, "Intra period must be more than GOP size, or -1 , not 0" ); 1568 2453 #endif 1569 #if ALLOW_RECOVERY_POINT_AS_RAP1570 2454 xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 3, "Decoding Refresh Type must be comprised between 0 and 3 included" ); 1571 2455 if(m_iDecodingRefreshType == 3) … … 1573 2457 xConfirmPara( !m_recoveryPointSEIEnabled, "When using RecoveryPointSEI messages as RA points, recoveryPointSEI must be enabled" ); 1574 2458 } 2459 2460 if (m_isField) 2461 { 2462 if (!m_pictureTimingSEIEnabled) 2463 { 2464 fprintf(stderr, "****************************************************************************\n"); 2465 fprintf(stderr, "** WARNING: Picture Timing SEI should be enabled for field coding! **\n"); 2466 fprintf(stderr, "****************************************************************************\n"); 2467 } 2468 } 2469 2470 if(m_crossComponentPredictionEnabledFlag && (m_chromaFormatIDC != CHROMA_444)) 2471 { 2472 fprintf(stderr, "****************************************************************************\n"); 2473 fprintf(stderr, "** WARNING: Cross-component prediction is specified for 4:4:4 format only **\n"); 2474 fprintf(stderr, "****************************************************************************\n"); 2475 2476 m_crossComponentPredictionEnabledFlag = false; 2477 } 2478 2479 if ( m_CUTransquantBypassFlagForce && m_bUseHADME ) 2480 { 2481 fprintf(stderr, "****************************************************************************\n"); 2482 fprintf(stderr, "** WARNING: --HadamardME has been disabled due to the enabling of **\n"); 2483 fprintf(stderr, "** --CUTransquantBypassFlagForce **\n"); 2484 fprintf(stderr, "****************************************************************************\n"); 2485 2486 m_bUseHADME = false; // this has been disabled so that the lambda is calculated slightly differently for lossless modes (as a result of JCTVC-R0104). 2487 } 2488 2489 xConfirmPara (m_log2MaxTransformSkipBlockSize < 2, "Transform Skip Log2 Max Size must be at least 2 (4x4)"); 2490 2491 if (m_log2MaxTransformSkipBlockSize!=2 && m_useTransformSkipFast) 2492 { 2493 fprintf(stderr, "***************************************************************************\n"); 2494 fprintf(stderr, "** WARNING: Transform skip fast is enabled (which only tests NxN splits),**\n"); 2495 fprintf(stderr, "** but transform skip log2 max size is not 2 (4x4) **\n"); 2496 fprintf(stderr, "** It may be better to disable transform skip fast mode **\n"); 2497 fprintf(stderr, "***************************************************************************\n"); 2498 } 2499 #if NH_MV 2500 for( Int layer = 0; layer < m_numberOfLayers; layer++ ) 2501 { 2502 xConfirmPara( m_iQP[layer] < -6 * (m_internalBitDepth[CHANNEL_TYPE_LUMA] - 8) || m_iQP[layer] > 51, "QP exceeds supported range (-QpBDOffsety to 51)" ); 2503 xConfirmPara( m_DeblockingFilterMetric && (m_bLoopFilterDisable[layer] || m_loopFilterOffsetInPPS), "If DeblockingFilterMetric is true then both LoopFilterDisable and LoopFilterOffsetInPPS must be 0"); 2504 } 1575 2505 #else 1576 xConfirmPara( m_iDecodingRefreshType < 0 || m_iDecodingRefreshType > 2, "Decoding Refresh Type must be equal to 0, 1 or 2" ); 1577 #endif 1578 #if H_MV 1579 for( Int layer = 0; layer < m_numberOfLayers; layer++ ) 1580 { 1581 xConfirmPara( m_iQP[layer] < -6 * (m_internalBitDepthY - 8) || m_iQP[layer] > 51, "QP exceeds supported range (-QpBDOffsety to 51)" ); 1582 } 1583 #else 1584 xConfirmPara( m_iQP < -6 * (m_internalBitDepthY - 8) || m_iQP > 51, "QP exceeds supported range (-QpBDOffsety to 51)" ); 1585 #endif 1586 xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 || m_loopFilterBetaOffsetDiv2 > 6, "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)"); 1587 xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 || m_loopFilterTcOffsetDiv2 > 6, "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)"); 2506 xConfirmPara( m_iQP < -6 * (m_internalBitDepth[CHANNEL_TYPE_LUMA] - 8) || m_iQP > 51, "QP exceeds supported range (-QpBDOffsety to 51)" ); 2507 xConfirmPara( m_DeblockingFilterMetric && (m_bLoopFilterDisable || m_loopFilterOffsetInPPS), "If DeblockingFilterMetric is true then both LoopFilterDisable and LoopFilterOffsetInPPS must be 0"); 2508 #endif 2509 2510 xConfirmPara( m_loopFilterBetaOffsetDiv2 < -6 || m_loopFilterBetaOffsetDiv2 > 6, "Loop Filter Beta Offset div. 2 exceeds supported range (-6 to 6)"); 2511 xConfirmPara( m_loopFilterTcOffsetDiv2 < -6 || m_loopFilterTcOffsetDiv2 > 6, "Loop Filter Tc Offset div. 2 exceeds supported range (-6 to 6)"); 1588 2512 xConfirmPara( m_iFastSearch < 0 || m_iFastSearch > 2, "Fast Search Mode is not supported value (0:Full search 1:Diamond 2:PMVFAST)" ); 1589 2513 xConfirmPara( m_iSearchRange < 0 , "Search Range must be more than 0" ); 1590 2514 xConfirmPara( m_bipredSearchRange < 0 , "Search Range must be more than 0" ); 1591 #if H_MV2515 #if NH_MV 1592 2516 xConfirmPara( m_iVerticalDisparitySearchRange <= 0 , "Vertical Disparity Search Range must be more than 0" ); 1593 2517 #endif … … 1603 2527 if (m_iDecodingRefreshType == 2) 1604 2528 { 1605 #if H_MV2529 #if NH_MV 1606 2530 for (Int i = 0; i < m_numberOfLayers; i++ ) 1607 2531 { … … 1618 2542 xConfirmPara( (m_iSourceWidth % (m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame width must be a multiple of the minimum CU size"); 1619 2543 xConfirmPara( (m_iSourceHeight % (m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)))!=0, "Resulting coded frame height must be a multiple of the minimum CU size"); 1620 2544 1621 2545 xConfirmPara( m_uiQuadtreeTULog2MinSize < 2, "QuadtreeTULog2MinSize must be 2 or greater."); 1622 2546 xConfirmPara( m_uiQuadtreeTULog2MaxSize > 5, "QuadtreeTULog2MaxSize must be 5 or smaller."); 1623 xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth, "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller.");1624 1625 2547 xConfirmPara( m_uiQuadtreeTULog2MaxSize < m_uiQuadtreeTULog2MinSize, "QuadtreeTULog2MaxSize must be greater than or equal to m_uiQuadtreeTULog2MinSize."); 1626 xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUWidth >>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS 1627 xConfirmPara( (1<<m_uiQuadtreeTULog2MinSize)>(m_uiMaxCUHeight>>(m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than minimum CU size" ); // HS 1628 xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUWidth >> m_uiMaxCUDepth ), "Minimum CU width must be greater than minimum transform size." ); 1629 xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) > ( m_uiMaxCUHeight >> m_uiMaxCUDepth ), "Minimum CU height must be greater than minimum transform size." ); 2548 xConfirmPara( (1<<m_uiQuadtreeTULog2MaxSize) > m_uiMaxCUWidth, "QuadtreeTULog2MaxSize must be log2(maxCUSize) or smaller."); 2549 xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) >= ( m_uiMaxCUWidth >> (m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than or equal to minimum CU size" ); 2550 xConfirmPara( ( 1 << m_uiQuadtreeTULog2MinSize ) >= ( m_uiMaxCUHeight >> (m_uiMaxCUDepth-1)), "QuadtreeTULog2MinSize must not be greater than or equal to minimum CU size" ); 1630 2551 xConfirmPara( m_uiQuadtreeTUMaxDepthInter < 1, "QuadtreeTUMaxDepthInter must be greater than or equal to 1" ); 1631 2552 xConfirmPara( m_uiMaxCUWidth < ( 1 << (m_uiQuadtreeTULog2MinSize + m_uiQuadtreeTUMaxDepthInter - 1) ), "QuadtreeTUMaxDepthInter must be less than or equal to the difference between log2(maxCUSize) and QuadtreeTULog2MinSize plus 1" ); 1632 2553 xConfirmPara( m_uiQuadtreeTUMaxDepthIntra < 1, "QuadtreeTUMaxDepthIntra must be greater than or equal to 1" ); 1633 2554 xConfirmPara( m_uiMaxCUWidth < ( 1 << (m_uiQuadtreeTULog2MinSize + m_uiQuadtreeTUMaxDepthIntra - 1) ), "QuadtreeTUMaxDepthInter must be less than or equal to the difference between log2(maxCUSize) and QuadtreeTULog2MinSize plus 1" ); 1634 2555 1635 2556 xConfirmPara( m_maxNumMergeCand < 1, "MaxNumMergeCand must be 1 or greater."); 1636 2557 xConfirmPara( m_maxNumMergeCand > 5, "MaxNumMergeCand must be 5 or smaller."); 1637 1638 #if H_3D_ARP 1639 #endif 1640 #if H_3D_SPIVMP 2558 #if NH_3D 1641 2559 xConfirmPara( m_log2SubPbSizeMinus3 < 0, "Log2SubPbSizeMinus3 must be equal to 0 or greater."); 1642 2560 xConfirmPara( m_log2SubPbSizeMinus3 > 3, "Log2SubPbSizeMinus3 must be equal to 3 or smaller."); … … 1648 2566 #endif 1649 2567 #if ADAPTIVE_QP_SELECTION 1650 #if H_MV2568 #if NH_MV 1651 2569 for( Int layer = 0; layer < m_numberOfLayers; layer++ ) 1652 2570 { … … 1661 2579 if( m_usePCM) 1662 2580 { 2581 for (UInt channelType = 0; channelType < MAX_NUM_CHANNEL_TYPE; channelType++) 2582 { 2583 xConfirmPara(((m_MSBExtendedBitDepth[channelType] > m_internalBitDepth[channelType]) && m_bPCMInputBitDepthFlag), "PCM bit depth cannot be greater than internal bit depth (PCMInputBitDepthFlag cannot be used when InputBitDepth or MSBExtendedBitDepth > InternalBitDepth)"); 2584 } 1663 2585 xConfirmPara( m_uiPCMLog2MinSize < 3, "PCMLog2MinSize must be 3 or greater."); 1664 2586 xConfirmPara( m_uiPCMLog2MinSize > 5, "PCMLog2MinSize must be 5 or smaller."); … … 1677 2599 xConfirmPara( m_sliceSegmentArgument < 1 , "SliceSegmentArgument should be larger than or equal to 1" ); 1678 2600 } 1679 2601 1680 2602 Bool tileFlag = (m_numTileColumnsMinus1 > 0 || m_numTileRowsMinus1 > 0 ); 1681 xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together"); 1682 1683 //TODO:ChromaFmt assumes 4:2:0 below 1684 xConfirmPara( m_iSourceWidth % TComSPS::getWinUnitX(CHROMA_420) != 0, "Picture width must be an integer multiple of the specified chroma subsampling"); 1685 xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(CHROMA_420) != 0, "Picture height must be an integer multiple of the specified chroma subsampling"); 1686 1687 xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(CHROMA_420) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling"); 1688 xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(CHROMA_420) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling"); 1689 1690 xConfirmPara( m_confWinLeft % TComSPS::getWinUnitX(CHROMA_420) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling"); 1691 xConfirmPara( m_confWinRight % TComSPS::getWinUnitX(CHROMA_420) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling"); 1692 xConfirmPara( m_confWinTop % TComSPS::getWinUnitY(CHROMA_420) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling"); 1693 xConfirmPara( m_confWinBottom % TComSPS::getWinUnitY(CHROMA_420) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling"); 2603 if (m_profile!=Profile::HIGHTHROUGHPUTREXT) 2604 { 2605 xConfirmPara( tileFlag && m_iWaveFrontSynchro, "Tile and Wavefront can not be applied together, except in the High Throughput Intra 4:4:4 16 profile"); 2606 } 2607 2608 xConfirmPara( m_iSourceWidth % TComSPS::getWinUnitX(m_chromaFormatIDC) != 0, "Picture width must be an integer multiple of the specified chroma subsampling"); 2609 xConfirmPara( m_iSourceHeight % TComSPS::getWinUnitY(m_chromaFormatIDC) != 0, "Picture height must be an integer multiple of the specified chroma subsampling"); 2610 2611 xConfirmPara( m_aiPad[0] % TComSPS::getWinUnitX(m_chromaFormatIDC) != 0, "Horizontal padding must be an integer multiple of the specified chroma subsampling"); 2612 xConfirmPara( m_aiPad[1] % TComSPS::getWinUnitY(m_chromaFormatIDC) != 0, "Vertical padding must be an integer multiple of the specified chroma subsampling"); 2613 2614 xConfirmPara( m_confWinLeft % TComSPS::getWinUnitX(m_chromaFormatIDC) != 0, "Left conformance window offset must be an integer multiple of the specified chroma subsampling"); 2615 xConfirmPara( m_confWinRight % TComSPS::getWinUnitX(m_chromaFormatIDC) != 0, "Right conformance window offset must be an integer multiple of the specified chroma subsampling"); 2616 xConfirmPara( m_confWinTop % TComSPS::getWinUnitY(m_chromaFormatIDC) != 0, "Top conformance window offset must be an integer multiple of the specified chroma subsampling"); 2617 xConfirmPara( m_confWinBottom % TComSPS::getWinUnitY(m_chromaFormatIDC) != 0, "Bottom conformance window offset must be an integer multiple of the specified chroma subsampling"); 1694 2618 1695 2619 xConfirmPara( m_defaultDisplayWindowFlag && !m_vuiParametersPresentFlag, "VUI needs to be enabled for default display window"); … … 1697 2621 if (m_defaultDisplayWindowFlag) 1698 2622 { 1699 xConfirmPara( m_defDispWinLeftOffset % TComSPS::getWinUnitX( CHROMA_420) != 0, "Left default display window offset must be an integer multiple of the specified chroma subsampling");1700 xConfirmPara( m_defDispWinRightOffset % TComSPS::getWinUnitX( CHROMA_420) != 0, "Right default display window offset must be an integer multiple of the specified chroma subsampling");1701 xConfirmPara( m_defDispWinTopOffset % TComSPS::getWinUnitY( CHROMA_420) != 0, "Top default display window offset must be an integer multiple of the specified chroma subsampling");1702 xConfirmPara( m_defDispWinBottomOffset % TComSPS::getWinUnitY( CHROMA_420) != 0, "Bottom default display window offset must be an integer multiple of the specified chroma subsampling");1703 } 1704 1705 #if H_3D2623 xConfirmPara( m_defDispWinLeftOffset % TComSPS::getWinUnitX(m_chromaFormatIDC) != 0, "Left default display window offset must be an integer multiple of the specified chroma subsampling"); 2624 xConfirmPara( m_defDispWinRightOffset % TComSPS::getWinUnitX(m_chromaFormatIDC) != 0, "Right default display window offset must be an integer multiple of the specified chroma subsampling"); 2625 xConfirmPara( m_defDispWinTopOffset % TComSPS::getWinUnitY(m_chromaFormatIDC) != 0, "Top default display window offset must be an integer multiple of the specified chroma subsampling"); 2626 xConfirmPara( m_defDispWinBottomOffset % TComSPS::getWinUnitY(m_chromaFormatIDC) != 0, "Bottom default display window offset must be an integer multiple of the specified chroma subsampling"); 2627 } 2628 2629 #if NH_3D 1706 2630 xConfirmPara( m_pchCameraParameterFile == 0 , "CameraParameterFile must be given"); 1707 2631 xConfirmPara( m_pchBaseViewCameraNumbers == 0 , "BaseViewCameraNumbers must be given" ); 1708 2632 xConfirmPara( m_iNumberOfViews != m_cCameraData.getBaseViewNumbers().size() , "Number of Views in BaseViewCameraNumbers must be equal to NumberOfViews" ); 1709 2633 xConfirmPara ( m_iCodedCamParPrecision < 0 || m_iCodedCamParPrecision > 5, "CodedCamParsPrecision must be in range of 0..5" ); 1710 #if H_3D_VSO2634 #if NH_3D_VSO 1711 2635 if( m_bUseVSO ) 1712 2636 { … … 1722 2646 ui >>= 1; 1723 2647 if( (ui & 1) == 1) 2648 { 1724 2649 xConfirmPara( ui != 1 , "Width should be 2^n"); 2650 } 1725 2651 } 1726 2652 ui = m_uiMaxCUHeight; … … 1729 2655 ui >>= 1; 1730 2656 if( (ui & 1) == 1) 2657 { 1731 2658 xConfirmPara( ui != 1 , "Height should be 2^n"); 1732 } 1733 1734 #if H_MV 2659 } 2660 } 2661 2662 #if NH_MV 1735 2663 // validate that POC of same frame is identical across multiple layers 1736 2664 Bool bErrorMvePoc = false; … … 1880 2808 Int* m_numReorderPics = m_numReorderPicsMvc [layer]; // It is not a member, but this name helps avoiding code duplication !!! 1881 2809 #endif 2810 1882 2811 /* if this is an intra-only sequence, ie IntraPeriod=1, don't verify the GOP structure 1883 2812 * This permits the ability to omit a GOP structure specification */ 1884 #if H_MV1885 if (m_iIntraPeriod[layer] == 1 && m_GOPList[0].m_POC == -1) {2813 #if NH_MV 2814 if (m_iIntraPeriod[layer] == 1 && m_GOPList[0].m_POC == -1) 1886 2815 #else 1887 if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) { 1888 #endif 2816 if (m_iIntraPeriod == 1 && m_GOPList[0].m_POC == -1) 2817 #endif 2818 { 1889 2819 m_GOPList[0] = GOPEntry(); 1890 2820 m_GOPList[0].m_QPFactor = 1; … … 1894 2824 m_GOPList[0].m_numRefPicsActive = 4; 1895 2825 } 1896 2826 else 2827 { 2828 xConfirmPara( m_intraConstraintFlag, "IntraConstraintFlag cannot be 1 for inter sequences"); 2829 } 2830 1897 2831 Bool verifiedGOP=false; 1898 2832 Bool errorGOP=false; … … 1906 2840 } 1907 2841 Bool isOK[MAX_GOP]; 1908 for(Int i=0; i<MAX_GOP; i++) 2842 for(Int i=0; i<MAX_GOP; i++) 1909 2843 { 1910 2844 isOK[i]=false; 1911 2845 } 1912 2846 Int numOK=0; 1913 #if H_MV2847 #if NH_MV 1914 2848 xConfirmPara( m_iIntraPeriod[layer] >=0&&(m_iIntraPeriod[layer]%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" ); 1915 2849 #else 1916 xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" );2850 xConfirmPara( m_iIntraPeriod >=0&&(m_iIntraPeriod%m_iGOPSize!=0), "Intra period must be a multiple of GOPSize, or -1" ); 1917 2851 #endif 1918 2852 … … 1924 2858 } 1925 2859 } 1926 1927 #if H_MV1928 if ( (m_iIntraPeriod[layer] != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent &&(!m_bLoopFilterDisable[layer]) )2860 2861 #if NH_MV 2862 if ( (m_iIntraPeriod[layer] != 1) && !m_loopFilterOffsetInPPS && (!m_bLoopFilterDisable[layer]) ) 1929 2863 #else 1930 if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && m_DeblockingFilterControlPresent &&(!m_bLoopFilterDisable) )2864 if ( (m_iIntraPeriod != 1) && !m_loopFilterOffsetInPPS && (!m_bLoopFilterDisable) ) 1931 2865 #endif 1932 2866 { … … 1937 2871 } 1938 2872 } 2873 1939 2874 m_extraRPSs=0; 1940 2875 //start looping through frames in coding order until we can verify that the GOP structure is correct. 1941 while(!verifiedGOP&&!errorGOP) 2876 while(!verifiedGOP&&!errorGOP) 1942 2877 { 1943 2878 Int curGOP = (checkGOP-1)%m_iGOPSize; 1944 Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC; 1945 if(m_GOPList[curGOP].m_POC<0) 1946 { 1947 #if H_MV2879 Int curPOC = ((checkGOP-1)/m_iGOPSize)*m_iGOPSize + m_GOPList[curGOP].m_POC; 2880 if(m_GOPList[curGOP].m_POC<0) 2881 { 2882 #if NH_MV 1948 2883 printf("\nError: found fewer Reference Picture Sets than GOPSize for layer %d\n", layer ); 1949 2884 #else … … 1952 2887 errorGOP=true; 1953 2888 } 1954 else 2889 else 1955 2890 { 1956 2891 //check that all reference pictures are available, or have a POC < 0 meaning they might be available in the next GOP. 1957 2892 Bool beforeI = false; 1958 for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 2893 for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 1959 2894 { 1960 2895 Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i]; … … 1963 2898 beforeI=true; 1964 2899 } 1965 else 2900 else 1966 2901 { 1967 2902 Bool found=false; 1968 for(Int j=0; j<numRefs; j++) 2903 for(Int j=0; j<numRefs; j++) 1969 2904 { 1970 if(refList[j]==absPOC) 2905 if(refList[j]==absPOC) 1971 2906 { 1972 2907 found=true; … … 1986 2921 if(!found) 1987 2922 { 1988 #if H_MV2923 #if NH_MV 1989 2924 printf("\nError: ref pic %d is not available for GOP frame %d of layer %d\n", m_GOPList[curGOP].m_referencePics[i], curGOP+1, layer); 1990 2925 #else … … 1998 2933 { 1999 2934 //all ref frames were present 2000 if(!isOK[curGOP]) 2935 if(!isOK[curGOP]) 2001 2936 { 2002 2937 numOK++; … … 2008 2943 } 2009 2944 } 2010 else 2945 else 2011 2946 { 2012 2947 //create a new GOPEntry for this frame containing all the reference pictures that were available (POC > 0) 2013 2948 m_GOPList[m_iGOPSize+m_extraRPSs]=m_GOPList[curGOP]; 2014 2949 Int newRefs=0; 2015 for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 2950 for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 2016 2951 { 2017 2952 Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i]; … … 2024 2959 } 2025 2960 Int numPrefRefs = m_GOPList[curGOP].m_numRefPicsActive; 2026 2961 2027 2962 for(Int offset = -1; offset>-checkGOP; offset--) 2028 2963 { … … 2040 2975 } 2041 2976 } 2042 for(Int i=0; i<newRefs; i++) 2977 for(Int i=0; i<newRefs; i++) 2043 2978 { 2044 2979 if(m_GOPList[m_iGOPSize+m_extraRPSs].m_referencePics[i]==offPOC-curPOC) … … 2047 2982 } 2048 2983 } 2049 if(newRef) 2984 if(newRef) 2050 2985 { 2051 2986 Int insertPoint=newRefs; … … 2095 3030 Int refPics = m_GOPList[rIdx].m_numRefPics; 2096 3031 Int newIdc=0; 2097 for(Int i = 0; i<= refPics; i++) 3032 for(Int i = 0; i<= refPics; i++) 2098 3033 { 2099 3034 Int deltaPOC = ((i != refPics)? m_GOPList[rIdx].m_referencePics[i] : 0); // check if the reference abs POC is >= 0 … … 2117 3052 newIdc++; 2118 3053 } 2119 m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1; 3054 m_GOPList[m_iGOPSize+m_extraRPSs].m_interRPSPrediction = 1; 2120 3055 m_GOPList[m_iGOPSize+m_extraRPSs].m_numRefIdc = newIdc; 2121 m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC; 3056 m_GOPList[m_iGOPSize+m_extraRPSs].m_deltaRPS = refPOC - m_GOPList[m_iGOPSize+m_extraRPSs].m_POC; 2122 3057 } 2123 3058 curGOP=m_iGOPSize+m_extraRPSs; … … 2125 3060 } 2126 3061 numRefs=0; 2127 for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 3062 for(Int i = 0; i< m_GOPList[curGOP].m_numRefPics; i++) 2128 3063 { 2129 3064 Int absPOC = curPOC+m_GOPList[curGOP].m_referencePics[i]; 2130 if(absPOC >= 0) 3065 if(absPOC >= 0) 2131 3066 { 2132 3067 refList[numRefs]=absPOC; … … 2141 3076 xConfirmPara(errorGOP,"Invalid GOP structure given"); 2142 3077 m_maxTempLayer = 1; 2143 for(Int i=0; i<m_iGOPSize; i++) 3078 for(Int i=0; i<m_iGOPSize; i++) 2144 3079 { 2145 3080 if(m_GOPList[i].m_temporalId >= m_maxTempLayer) … … 2147 3082 m_maxTempLayer = m_GOPList[i].m_temporalId+1; 2148 3083 } 2149 xConfirmPara(m_GOPList[i].m_sliceType!='B' &&m_GOPList[i].m_sliceType!='P'&&m_GOPList[i].m_sliceType!='I', "Slice type must be equal to B or P or I");3084 xConfirmPara(m_GOPList[i].m_sliceType!='B' && m_GOPList[i].m_sliceType!='P' && m_GOPList[i].m_sliceType!='I', "Slice type must be equal to B or P or I"); 2150 3085 } 2151 3086 for(Int i=0; i<MAX_TLAYER; i++) … … 2154 3089 m_maxDecPicBuffering[i] = 1; 2155 3090 } 2156 for(Int i=0; i<m_iGOPSize; i++) 3091 for(Int i=0; i<m_iGOPSize; i++) 2157 3092 { 2158 3093 if(m_GOPList[i].m_numRefPics+1 > m_maxDecPicBuffering[m_GOPList[i].m_temporalId]) … … 2160 3095 m_maxDecPicBuffering[m_GOPList[i].m_temporalId] = m_GOPList[i].m_numRefPics + 1; 2161 3096 } 2162 Int highestDecodingNumberWithLowerPOC = 0; 3097 Int highestDecodingNumberWithLowerPOC = 0; 2163 3098 for(Int j=0; j<m_iGOPSize; j++) 2164 3099 { … … 2171 3106 for(Int j=0; j<highestDecodingNumberWithLowerPOC; j++) 2172 3107 { 2173 if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId && 3108 if(m_GOPList[j].m_temporalId <= m_GOPList[i].m_temporalId && 2174 3109 m_GOPList[j].m_POC > m_GOPList[i].m_POC) 2175 3110 { 2176 3111 numReorder++; 2177 3112 } 2178 } 3113 } 2179 3114 if(numReorder > m_numReorderPics[m_GOPList[i].m_temporalId]) 2180 3115 { … … 2182 3117 } 2183 3118 } 2184 for(Int i=0; i<MAX_TLAYER-1; i++) 3119 for(Int i=0; i<MAX_TLAYER-1; i++) 2185 3120 { 2186 3121 // a lower layer can not have higher value of m_numReorderPics than a higher layer … … 2201 3136 } 2202 3137 2203 2204 3138 // the value of num_reorder_pics[ i ] shall be in the range of 0 to max_dec_pic_buffering[ i ] - 1, inclusive 2205 3139 if(m_numReorderPics[MAX_TLAYER-1] > m_maxDecPicBuffering[MAX_TLAYER-1] - 1) … … 2209 3143 2210 3144 if(m_vuiParametersPresentFlag && m_bitstreamRestrictionFlag) 2211 { 3145 { 2212 3146 Int PicSizeInSamplesY = m_iSourceWidth * m_iSourceHeight; 2213 3147 if(tileFlag) … … 2221 3155 maxTileWidth = m_uiMaxCUWidth*((widthInCU+m_numTileColumnsMinus1)/(m_numTileColumnsMinus1+1)); 2222 3156 maxTileHeight = m_uiMaxCUHeight*((heightInCU+m_numTileRowsMinus1)/(m_numTileRowsMinus1+1)); 2223 // if only the last tile-row is one treeblock higher than the others 3157 // if only the last tile-row is one treeblock higher than the others 2224 3158 // the maxTileHeight becomes smaller if the last row of treeblocks has lower height than the others 2225 3159 if(!((heightInCU-1)%(m_numTileRowsMinus1+1))) 2226 3160 { 2227 3161 maxTileHeight = maxTileHeight - m_uiMaxCUHeight + (m_iSourceHeight % m_uiMaxCUHeight); 2228 } 2229 // if only the last tile-column is one treeblock wider than the others 2230 // the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others 3162 } 3163 // if only the last tile-column is one treeblock wider than the others 3164 // the maxTileWidth becomes smaller if the last column of treeblocks has lower width than the others 2231 3165 if(!((widthInCU-1)%(m_numTileColumnsMinus1+1))) 2232 3166 { … … 2272 3206 m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/((2*m_iSourceHeight+m_iSourceWidth)*m_uiMaxCUHeight)-4; 2273 3207 } 2274 else if(m_sliceMode == 1)3208 else if(m_sliceMode == FIXED_NUMBER_OF_CTU) 2275 3209 { 2276 3210 m_minSpatialSegmentationIdc = 4*PicSizeInSamplesY/(m_sliceArgument*m_uiMaxCUWidth*m_uiMaxCUHeight)-4; … … 2281 3215 } 2282 3216 } 3217 2283 3218 xConfirmPara( m_iWaveFrontSynchro < 0, "WaveFrontSynchro cannot be negative" ); 2284 xConfirmPara( m_iWaveFrontSubstreams <= 0, "WaveFrontSubstreams must be positive" );2285 xConfirmPara( m_iWaveFrontSubstreams > 1 && !m_iWaveFrontSynchro, "Must have WaveFrontSynchro > 0 in order to have WaveFrontSubstreams > 1" );2286 3219 2287 3220 xConfirmPara( m_decodedPictureHashSEIEnabled<0 || m_decodedPictureHashSEIEnabled>3, "this hash type is not correct!\n"); … … 2299 3232 } 2300 3233 3234 if (m_kneeSEIEnabled && !m_kneeSEICancelFlag) 3235 { 3236 xConfirmPara( m_kneeSEINumKneePointsMinus1 < 0 || m_kneeSEINumKneePointsMinus1 > 998, "SEIKneeFunctionNumKneePointsMinus1 must be in the range of 0 to 998"); 3237 for ( UInt i=0; i<=m_kneeSEINumKneePointsMinus1; i++ ) 3238 { 3239 xConfirmPara( m_kneeSEIInputKneePoint[i] < 1 || m_kneeSEIInputKneePoint[i] > 999, "SEIKneeFunctionInputKneePointValue must be in the range of 1 to 999"); 3240 xConfirmPara( m_kneeSEIOutputKneePoint[i] < 0 || m_kneeSEIOutputKneePoint[i] > 1000, "SEIKneeFunctionInputKneePointValue must be in the range of 0 to 1000"); 3241 if ( i > 0 ) 3242 { 3243 xConfirmPara( m_kneeSEIInputKneePoint[i-1] >= m_kneeSEIInputKneePoint[i], "The i-th SEIKneeFunctionInputKneePointValue must be greater than the (i-1)-th value"); 3244 xConfirmPara( m_kneeSEIOutputKneePoint[i-1] > m_kneeSEIOutputKneePoint[i], "The i-th SEIKneeFunctionOutputKneePointValue must be greater than or equal to the (i-1)-th value"); 3245 } 3246 } 3247 } 3248 2301 3249 if ( m_RCEnableRateControl ) 2302 3250 { … … 2311 3259 xConfirmPara( m_uiDeltaQpRD > 0, "Rate control cannot be used together with slice level multiple-QP optimization!\n" ); 2312 3260 } 2313 #if H_MV3261 #if NH_MV 2314 3262 // VPS VUI 2315 3263 for(Int i = 0; i < MAX_VPS_OP_SETS_PLUS1; i++ ) … … 2337 3285 2338 3286 xConfirmPara(m_log2ParallelMergeLevel < 2, "Log2ParallelMergeLevel should be larger than or equal to 2"); 3287 2339 3288 if (m_framePackingSEIEnabled) 2340 3289 { 2341 3290 xConfirmPara(m_framePackingSEIType < 3 || m_framePackingSEIType > 5 , "SEIFramePackingType must be in rage 3 to 5"); 2342 3291 } 2343 2344 #if H_MV 3292 #if NH_MV 2345 3293 } 2346 3294 } … … 2363 3311 } 2364 3312 #endif 3313 3314 if (m_segmentedRectFramePackingSEIEnabled) 3315 { 3316 xConfirmPara(m_framePackingSEIEnabled > 0 , "SEISegmentedRectFramePacking must be 0 when SEIFramePacking is 1"); 3317 } 3318 3319 if((m_numTileColumnsMinus1 <= 0) && (m_numTileRowsMinus1 <= 0) && m_tmctsSEIEnabled) 3320 { 3321 printf("Warning: SEITempMotionConstrainedTileSets is set to false to disable temporal motion-constrained tile sets SEI message because there are no tiles enabled.\n"); 3322 m_tmctsSEIEnabled = false; 3323 } 3324 3325 if(m_timeCodeSEIEnabled) 3326 { 3327 xConfirmPara(m_timeCodeSEINumTs > MAX_TIMECODE_SEI_SETS, "Number of time sets cannot exceed 3"); 3328 } 3329 2365 3330 #undef xConfirmPara 2366 3331 if (check_failed) … … 2370 3335 } 2371 3336 2372 /** \todo use of global variables should be removed later 2373 */ 2374 Void TAppEncCfg::xSetGlobal() 3337 const Char *profileToString(const Profile::Name profile) 2375 3338 { 2376 // set max CU width & height 2377 g_uiMaxCUWidth = m_uiMaxCUWidth; 2378 g_uiMaxCUHeight = m_uiMaxCUHeight; 2379 2380 // compute actual CU depth with respect to config depth and max transform size 2381 g_uiAddCUDepth = 0; 2382 while( (m_uiMaxCUWidth>>m_uiMaxCUDepth) > ( 1 << ( m_uiQuadtreeTULog2MinSize + g_uiAddCUDepth ) ) ) g_uiAddCUDepth++; 2383 2384 m_uiMaxCUDepth += g_uiAddCUDepth; 2385 g_uiAddCUDepth++; 2386 g_uiMaxCUDepth = m_uiMaxCUDepth; 2387 2388 // set internal bit-depth and constants 2389 g_bitDepthY = m_internalBitDepthY; 2390 g_bitDepthC = m_internalBitDepthC; 2391 2392 g_uiPCMBitDepthLuma = m_bPCMInputBitDepthFlag ? m_inputBitDepthY : m_internalBitDepthY; 2393 g_uiPCMBitDepthChroma = m_bPCMInputBitDepthFlag ? m_inputBitDepthC : m_internalBitDepthC; 3339 static const UInt numberOfProfiles = sizeof(strToProfile)/sizeof(*strToProfile); 3340 3341 for (UInt profileIndex = 0; profileIndex < numberOfProfiles; profileIndex++) 3342 { 3343 if (strToProfile[profileIndex].value == profile) 3344 { 3345 return strToProfile[profileIndex].str; 3346 } 3347 } 3348 3349 //if we get here, we didn't find this profile in the list - so there is an error 3350 std::cerr << "ERROR: Unknown profile \"" << profile << "\" in profileToString" << std::endl; 3351 assert(false); 3352 exit(1); 3353 return ""; 2394 3354 } 2395 3355 … … 2397 3357 { 2398 3358 printf("\n"); 2399 #if H_MV3359 #if NH_MV 2400 3360 for( Int layer = 0; layer < m_numberOfLayers; layer++) 2401 3361 { 2402 printf("Input File %i : %s\n", layer, m_pchInputFileList[layer]);3362 printf("Input File %i : %s\n", layer, m_pchInputFileList[layer]); 2403 3363 } 2404 3364 #else 2405 printf("Input File : %s\n", m_pchInputFile );2406 #endif 2407 printf("Bitstream File : %s\n", m_pchBitstreamFile );2408 #if H_MV3365 printf("Input File : %s\n", m_pchInputFile ); 3366 #endif 3367 printf("Bitstream File : %s\n", m_pchBitstreamFile ); 3368 #if NH_MV 2409 3369 for( Int layer = 0; layer < m_numberOfLayers; layer++) 2410 3370 { 2411 printf("Reconstruction File %i : %s\n", layer, m_pchReconFileList[layer]);3371 printf("Reconstruction File %i : %s\n", layer, m_pchReconFileList[layer]); 2412 3372 } 2413 3373 #else 2414 printf("Reconstruction File : %s\n", m_pchReconFile );2415 #endif 2416 #if H_MV3374 printf("Reconstruction File : %s\n", m_pchReconFile ); 3375 #endif 3376 #if NH_MV 2417 3377 xPrintParaVector( "NuhLayerId" , m_layerIdInNuh ); 2418 3378 if ( m_targetEncLayerIdList.size() > 0) … … 2421 3381 } 2422 3382 xPrintParaVector( "ViewIdVal" , m_viewId ); 2423 xPrintParaVector( "ViewOrderI ndex", m_viewOrderIndex );3383 xPrintParaVector( "ViewOrderIdx" , m_viewOrderIndex ); 2424 3384 xPrintParaVector( "AuxId", m_auxId ); 2425 3385 #endif 2426 #if H_3D2427 xPrintParaVector( "Depth Flag", m_depthFlag );2428 printf("Coded Camera Param. Precision : %d\n", m_iCodedCamParPrecision);2429 #endif 2430 #if H_MV3386 #if NH_3D 3387 xPrintParaVector( "DepthLayerFlag", m_depthFlag ); 3388 printf("Coded Camera Param. Precision : %d\n", m_iCodedCamParPrecision); 3389 #endif 3390 #if NH_MV 2431 3391 xPrintParaVector( "QP" , m_fQP ); 2432 3392 xPrintParaVector( "LoopFilterDisable", m_bLoopFilterDisable ); 2433 3393 xPrintParaVector( "SAO" , m_bUseSAO ); 2434 3394 #endif 2435 printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confWinLeft - m_confWinRight, m_iSourceHeight - m_confWinTop - m_confWinBottom, m_iFrameRate ); 2436 printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate ); 3395 3396 printf("Real Format : %dx%d %dHz\n", m_iSourceWidth - m_confWinLeft - m_confWinRight, m_iSourceHeight - m_confWinTop - m_confWinBottom, m_iFrameRate ); 3397 printf("Internal Format : %dx%d %dHz\n", m_iSourceWidth, m_iSourceHeight, m_iFrameRate ); 3398 printf("Sequence PSNR output : %s\n", (m_printMSEBasedSequencePSNR ? "Linear average, MSE-based" : "Linear average only") ); 3399 printf("Sequence MSE output : %s\n", (m_printSequenceMSE ? "Enabled" : "Disabled") ); 3400 printf("Frame MSE output : %s\n", (m_printFrameMSE ? "Enabled" : "Disabled") ); 3401 printf("Cabac-zero-word-padding : %s\n", (m_cabacZeroWordPaddingEnabled? "Enabled" : "Disabled") ); 2437 3402 if (m_isField) 2438 3403 { 2439 printf("Frame/Field : Field based coding\n"); 2440 printf("Field index : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded ); 2441 if (m_isTopFieldFirst) 2442 { 2443 printf("Field Order : Top field first\n"); 3404 printf("Frame/Field : Field based coding\n"); 3405 printf("Field index : %u - %d (%d fields)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded ); 3406 printf("Field Order : %s field first\n", m_isTopFieldFirst?"Top":"Bottom"); 3407 3408 } 3409 else 3410 { 3411 printf("Frame/Field : Frame based coding\n"); 3412 printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded ); 3413 } 3414 #if NH_MV 3415 printf("Profile :"); 3416 for (Int i = 0; i < m_profiles.size(); i++) 3417 { 3418 Profile::Name m_profile = m_profiles[i]; 3419 3420 #endif 3421 if (m_profile == Profile::MAINREXT) 3422 { 3423 ExtendedProfileName validProfileName; 3424 if (m_onePictureOnlyConstraintFlag) 3425 { 3426 validProfileName = m_bitDepthConstraint == 8 ? MAIN_444_STILL_PICTURE : (m_bitDepthConstraint == 16 ? MAIN_444_16_STILL_PICTURE : NONE); 2444 3427 } 2445 3428 else 2446 3429 { 2447 printf("Field Order : Bottom field first\n"); 2448 } 2449 } 2450 else 2451 { 2452 printf("Frame/Field : Frame based coding\n"); 2453 printf("Frame index : %u - %d (%d frames)\n", m_FrameSkip, m_FrameSkip+m_framesToBeEncoded-1, m_framesToBeEncoded ); 2454 } 2455 printf("CU size / depth : %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth ); 2456 printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize ); 2457 printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter); 2458 printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra); 2459 printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize); 2460 printf("Motion search range : %d\n", m_iSearchRange ); 2461 #if H_MV 2462 printf("Disp search range restriction: %d\n", m_bUseDisparitySearchRangeRestriction ); 2463 printf("Vertical disp search range : %d\n", m_iVerticalDisparitySearchRange ); 2464 #endif 2465 #if H_MV 3430 const UInt intraIdx = m_intraConstraintFlag ? 1:0; 3431 const UInt bitDepthIdx = (m_bitDepthConstraint == 8 ? 0 : (m_bitDepthConstraint ==10 ? 1 : (m_bitDepthConstraint == 12 ? 2 : (m_bitDepthConstraint == 16 ? 3 : 4 )))); 3432 const UInt chromaFormatIdx = UInt(m_chromaFormatConstraint); 3433 validProfileName = (bitDepthIdx > 3 || chromaFormatIdx>3) ? NONE : validRExtProfileNames[intraIdx][bitDepthIdx][chromaFormatIdx]; 3434 } 3435 std::string rextSubProfile; 3436 if (validProfileName!=NONE) 3437 { 3438 rextSubProfile=enumToString(strToExtendedProfile, sizeof(strToExtendedProfile)/sizeof(*strToExtendedProfile), validProfileName); 3439 } 3440 if (rextSubProfile == "main_444_16") 3441 { 3442 rextSubProfile="main_444_16 [NON STANDARD]"; 3443 } 3444 #if NH_MV 3445 printf(" %s (%s) ", profileToString(m_profile), (rextSubProfile.empty())?"INVALID REXT PROFILE":rextSubProfile.c_str() ); 3446 #else 3447 printf("Profile : %s (%s)\n", profileToString(m_profile), (rextSubProfile.empty())?"INVALID REXT PROFILE":rextSubProfile.c_str() ); 3448 #endif 3449 } 3450 else 3451 { 3452 #if NH_MV 3453 printf(" %s ", profileToString(m_profile) ); 3454 #else 3455 printf("Profile : %s\n", profileToString(m_profile) ); 3456 #endif 3457 } 3458 #if NH_MV 3459 } 3460 printf("\n"); 3461 #endif 3462 3463 printf("CU size / depth / total-depth : %d / %d / %d\n", m_uiMaxCUWidth, m_uiMaxCUDepth, m_uiMaxTotalCUDepth ); 3464 printf("RQT trans. size (min / max) : %d / %d\n", 1 << m_uiQuadtreeTULog2MinSize, 1 << m_uiQuadtreeTULog2MaxSize ); 3465 printf("Max RQT depth inter : %d\n", m_uiQuadtreeTUMaxDepthInter); 3466 printf("Max RQT depth intra : %d\n", m_uiQuadtreeTUMaxDepthIntra); 3467 printf("Min PCM size : %d\n", 1 << m_uiPCMLog2MinSize); 3468 printf("Motion search range : %d\n", m_iSearchRange ); 3469 #if NH_MV 3470 printf("Disp search range restriction : %d\n", m_bUseDisparitySearchRangeRestriction ); 3471 printf("Vertical disp search range : %d\n", m_iVerticalDisparitySearchRange ); 3472 #endif 3473 #if NH_MV 2466 3474 xPrintParaVector( "Intra period", m_iIntraPeriod ); 2467 3475 #else 2468 printf("Intra period : %d\n", m_iIntraPeriod ); 2469 #endif 2470 printf("Decoding refresh type : %d\n", m_iDecodingRefreshType ); 2471 #if !H_MV 2472 printf("QP : %5.2f\n", m_fQP ); 2473 #endif 2474 printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth); 2475 2476 printf("Cb QP Offset : %d\n", m_cbQpOffset ); 2477 printf("Cr QP Offset : %d\n", m_crQpOffset); 2478 2479 printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) ); 2480 printf("GOP size : %d\n", m_iGOPSize ); 2481 printf("Internal bit depth : (Y:%d, C:%d)\n", m_internalBitDepthY, m_internalBitDepthC ); 2482 printf("PCM sample bit depth : (Y:%d, C:%d)\n", g_uiPCMBitDepthLuma, g_uiPCMBitDepthChroma ); 2483 printf("RateControl : %d\n", m_RCEnableRateControl ); 3476 printf("Intra period : %d\n", m_iIntraPeriod ); 3477 #endif 3478 printf("Decoding refresh type : %d\n", m_iDecodingRefreshType ); 3479 #if !NH_MV 3480 printf("QP : %5.2f\n", m_fQP ); 3481 #endif 3482 printf("Max dQP signaling depth : %d\n", m_iMaxCuDQPDepth); 3483 3484 printf("Cb QP Offset : %d\n", m_cbQpOffset ); 3485 printf("Cr QP Offset : %d\n", m_crQpOffset); 3486 printf("QP adaptation : %d (range=%d)\n", m_bUseAdaptiveQP, (m_bUseAdaptiveQP ? m_iQPAdaptationRange : 0) ); 3487 printf("GOP size : %d\n", m_iGOPSize ); 3488 printf("Input bit depth : (Y:%d, C:%d)\n", m_inputBitDepth[CHANNEL_TYPE_LUMA], m_inputBitDepth[CHANNEL_TYPE_CHROMA] ); 3489 printf("MSB-extended bit depth : (Y:%d, C:%d)\n", m_MSBExtendedBitDepth[CHANNEL_TYPE_LUMA], m_MSBExtendedBitDepth[CHANNEL_TYPE_CHROMA] ); 3490 printf("Internal bit depth : (Y:%d, C:%d)\n", m_internalBitDepth[CHANNEL_TYPE_LUMA], m_internalBitDepth[CHANNEL_TYPE_CHROMA] ); 3491 printf("PCM sample bit depth : (Y:%d, C:%d)\n", m_bPCMInputBitDepthFlag ? m_MSBExtendedBitDepth[CHANNEL_TYPE_LUMA] : m_internalBitDepth[CHANNEL_TYPE_LUMA], 3492 m_bPCMInputBitDepthFlag ? m_MSBExtendedBitDepth[CHANNEL_TYPE_CHROMA] : m_internalBitDepth[CHANNEL_TYPE_CHROMA] ); 3493 printf("Intra reference smoothing : %s\n", (m_enableIntraReferenceSmoothing ? "Enabled" : "Disabled") ); 3494 printf("diff_cu_chroma_qp_offset_depth : %d\n", m_diffCuChromaQpOffsetDepth); 3495 printf("extended_precision_processing_flag : %s\n", (m_extendedPrecisionProcessingFlag ? "Enabled" : "Disabled") ); 3496 printf("implicit_rdpcm_enabled_flag : %s\n", (m_rdpcmEnabledFlag[RDPCM_SIGNAL_IMPLICIT] ? "Enabled" : "Disabled") ); 3497 printf("explicit_rdpcm_enabled_flag : %s\n", (m_rdpcmEnabledFlag[RDPCM_SIGNAL_EXPLICIT] ? "Enabled" : "Disabled") ); 3498 printf("transform_skip_rotation_enabled_flag : %s\n", (m_transformSkipRotationEnabledFlag ? "Enabled" : "Disabled") ); 3499 printf("transform_skip_context_enabled_flag : %s\n", (m_transformSkipContextEnabledFlag ? "Enabled" : "Disabled") ); 3500 printf("cross_component_prediction_enabled_flag: %s\n", (m_crossComponentPredictionEnabledFlag ? (m_reconBasedCrossCPredictionEstimate ? "Enabled (reconstructed-residual-based estimate)" : "Enabled (encoder-side-residual-based estimate)") : "Disabled") ); 3501 printf("high_precision_offsets_enabled_flag : %s\n", (m_highPrecisionOffsetsEnabledFlag ? "Enabled" : "Disabled") ); 3502 printf("persistent_rice_adaptation_enabled_flag: %s\n", (m_persistentRiceAdaptationEnabledFlag ? "Enabled" : "Disabled") ); 3503 printf("cabac_bypass_alignment_enabled_flag : %s\n", (m_cabacBypassAlignmentEnabledFlag ? "Enabled" : "Disabled") ); 3504 #if NH_MV 3505 Bool anySAO = false; 3506 IntAry1d saoOffBitShiftL; 3507 IntAry1d saoOffBitShiftC; 3508 3509 for (Int i = 0; i < m_numberOfLayers; i++) 3510 { 3511 if ( m_bUseSAO[i] ) 3512 { 3513 anySAO = true; 3514 saoOffBitShiftL.push_back( m_log2SaoOffsetScale[i][CHANNEL_TYPE_LUMA] ); 3515 saoOffBitShiftC.push_back( m_log2SaoOffsetScale[i][CHANNEL_TYPE_CHROMA] ); 3516 } 3517 else 3518 { 3519 saoOffBitShiftL.push_back( -1 ); 3520 saoOffBitShiftC.push_back( -1 ); 3521 } 3522 } 3523 if (anySAO) 3524 { 3525 xPrintParaVector( "Sao Luma Offset bit shifts" , saoOffBitShiftL ); 3526 xPrintParaVector( "Sao Chroma Offset bit shifts", saoOffBitShiftC ); 3527 } 3528 #else 3529 if (m_bUseSAO) 3530 { 3531 printf("log2_sao_offset_scale_luma : %d\n", m_log2SaoOffsetScale[CHANNEL_TYPE_LUMA]); 3532 printf("log2_sao_offset_scale_chroma : %d\n", m_log2SaoOffsetScale[CHANNEL_TYPE_CHROMA]); 3533 } 3534 #endif 3535 3536 switch (m_costMode) 3537 { 3538 case COST_STANDARD_LOSSY: printf("Cost function: : Lossy coding (default)\n"); break; 3539 case COST_SEQUENCE_LEVEL_LOSSLESS: printf("Cost function: : Sequence_level_lossless coding\n"); break; 3540 case COST_LOSSLESS_CODING: printf("Cost function: : Lossless coding with fixed QP of %d\n", LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP); break; 3541 case COST_MIXED_LOSSLESS_LOSSY_CODING: printf("Cost function: : Mixed_lossless_lossy coding with QP'=%d for lossless evaluation\n", LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME); break; 3542 default: printf("Cost function: : Unknown\n"); break; 3543 } 3544 3545 printf("RateControl : %d\n", m_RCEnableRateControl ); 3546 2484 3547 if(m_RCEnableRateControl) 2485 3548 { 2486 printf("TargetBitrate : %d\n", m_RCTargetBitrate );2487 printf("KeepHierarchicalBit : %d\n", m_RCKeepHierarchicalBit );2488 printf("LCULevelRC : %d\n", m_RCLCULevelRC );2489 printf("UseLCUSeparateModel : %d\n", m_RCUseLCUSeparateModel );2490 printf("InitialQP : %d\n", m_RCInitialQP );2491 printf("ForceIntraQP : %d\n", m_RCForceIntraQP );3549 printf("TargetBitrate : %d\n", m_RCTargetBitrate ); 3550 printf("KeepHierarchicalBit : %d\n", m_RCKeepHierarchicalBit ); 3551 printf("LCULevelRC : %d\n", m_RCLCULevelRC ); 3552 printf("UseLCUSeparateModel : %d\n", m_RCUseLCUSeparateModel ); 3553 printf("InitialQP : %d\n", m_RCInitialQP ); 3554 printf("ForceIntraQP : %d\n", m_RCForceIntraQP ); 2492 3555 2493 3556 #if KWU_RC_MADPRED_E0227 … … 2509 3572 } 2510 3573 #endif 2511 } 2512 printf("Max Num Merge Candidates : %d\n", m_maxNumMergeCand); 2513 #if H_3D 2514 printf("BaseViewCameraNumbers : %s\n", m_pchBaseViewCameraNumbers ); 2515 printf("Coded Camera Param. Precision: %d\n", m_iCodedCamParPrecision); 2516 #if H_3D_VSO 2517 printf("Force use of Lambda Scale : %d\n", m_bForceLambdaScaleVSO ); 3574 3575 } 3576 3577 printf("Max Num Merge Candidates : %d\n", m_maxNumMergeCand); 3578 #if NH_3D 3579 printf("BaseViewCameraNumbers : %s\n", m_pchBaseViewCameraNumbers ); 3580 printf("Coded Camera Param. Precision : %d\n", m_iCodedCamParPrecision); 3581 #if NH_3D_VSO 3582 printf("Force use of Lambda Scale : %d\n", m_bForceLambdaScaleVSO ); 2518 3583 2519 3584 if ( m_bUseVSO ) 2520 3585 { 2521 printf("VSO Lambda Scale : %5.2f\n", m_dLambdaScaleVSO );2522 printf("VSO Mode : %d\n", m_uiVSOMode );2523 printf("VSO Config : %s\n", m_pchVSOConfig );2524 printf("VSO Negative Distortion : %d\n", m_bAllowNegDist ? 1 : 0);2525 printf("VSO LS Table : %d\n", m_bVSOLSTable ? 1 : 0);2526 printf("VSO Estimated VSD : %d\n", m_bUseEstimatedVSD ? 1 : 0);2527 printf("VSO Early Skip : %d\n", m_bVSOEarlySkip ? 1 : 0);3586 printf("VSO Lambda Scale : %5.2f\n", m_dLambdaScaleVSO ); 3587 printf("VSO Mode : %d\n", m_uiVSOMode ); 3588 printf("VSO Config : %s\n", m_pchVSOConfig ); 3589 printf("VSO Negative Distortion : %d\n", m_bAllowNegDist ? 1 : 0); 3590 printf("VSO LS Table : %d\n", m_bVSOLSTable ? 1 : 0); 3591 printf("VSO Estimated VSD : %d\n", m_bUseEstimatedVSD ? 1 : 0); 3592 printf("VSO Early Skip : %d\n", m_bVSOEarlySkip ? 1 : 0); 2528 3593 if ( m_bUseWVSO ) 2529 printf("Dist. Weights (VSO/VSD/SAD) : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight ); 3594 { 3595 printf("Dist. Weights (VSO/VSD/SAD) : %d/%d/%d\n ", m_iVSOWeight, m_iVSDWeight, m_iDWeight ); 3596 } 2530 3597 } 2531 3598 #endif //HHI_VSO 2532 3599 #endif //H_3D 2533 3600 printf("\n"); 2534 #if H_MV3601 #if NH_MV 2535 3602 printf("TOOL CFG General: "); 2536 3603 #else 2537 3604 printf("TOOL CFG: "); 2538 3605 #endif 2539 printf("IBD:%d ", g_bitDepthY > m_inputBitDepthY || g_bitDepthC > m_inputBitDepthC);3606 printf("IBD:%d ", ((m_internalBitDepth[CHANNEL_TYPE_LUMA] > m_MSBExtendedBitDepth[CHANNEL_TYPE_LUMA]) || (m_internalBitDepth[CHANNEL_TYPE_CHROMA] > m_MSBExtendedBitDepth[CHANNEL_TYPE_CHROMA]))); 2540 3607 printf("HAD:%d ", m_bUseHADME ); 2541 3608 printf("RDQ:%d ", m_useRDOQ ); … … 2552 3619 printf("TransformSkip:%d ", m_useTransformSkip ); 2553 3620 printf("TransformSkipFast:%d ", m_useTransformSkipFast ); 3621 printf("TransformSkipLog2MaxSize:%d ", m_log2MaxTransformSkipBlockSize); 2554 3622 printf("Slice: M=%d ", m_sliceMode); 2555 if (m_sliceMode!= 0)3623 if (m_sliceMode!=NO_SLICES) 2556 3624 { 2557 3625 printf("A=%d ", m_sliceArgument); 2558 3626 } 2559 3627 printf("SliceSegment: M=%d ",m_sliceSegmentMode); 2560 if (m_sliceSegmentMode!= 0)3628 if (m_sliceSegmentMode!=NO_SLICES) 2561 3629 { 2562 3630 printf("A=%d ", m_sliceSegmentArgument); 2563 3631 } 2564 3632 printf("CIP:%d ", m_bUseConstrainedIntraPred); 2565 #if ! H_MV3633 #if !NH_MV 2566 3634 printf("SAO:%d ", (m_bUseSAO)?(1):(0)); 2567 3635 #endif 2568 3636 printf("PCM:%d ", (m_usePCM && (1<<m_uiPCMLog2MinSize) <= m_uiMaxCUWidth)? 1 : 0); 3637 2569 3638 if (m_TransquantBypassEnableFlag && m_CUTransquantBypassFlagForce) 2570 3639 { 2571 printf("TransQuantBypassEnabled: =1 3640 printf("TransQuantBypassEnabled: =1"); 2572 3641 } 2573 3642 else … … 2575 3644 printf("TransQuantBypassEnabled:%d ", (m_TransquantBypassEnableFlag)? 1:0 ); 2576 3645 } 3646 2577 3647 printf("WPP:%d ", (Int)m_useWeightedPred); 2578 3648 printf("WPB:%d ", (Int)m_useWeightedBiPred); 2579 3649 printf("PME:%d ", m_log2ParallelMergeLevel); 3650 const Int iWaveFrontSubstreams = m_iWaveFrontSynchro ? (m_iSourceHeight + m_uiMaxCUHeight - 1) / m_uiMaxCUHeight : 1; 2580 3651 printf(" WaveFrontSynchro:%d WaveFrontSubstreams:%d", 2581 m_iWaveFrontSynchro, m_iWaveFrontSubstreams);3652 m_iWaveFrontSynchro, iWaveFrontSubstreams); 2582 3653 printf(" ScalingList:%d ", m_useScalingListId ); 2583 3654 printf("TMVPMode:%d ", m_TMVPModeId ); 2584 3655 #if ADAPTIVE_QP_SELECTION 2585 printf("AQpS:%d 3656 printf("AQpS:%d", m_bUseAdaptQpSelect ); 2586 3657 #endif 2587 3658 2588 3659 printf(" SignBitHidingFlag:%d ", m_signHideFlag); 2589 printf("RecalQP:%d 2590 #if H_3D_VSO2591 printf(" VSO:%d ", m_bUseVSO );3660 printf("RecalQP:%d", m_recalculateQPAccordingToLambda ? 1 : 0 ); 3661 #if NH_3D_VSO 3662 printf(" VSO:%d ", m_bUseVSO ); 2592 3663 printf("WVSO:%d ", m_bUseWVSO ); 2593 3664 #endif 2594 #if H_3D3665 #if NH_3D 2595 3666 printf( "QTL:%d " , m_bUseQTL); 2596 3667 printf( "IlluCompEnable:%d " , m_abUseIC); … … 2617 3688 #endif 2618 3689 2619 printf("\n\n"); 3690 printf("\n\n"); 2620 3691 2621 3692 fflush(stdout); … … 2625 3696 { 2626 3697 if (!bflag) 3698 { 2627 3699 return false; 2628 3700 } 3701 2629 3702 printf("Error: %s\n",message); 2630 3703 return true;
Note: See TracChangeset for help on using the changeset viewer.