| 1 | /***************************************************************************** |
| 2 | * Copyright (C) 2013 x265 project |
| 3 | * |
| 4 | * Authors: Steve Borho <steve@borho.org> |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA. |
| 19 | * |
| 20 | * This program is also available under a commercial proprietary license. |
| 21 | * For more information, contact us at license @ x265.com. |
| 22 | *****************************************************************************/ |
| 23 | |
| 24 | #include "common.h" |
| 25 | #include "slice.h" |
| 26 | #include "level.h" |
| 27 | |
| 28 | namespace x265 { |
| 29 | typedef struct |
| 30 | { |
| 31 | uint32_t maxLumaSamples; |
| 32 | uint32_t maxLumaSamplesPerSecond; |
| 33 | uint32_t maxBitrateMain; |
| 34 | uint32_t maxBitrateHigh; |
| 35 | uint32_t maxCpbSizeMain; |
| 36 | uint32_t maxCpbSizeHigh; |
| 37 | uint32_t minCompressionRatio; |
| 38 | Level::Name levelEnum; |
| 39 | const char* name; |
| 40 | int levelIdc; |
| 41 | } LevelSpec; |
| 42 | |
| 43 | LevelSpec levels[] = |
| 44 | { |
| 45 | { 36864, 552960, 128, MAX_UINT, 350, MAX_UINT, 2, Level::LEVEL1, "1", 10 }, |
| 46 | { 122880, 3686400, 1500, MAX_UINT, 1500, MAX_UINT, 2, Level::LEVEL2, "2", 20 }, |
| 47 | { 245760, 7372800, 3000, MAX_UINT, 3000, MAX_UINT, 2, Level::LEVEL2_1, "2.1", 21 }, |
| 48 | { 552960, 16588800, 6000, MAX_UINT, 6000, MAX_UINT, 2, Level::LEVEL3, "3", 30 }, |
| 49 | { 983040, 33177600, 10000, MAX_UINT, 10000, MAX_UINT, 2, Level::LEVEL3_1, "3.1", 31 }, |
| 50 | { 2228224, 66846720, 12000, 30000, 12000, 30000, 4, Level::LEVEL4, "4", 40 }, |
| 51 | { 2228224, 133693440, 20000, 50000, 20000, 50000, 4, Level::LEVEL4_1, "4.1", 41 }, |
| 52 | { 8912896, 267386880, 25000, 100000, 25000, 100000, 6, Level::LEVEL5, "5", 50 }, |
| 53 | { 8912896, 534773760, 40000, 160000, 40000, 160000, 8, Level::LEVEL5_1, "5.1", 51 }, |
| 54 | { 8912896, 1069547520, 60000, 240000, 60000, 240000, 8, Level::LEVEL5_2, "5.2", 52 }, |
| 55 | { 35651584, 1069547520, 60000, 240000, 60000, 240000, 8, Level::LEVEL6, "6", 60 }, |
| 56 | { 35651584, 2139095040, 120000, 480000, 120000, 480000, 8, Level::LEVEL6_1, "6.1", 61 }, |
| 57 | { 35651584, 4278190080U, 240000, 800000, 240000, 800000, 6, Level::LEVEL6_2, "6.2", 62 }, |
| 58 | }; |
| 59 | |
| 60 | /* determine minimum decoder level required to decode the described video */ |
| 61 | void determineLevel(const x265_param ¶m, VPS& vps) |
| 62 | { |
| 63 | if (param.bLossless) |
| 64 | vps.ptl.profileIdc = Profile::NONE; |
| 65 | else if (param.internalCsp == X265_CSP_I420) |
| 66 | { |
| 67 | if (param.internalBitDepth == 8) |
| 68 | { |
| 69 | if (param.keyframeMax == 1 && param.maxNumReferences == 1) |
| 70 | vps.ptl.profileIdc = Profile::MAINSTILLPICTURE; |
| 71 | else |
| 72 | vps.ptl.profileIdc = Profile::MAIN; |
| 73 | } |
| 74 | else if (param.internalBitDepth == 10) |
| 75 | vps.ptl.profileIdc = Profile::MAIN10; |
| 76 | } |
| 77 | else |
| 78 | vps.ptl.profileIdc = Profile::MAINREXT; |
| 79 | |
| 80 | /* determine which profiles are compatible with this stream */ |
| 81 | |
| 82 | memset(vps.ptl.profileCompatibilityFlag, 0, sizeof(vps.ptl.profileCompatibilityFlag)); |
| 83 | vps.ptl.profileCompatibilityFlag[vps.ptl.profileIdc] = true; |
| 84 | if (vps.ptl.profileIdc == Profile::MAIN10 && param.internalBitDepth == 8) |
| 85 | vps.ptl.profileCompatibilityFlag[Profile::MAIN] = true; |
| 86 | else if (vps.ptl.profileIdc == Profile::MAIN) |
| 87 | vps.ptl.profileCompatibilityFlag[Profile::MAIN10] = true; |
| 88 | else if (vps.ptl.profileIdc == Profile::MAINSTILLPICTURE) |
| 89 | { |
| 90 | vps.ptl.profileCompatibilityFlag[Profile::MAIN] = true; |
| 91 | vps.ptl.profileCompatibilityFlag[Profile::MAIN10] = true; |
| 92 | } |
| 93 | else if (vps.ptl.profileIdc == Profile::MAINREXT) |
| 94 | vps.ptl.profileCompatibilityFlag[Profile::MAINREXT] = true; |
| 95 | |
| 96 | uint32_t lumaSamples = param.sourceWidth * param.sourceHeight; |
| 97 | uint32_t samplesPerSec = (uint32_t)(lumaSamples * ((double)param.fpsNum / param.fpsDenom)); |
| 98 | uint32_t bitrate = param.rc.vbvMaxBitrate ? param.rc.vbvMaxBitrate : param.rc.bitrate; |
| 99 | |
| 100 | const uint32_t MaxDpbPicBuf = 6; |
| 101 | vps.ptl.levelIdc = Level::NONE; |
| 102 | vps.ptl.tierFlag = Level::MAIN; |
| 103 | |
| 104 | const size_t NumLevels = sizeof(levels) / sizeof(levels[0]); |
| 105 | uint32_t i; |
| 106 | for (i = 0; i < NumLevels; i++) |
| 107 | { |
| 108 | if (lumaSamples > levels[i].maxLumaSamples) |
| 109 | continue; |
| 110 | else if (samplesPerSec > levels[i].maxLumaSamplesPerSecond) |
| 111 | continue; |
| 112 | else if (bitrate > levels[i].maxBitrateMain && levels[i].maxBitrateHigh == MAX_UINT) |
| 113 | continue; |
| 114 | else if (bitrate > levels[i].maxBitrateHigh) |
| 115 | continue; |
| 116 | else if (param.sourceWidth > sqrt(levels[i].maxLumaSamples * 8.0f)) |
| 117 | continue; |
| 118 | else if (param.sourceHeight > sqrt(levels[i].maxLumaSamples * 8.0f)) |
| 119 | continue; |
| 120 | |
| 121 | uint32_t maxDpbSize = MaxDpbPicBuf; |
| 122 | if (lumaSamples <= (levels[i].maxLumaSamples >> 2)) |
| 123 | maxDpbSize = X265_MIN(4 * MaxDpbPicBuf, 16); |
| 124 | else if (lumaSamples <= (levels[i].maxLumaSamples >> 1)) |
| 125 | maxDpbSize = X265_MIN(2 * MaxDpbPicBuf, 16); |
| 126 | else if (lumaSamples <= ((3 * levels[i].maxLumaSamples) >> 2)) |
| 127 | maxDpbSize = X265_MIN((4 * MaxDpbPicBuf) / 3, 16); |
| 128 | |
| 129 | /* The value of sps_max_dec_pic_buffering_minus1[ HighestTid ] + 1 shall be less than |
| 130 | * or equal to MaxDpbSize */ |
| 131 | if (vps.maxDecPicBuffering > maxDpbSize) |
| 132 | continue; |
| 133 | |
| 134 | /* For level 5 and higher levels, the value of CtbSizeY shall be equal to 32 or 64 */ |
| 135 | if (levels[i].levelEnum >= Level::LEVEL5 && param.maxCUSize < 32) |
| 136 | { |
| 137 | x265_log(¶m, X265_LOG_WARNING, "level %s detected, but CTU size 16 is non-compliant\n", levels[i].name); |
| 138 | vps.ptl.profileIdc = Profile::NONE; |
| 139 | vps.ptl.levelIdc = Level::NONE; |
| 140 | vps.ptl.tierFlag = Level::MAIN; |
| 141 | x265_log(¶m, X265_LOG_INFO, "NONE profile, Level-NONE (Main tier)\n"); |
| 142 | return; |
| 143 | } |
| 144 | |
| 145 | /* The value of NumPocTotalCurr shall be less than or equal to 8 */ |
| 146 | int numPocTotalCurr = param.maxNumReferences + vps.numReorderPics; |
| 147 | if (numPocTotalCurr > 8) |
| 148 | { |
| 149 | x265_log(¶m, X265_LOG_WARNING, "level %s detected, but NumPocTotalCurr (total references) is non-compliant\n", levels[i].name); |
| 150 | vps.ptl.profileIdc = Profile::NONE; |
| 151 | vps.ptl.levelIdc = Level::NONE; |
| 152 | vps.ptl.tierFlag = Level::MAIN; |
| 153 | x265_log(¶m, X265_LOG_INFO, "NONE profile, Level-NONE (Main tier)\n"); |
| 154 | return; |
| 155 | } |
| 156 | |
| 157 | vps.ptl.levelIdc = levels[i].levelEnum; |
| 158 | vps.ptl.minCrForLevel = levels[i].minCompressionRatio; |
| 159 | vps.ptl.maxLumaSrForLevel = levels[i].maxLumaSamplesPerSecond; |
| 160 | |
| 161 | if (bitrate > levels[i].maxBitrateMain && bitrate <= levels[i].maxBitrateHigh && |
| 162 | levels[i].maxBitrateHigh != MAX_UINT) |
| 163 | vps.ptl.tierFlag = Level::HIGH; |
| 164 | else |
| 165 | vps.ptl.tierFlag = Level::MAIN; |
| 166 | break; |
| 167 | } |
| 168 | |
| 169 | vps.ptl.intraConstraintFlag = false; |
| 170 | vps.ptl.lowerBitRateConstraintFlag = true; |
| 171 | vps.ptl.bitDepthConstraint = param.internalBitDepth; |
| 172 | vps.ptl.chromaFormatConstraint = param.internalCsp; |
| 173 | |
| 174 | static const char *profiles[] = { "None", "Main", "Main 10", "Main Still Picture", "RExt" }; |
| 175 | static const char *tiers[] = { "Main", "High" }; |
| 176 | |
| 177 | const char *profile = profiles[vps.ptl.profileIdc]; |
| 178 | if (vps.ptl.profileIdc == Profile::MAINREXT) |
| 179 | { |
| 180 | if (param.internalCsp == X265_CSP_I422) |
| 181 | profile = "Main 4:2:2 10"; |
| 182 | if (param.internalCsp == X265_CSP_I444) |
| 183 | { |
| 184 | if (vps.ptl.bitDepthConstraint <= 8) |
| 185 | profile = "Main 4:4:4 8"; |
| 186 | else if (vps.ptl.bitDepthConstraint <= 10) |
| 187 | profile = "Main 4:4:4 10"; |
| 188 | } |
| 189 | } |
| 190 | x265_log(¶m, X265_LOG_INFO, "%s profile, Level-%s (%s tier)\n", |
| 191 | profile, levels[i].name, tiers[vps.ptl.tierFlag]); |
| 192 | } |
| 193 | |
| 194 | /* enforce a maximum decoder level requirement, in other words assure that a |
| 195 | * decoder of the specified level may decode the video about to be created. |
| 196 | * Lower parameters where necessary to ensure the video will be decodable by a |
| 197 | * decoder meeting this level of requirement. Some parameters (resolution and |
| 198 | * frame rate) are non-negotiable and thus this function may fail. In those |
| 199 | * circumstances it will be quite noisy */ |
| 200 | bool enforceLevel(x265_param& param, VPS& vps) |
| 201 | { |
| 202 | vps.numReorderPics = (param.bBPyramid && param.bframes > 1) ? 2 : 1; |
| 203 | vps.maxDecPicBuffering = X265_MIN(MAX_NUM_REF, X265_MAX(vps.numReorderPics + 1, (uint32_t)param.maxNumReferences) + vps.numReorderPics); |
| 204 | |
| 205 | /* no level specified by user, just auto-detect from the configuration */ |
| 206 | if (param.levelIdc <= 0) |
| 207 | return true; |
| 208 | |
| 209 | uint32_t level = 0; |
| 210 | while (levels[level].levelIdc != param.levelIdc && level + 1 < sizeof(levels) / sizeof(levels[0])) |
| 211 | level++; |
| 212 | if (levels[level].levelIdc != param.levelIdc) |
| 213 | { |
| 214 | x265_log(¶m, X265_LOG_WARNING, "specified level %d does not exist\n", param.levelIdc); |
| 215 | return false; |
| 216 | } |
| 217 | |
| 218 | LevelSpec& l = levels[level]; |
| 219 | bool highTier = !!param.bHighTier; |
| 220 | if (highTier && l.maxBitrateHigh == MAX_UINT) |
| 221 | { |
| 222 | highTier = false; |
| 223 | x265_log(¶m, X265_LOG_WARNING, "Level %s has no High tier, using Main tier\n", l.name); |
| 224 | } |
| 225 | |
| 226 | uint32_t lumaSamples = param.sourceWidth * param.sourceHeight; |
| 227 | uint32_t samplesPerSec = (uint32_t)(lumaSamples * ((double)param.fpsNum / param.fpsDenom)); |
| 228 | bool ok = true; |
| 229 | if (lumaSamples > l.maxLumaSamples) |
| 230 | ok = false; |
| 231 | else if (param.sourceWidth > sqrt(l.maxLumaSamples * 8.0f)) |
| 232 | ok = false; |
| 233 | else if (param.sourceHeight > sqrt(l.maxLumaSamples * 8.0f)) |
| 234 | ok = false; |
| 235 | if (!ok) |
| 236 | { |
| 237 | x265_log(¶m, X265_LOG_WARNING, "picture dimensions are out of range for specified level\n"); |
| 238 | return false; |
| 239 | } |
| 240 | else if (samplesPerSec > l.maxLumaSamplesPerSecond) |
| 241 | { |
| 242 | x265_log(¶m, X265_LOG_WARNING, "frame rate is out of range for specified level\n"); |
| 243 | return false; |
| 244 | } |
| 245 | |
| 246 | if ((uint32_t)param.rc.vbvMaxBitrate > (highTier ? l.maxBitrateHigh : l.maxBitrateMain)) |
| 247 | { |
| 248 | param.rc.vbvMaxBitrate = highTier ? l.maxBitrateHigh : l.maxBitrateMain; |
| 249 | x265_log(¶m, X265_LOG_INFO, "lowering VBV max bitrate to %dKbps\n", param.rc.vbvMaxBitrate); |
| 250 | } |
| 251 | if ((uint32_t)param.rc.vbvBufferSize > (highTier ? l.maxCpbSizeHigh : l.maxCpbSizeMain)) |
| 252 | { |
| 253 | param.rc.vbvMaxBitrate = highTier ? l.maxCpbSizeHigh : l.maxCpbSizeMain; |
| 254 | x265_log(¶m, X265_LOG_INFO, "lowering VBV buffer size to %dKb\n", param.rc.vbvBufferSize); |
| 255 | } |
| 256 | |
| 257 | switch (param.rc.rateControlMode) |
| 258 | { |
| 259 | case X265_RC_ABR: |
| 260 | if ((uint32_t)param.rc.bitrate > (highTier ? l.maxBitrateHigh : l.maxBitrateMain)) |
| 261 | { |
| 262 | param.rc.bitrate = l.maxBitrateHigh; |
| 263 | x265_log(¶m, X265_LOG_INFO, "lowering target bitrate to High tier limit of %dKbps\n", param.rc.bitrate); |
| 264 | } |
| 265 | break; |
| 266 | |
| 267 | case X265_RC_CQP: |
| 268 | x265_log(¶m, X265_LOG_WARNING, "Constant QP is inconsistent with specifying a decoder level, no bitrate guarantee is possible.\n"); |
| 269 | return false; |
| 270 | |
| 271 | case X265_RC_CRF: |
| 272 | if (!param.rc.vbvBufferSize || !param.rc.vbvMaxBitrate) |
| 273 | { |
| 274 | if (!param.rc.vbvMaxBitrate) |
| 275 | param.rc.vbvMaxBitrate = highTier ? l.maxBitrateHigh : l.maxBitrateMain; |
| 276 | if (!param.rc.vbvBufferSize) |
| 277 | param.rc.vbvBufferSize = highTier ? l.maxCpbSizeHigh : l.maxCpbSizeMain; |
| 278 | x265_log(¶m, X265_LOG_WARNING, "Specifying a decoder level with constant rate factor rate-control requires\n"); |
| 279 | x265_log(¶m, X265_LOG_WARNING, "enabling VBV with vbv-bufsize=%dkb vbv-maxrate=%dkbps. VBV outputs are non-deterministic!\n", |
| 280 | param.rc.vbvBufferSize, param.rc.vbvMaxBitrate); |
| 281 | } |
| 282 | break; |
| 283 | |
| 284 | default: |
| 285 | x265_log(¶m, X265_LOG_ERROR, "Unknown rate control mode is inconsistent with specifying a decoder level\n"); |
| 286 | return false; |
| 287 | } |
| 288 | |
| 289 | /* The value of sps_max_dec_pic_buffering_minus1[ HighestTid ] + 1 shall be less than or equal to MaxDpbSize */ |
| 290 | const uint32_t MaxDpbPicBuf = 6; |
| 291 | uint32_t maxDpbSize = MaxDpbPicBuf; |
| 292 | if (lumaSamples <= (l.maxLumaSamples >> 2)) |
| 293 | maxDpbSize = X265_MIN(4 * MaxDpbPicBuf, 16); |
| 294 | else if (lumaSamples <= (l.maxLumaSamples >> 1)) |
| 295 | maxDpbSize = X265_MIN(2 * MaxDpbPicBuf, 16); |
| 296 | else if (lumaSamples <= ((3 * l.maxLumaSamples) >> 2)) |
| 297 | maxDpbSize = X265_MIN((4 * MaxDpbPicBuf) / 3, 16); |
| 298 | |
| 299 | int savedRefCount = param.maxNumReferences; |
| 300 | while (vps.maxDecPicBuffering > maxDpbSize && param.maxNumReferences > 1) |
| 301 | { |
| 302 | param.maxNumReferences--; |
| 303 | vps.maxDecPicBuffering = X265_MIN(MAX_NUM_REF, X265_MAX(vps.numReorderPics + 1, (uint32_t)param.maxNumReferences) + vps.numReorderPics); |
| 304 | } |
| 305 | if (param.maxNumReferences != savedRefCount) |
| 306 | x265_log(¶m, X265_LOG_INFO, "Lowering max references to %d to meet level requirement\n", param.maxNumReferences); |
| 307 | |
| 308 | /* For level 5 and higher levels, the value of CtbSizeY shall be equal to 32 or 64 */ |
| 309 | if (param.levelIdc >= 50 && param.maxCUSize < 32) |
| 310 | { |
| 311 | param.maxCUSize = 32; |
| 312 | x265_log(¶m, X265_LOG_INFO, "Levels 5.0 and above require a maximum CTU size of at least 32, using --ctu 32\n"); |
| 313 | } |
| 314 | |
| 315 | /* The value of NumPocTotalCurr shall be less than or equal to 8 */ |
| 316 | int numPocTotalCurr = param.maxNumReferences + !!param.bframes; |
| 317 | if (numPocTotalCurr > 8) |
| 318 | { |
| 319 | param.maxNumReferences = 8 - !!param.bframes; |
| 320 | x265_log(¶m, X265_LOG_INFO, "Lowering max references to %d to meet numPocTotalCurr requirement\n", param.maxNumReferences); |
| 321 | } |
| 322 | |
| 323 | return true; |
| 324 | } |
| 325 | |
| 326 | extern "C" |
| 327 | int x265_param_apply_profile(x265_param *param, const char *profile) |
| 328 | { |
| 329 | if (!profile) |
| 330 | return 0; |
| 331 | if (!strcmp(profile, "main")) |
| 332 | { |
| 333 | /* SPSs shall have chroma_format_idc equal to 1 only */ |
| 334 | param->internalCsp = X265_CSP_I420; |
| 335 | |
| 336 | #if HIGH_BIT_DEPTH |
| 337 | /* SPSs shall have bit_depth_luma_minus8 equal to 0 only */ |
| 338 | x265_log(param, X265_LOG_ERROR, "Main profile not supported, compiled for Main10.\n"); |
| 339 | return -1; |
| 340 | #endif |
| 341 | } |
| 342 | else if (!strcmp(profile, "main10")) |
| 343 | { |
| 344 | /* SPSs shall have chroma_format_idc equal to 1 only */ |
| 345 | param->internalCsp = X265_CSP_I420; |
| 346 | |
| 347 | /* SPSs shall have bit_depth_luma_minus8 in the range of 0 to 2, inclusive |
| 348 | * this covers all builds of x265, currently */ |
| 349 | } |
| 350 | else if (!strcmp(profile, "mainstillpicture") || !strcmp(profile, "msp")) |
| 351 | { |
| 352 | /* SPSs shall have chroma_format_idc equal to 1 only */ |
| 353 | param->internalCsp = X265_CSP_I420; |
| 354 | |
| 355 | /* SPSs shall have sps_max_dec_pic_buffering_minus1[ sps_max_sub_layers_minus1 ] equal to 0 only */ |
| 356 | param->maxNumReferences = 1; |
| 357 | |
| 358 | /* The bitstream shall contain only one picture (we do not enforce this) */ |
| 359 | /* just in case the user gives us more than one picture: */ |
| 360 | param->keyframeMax = 1; |
| 361 | param->bOpenGOP = 0; |
| 362 | param->bRepeatHeaders = 1; |
| 363 | param->lookaheadDepth = 0; |
| 364 | param->bframes = 0; |
| 365 | param->scenecutThreshold = 0; |
| 366 | param->bFrameAdaptive = 0; |
| 367 | param->rc.cuTree = 0; |
| 368 | param->bEnableWeightedPred = 0; |
| 369 | param->bEnableWeightedBiPred = 0; |
| 370 | |
| 371 | #if HIGH_BIT_DEPTH |
| 372 | /* SPSs shall have bit_depth_luma_minus8 equal to 0 only */ |
| 373 | x265_log(param, X265_LOG_ERROR, "Mainstillpicture profile not supported, compiled for Main10.\n"); |
| 374 | return -1; |
| 375 | #endif |
| 376 | } |
| 377 | else if (!strcmp(profile, "main422-10")) |
| 378 | param->internalCsp = X265_CSP_I422; |
| 379 | else if (!strcmp(profile, "main444-8")) |
| 380 | { |
| 381 | param->internalCsp = X265_CSP_I444; |
| 382 | #if HIGH_BIT_DEPTH |
| 383 | x265_log(param, X265_LOG_ERROR, "Main 4:4:4 8 profile not supported, compiled for Main10.\n"); |
| 384 | return -1; |
| 385 | #endif |
| 386 | } |
| 387 | else if (!strcmp(profile, "main444-10")) |
| 388 | param->internalCsp = X265_CSP_I444; |
| 389 | else |
| 390 | { |
| 391 | x265_log(param, X265_LOG_ERROR, "unknown profile <%s>\n", profile); |
| 392 | return -1; |
| 393 | } |
| 394 | |
| 395 | return 0; |
| 396 | } |
| 397 | } |