FFmpeg: libavcodec/h264_ps.c Source File

FFmpeg

[フレーム]

libavcodec

h264_ps.c

Go to the documentation of this file.

1 /*

2 * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 /**

23 * @file

24 * H.264 / AVC / MPEG4 part10 parameter set decoding.

25 * @author Michael Niedermayer <michaelni@gmx.at>

26 */

28 #include <inttypes.h>

30 #include "libavutil/imgutils.h"

31 #include "internal.h"

32 #include "avcodec.h"

33 #include "h264.h"

34 #include "h264data.h"

35 #include "golomb.h"

37 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)

38 #define MIN_LOG2_MAX_FRAME_NUM 4

40 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))

42 #define CHROMA_QP_TABLE_END(d) \

43 QP(0, d), QP(1, d), QP(2, d), QP(3, d), QP(4, d), QP(5, d), \

44 QP(6, d), QP(7, d), QP(8, d), QP(9, d), QP(10, d), QP(11, d), \

45 QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d), \

46 QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d), \

47 QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d), \

48 QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d), \

49 QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d), \

50 QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d), \

51 QP(39, d), QP(39, d), QP(39, d), QP(39, d)

53 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1] = {

54 { CHROMA_QP_TABLE_END(8) },

55 { 0, 1, 2, 3, 4, 5,

56 CHROMA_QP_TABLE_END(9) },

57 { 0, 1, 2, 3, 4, 5,

58 6, 7, 8, 9, 10, 11,

59 CHROMA_QP_TABLE_END(10) },

60 { 0, 1, 2, 3, 4, 5,

61 6, 7, 8, 9, 10, 11,

62 12,13,14,15, 16, 17,

63 CHROMA_QP_TABLE_END(11) },

64 { 0, 1, 2, 3, 4, 5,

65 6, 7, 8, 9, 10, 11,

66 12,13,14,15, 16, 17,

67 18,19,20,21, 22, 23,

68 CHROMA_QP_TABLE_END(12) },

69 { 0, 1, 2, 3, 4, 5,

70 6, 7, 8, 9, 10, 11,

71 12,13,14,15, 16, 17,

72 18,19,20,21, 22, 23,

73 24,25,26,27, 28, 29,

74 CHROMA_QP_TABLE_END(13) },

75 { 0, 1, 2, 3, 4, 5,

76 6, 7, 8, 9, 10, 11,

77 12,13,14,15, 16, 17,

78 18,19,20,21, 22, 23,

79 24,25,26,27, 28, 29,

80 30,31,32,33, 34, 35,

81 CHROMA_QP_TABLE_END(14) },

82 };

84 static const uint8_t default_scaling4[2][16] = {

85 { 6, 13, 20, 28, 13, 20, 28, 32,

86 20, 28, 32, 37, 28, 32, 37, 42 },

87 { 10, 14, 20, 24, 14, 20, 24, 27,

88 20, 24, 27, 30, 24, 27, 30, 34 }

89 };

91 static const uint8_t default_scaling8[2][64] = {

92 { 6, 10, 13, 16, 18, 23, 25, 27,

93 10, 11, 16, 18, 23, 25, 27, 29,

94 13, 16, 18, 23, 25, 27, 29, 31,

95 16, 18, 23, 25, 27, 29, 31, 33,

96 18, 23, 25, 27, 29, 31, 33, 36,

97 23, 25, 27, 29, 31, 33, 36, 38,

98 25, 27, 29, 31, 33, 36, 38, 40,

99 27, 29, 31, 33, 36, 38, 40, 42 },

100 { 9, 13, 15, 17, 19, 21, 22, 24,

101 13, 13, 17, 19, 21, 22, 24, 25,

102 15, 17, 19, 21, 22, 24, 25, 27,

103 17, 19, 21, 22, 24, 25, 27, 28,

104 19, 21, 22, 24, 25, 27, 28, 30,

105 21, 22, 24, 25, 27, 28, 30, 32,

106 22, 24, 25, 27, 28, 30, 32, 33,

107 24, 25, 27, 28, 30, 32, 33, 35 }

108 };

109

110 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)

111 {

112 int cpb_count, i;

113 cpb_count = get_ue_golomb_31(&h->gb) + 1;

114

115 if (cpb_count > 32U) {

116 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);

117 return AVERROR_INVALIDDATA;

118 }

119

120 get_bits(&h->gb, 4); /* bit_rate_scale */

121 get_bits(&h->gb, 4); /* cpb_size_scale */

122 for (i = 0; i < cpb_count; i++) {

123 get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */

124 get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */

125 get_bits1(&h->gb); /* cbr_flag */

126 }

127 sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;

128 sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;

129 sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;

130 sps->time_offset_length = get_bits(&h->gb, 5);

131 sps->cpb_cnt = cpb_count;

132 return 0;

133 }

134

135 static inline int decode_vui_parameters(H264Context *h, SPS *sps)

136 {

137 int aspect_ratio_info_present_flag;

138 unsigned int aspect_ratio_idc;

139

140 aspect_ratio_info_present_flag = get_bits1(&h->gb);

141

142 if (aspect_ratio_info_present_flag) {

143 aspect_ratio_idc = get_bits(&h->gb, 8);

144 if (aspect_ratio_idc == EXTENDED_SAR) {

145 sps->sar.num = get_bits(&h->gb, 16);

146 sps->sar.den = get_bits(&h->gb, 16);

147 } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {

148 sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];

149 } else {

150 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");

151 return AVERROR_INVALIDDATA;

152 }

153 } else {

154 sps->sar.num =

155 sps->sar.den = 0;

156 }

157

158 if (get_bits1(&h->gb)) /* overscan_info_present_flag */

159 get_bits1(&h->gb); /* overscan_appropriate_flag */

160

161 sps->video_signal_type_present_flag = get_bits1(&h->gb);

162 if (sps->video_signal_type_present_flag) {

163 get_bits(&h->gb, 3); /* video_format */

164 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */

165

166 sps->colour_description_present_flag = get_bits1(&h->gb);

167 if (sps->colour_description_present_flag) {

168 sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */

169 sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */

170 sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */

171 if (sps->color_primaries >= AVCOL_PRI_NB)

172 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;

173 if (sps->color_trc >= AVCOL_TRC_NB)

174 sps->color_trc = AVCOL_TRC_UNSPECIFIED;

175 if (sps->colorspace >= AVCOL_SPC_NB)

176 sps->colorspace = AVCOL_SPC_UNSPECIFIED;

177 }

178 }

179

180 /* chroma_location_info_present_flag */

181 if (get_bits1(&h->gb)) {

182 /* chroma_sample_location_type_top_field */

183 h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;

184 get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */

185 }

186

187 if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {

188 av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");

189 return 0;

190 }

191

192 sps->timing_info_present_flag = get_bits1(&h->gb);

193 if (sps->timing_info_present_flag) {

194 sps->num_units_in_tick = get_bits_long(&h->gb, 32);

195 sps->time_scale = get_bits_long(&h->gb, 32);

196 if (!sps->num_units_in_tick || !sps->time_scale) {

197 av_log(h->avctx, AV_LOG_ERROR,

198 "time_scale/num_units_in_tick invalid or unsupported (%"PRIu32"/%"PRIu32")\n",

199 sps->time_scale, sps->num_units_in_tick);

200 return AVERROR_INVALIDDATA;

201 }

202 sps->fixed_frame_rate_flag = get_bits1(&h->gb);

203 }

204

205 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);

206 if (sps->nal_hrd_parameters_present_flag)

207 if (decode_hrd_parameters(h, sps) < 0)

208 return AVERROR_INVALIDDATA;

209 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);

210 if (sps->vcl_hrd_parameters_present_flag)

211 if (decode_hrd_parameters(h, sps) < 0)

212 return AVERROR_INVALIDDATA;

213 if (sps->nal_hrd_parameters_present_flag ||

214 sps->vcl_hrd_parameters_present_flag)

215 get_bits1(&h->gb); /* low_delay_hrd_flag */

216 sps->pic_struct_present_flag = get_bits1(&h->gb);

217 if (!get_bits_left(&h->gb))

218 return 0;

219 sps->bitstream_restriction_flag = get_bits1(&h->gb);

220 if (sps->bitstream_restriction_flag) {

221 get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */

222 get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */

223 get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */

224 get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */

225 get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */

226 sps->num_reorder_frames = get_ue_golomb(&h->gb);

227 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/

228

229 if (get_bits_left(&h->gb) < 0) {

230 sps->num_reorder_frames = 0;

231 sps->bitstream_restriction_flag = 0;

232 }

233

234 if (sps->num_reorder_frames > 16U

235 /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {

236 av_log(h->avctx, AV_LOG_ERROR,

237 "Clipping illegal num_reorder_frames %d\n",

238 sps->num_reorder_frames);

239 sps->num_reorder_frames = 16;

240 return AVERROR_INVALIDDATA;

241 }

242 }

243

244 if (get_bits_left(&h->gb) < 0) {

245 av_log(h->avctx, AV_LOG_ERROR,

246 "Overread VUI by %d bits\n", -get_bits_left(&h->gb));

247 return AVERROR_INVALIDDATA;

248 }

249

250 return 0;

251 }

252

253 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,

254 const uint8_t *jvt_list,

255 const uint8_t *fallback_list)

256 {

257 int i, last = 8, next = 8;

258 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;

259 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */

260 memcpy(factors, fallback_list, size * sizeof(uint8_t));

261 else

262 for (i = 0; i < size; i++) {

263 if (next)

264 next = (last + get_se_golomb(&h->gb)) & 0xff;

265 if (!i && !next) { /* matrix not written, we use the preset one */

266 memcpy(factors, jvt_list, size * sizeof(uint8_t));

267 break;

268 }

269 last = factors[scan[i]] = next ? next : last;

270 }

271 }

272

273 static void decode_scaling_matrices(H264Context *h, SPS *sps,

274 PPS *pps, int is_sps,

275 uint8_t(*scaling_matrix4)[16],

276 uint8_t(*scaling_matrix8)[64])

277 {

278 int fallback_sps = !is_sps && sps->scaling_matrix_present;

279 const uint8_t *fallback[4] = {

280 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],

281 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],

282 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],

283 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]

284 };

285 if (get_bits1(&h->gb)) {

286 sps->scaling_matrix_present |= is_sps;

287 decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y

288 decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr

289 decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb

290 decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y

291 decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr

292 decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb

293 if (is_sps || pps->transform_8x8_mode) {

294 decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y

295 decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y

296 if (sps->chroma_format_idc == 3) {

297 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr

298 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr

299 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb

300 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb

301 }

302 }

303 }

304 }

305

306 int ff_h264_decode_seq_parameter_set(H264Context *h)

307 {

308 int profile_idc, level_idc, constraint_set_flags = 0;

309 unsigned int sps_id;

310 int i, log2_max_frame_num_minus4;

311 SPS *sps;

312

313 profile_idc = get_bits(&h->gb, 8);

314 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag

315 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag

316 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag

317 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag

318 constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag

319 constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag

320 skip_bits(&h->gb, 2); // reserved_zero_2bits

321 level_idc = get_bits(&h->gb, 8);

322 sps_id = get_ue_golomb_31(&h->gb);

323

324 if (sps_id >= MAX_SPS_COUNT) {

325 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);

326 return AVERROR_INVALIDDATA;

327 }

328 sps = av_mallocz(sizeof(SPS));

329 if (!sps)

330 return AVERROR(ENOMEM);

331

332 sps->sps_id = sps_id;

333 sps->time_offset_length = 24;

334 sps->profile_idc = profile_idc;

335 sps->constraint_set_flags = constraint_set_flags;

336 sps->level_idc = level_idc;

337 sps->full_range = -1;

338

339 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));

340 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));

341 sps->scaling_matrix_present = 0;

342 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED

343

344 if (sps->profile_idc == 100 || // High profile

345 sps->profile_idc == 110 || // High10 profile

346 sps->profile_idc == 122 || // High422 profile

347 sps->profile_idc == 244 || // High444 Predictive profile

348 sps->profile_idc == 44 || // Cavlc444 profile

349 sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)

350 sps->profile_idc == 86 || // Scalable High Intra profile (SVC)

351 sps->profile_idc == 118 || // Stereo High profile (MVC)

352 sps->profile_idc == 128 || // Multiview High profile (MVC)

353 sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)

354 sps->profile_idc == 144) { // old High444 profile

355 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);

356 if (sps->chroma_format_idc > 3U) {

357 avpriv_request_sample(h->avctx, "chroma_format_idc %u",

358 sps->chroma_format_idc);

359 goto fail;

360 } else if (sps->chroma_format_idc == 3) {

361 sps->residual_color_transform_flag = get_bits1(&h->gb);

362 if (sps->residual_color_transform_flag) {

363 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");

364 goto fail;

365 }

366 }

367 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;

368 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;

369 if (sps->bit_depth_chroma != sps->bit_depth_luma) {

370 avpriv_request_sample(h->avctx,

371 "Different chroma and luma bit depth");

372 goto fail;

373 }

374 if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||

375 sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {

376 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",

377 sps->bit_depth_luma, sps->bit_depth_chroma);

378 goto fail;

379 }

380 sps->transform_bypass = get_bits1(&h->gb);

381 decode_scaling_matrices(h, sps, NULL, 1,

382 sps->scaling_matrix4, sps->scaling_matrix8);

383 } else {

384 sps->chroma_format_idc = 1;

385 sps->bit_depth_luma = 8;

386 sps->bit_depth_chroma = 8;

387 }

388

389 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);

390 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||

391 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {

392 av_log(h->avctx, AV_LOG_ERROR,

393 "log2_max_frame_num_minus4 out of range (0-12): %d\n",

394 log2_max_frame_num_minus4);

395 goto fail;

396 }

397 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;

398

399 sps->poc_type = get_ue_golomb_31(&h->gb);

400

401 if (sps->poc_type == 0) { // FIXME #define

402 unsigned t = get_ue_golomb(&h->gb);

403 if (t>12) {

404 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);

405 goto fail;

406 }

407 sps->log2_max_poc_lsb = t + 4;

408 } else if (sps->poc_type == 1) { // FIXME #define

409 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);

410 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);

411 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);

412 sps->poc_cycle_length = get_ue_golomb(&h->gb);

413

414 if ((unsigned)sps->poc_cycle_length >=

415 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {

416 av_log(h->avctx, AV_LOG_ERROR,

417 "poc_cycle_length overflow %d\n", sps->poc_cycle_length);

418 goto fail;

419 }

420

421 for (i = 0; i < sps->poc_cycle_length; i++)

422 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);

423 } else if (sps->poc_type != 2) {

424 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);

425 goto fail;

426 }

427

428 sps->ref_frame_count = get_ue_golomb_31(&h->gb);

429 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))

430 sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);

431 if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||

432 sps->ref_frame_count > 16U) {

433 av_log(h->avctx, AV_LOG_ERROR,

434 "too many reference frames %d\n", sps->ref_frame_count);

435 goto fail;

436 }

437 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);

438 sps->mb_width = get_ue_golomb(&h->gb) + 1;

439 sps->mb_height = get_ue_golomb(&h->gb) + 1;

440 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||

441 (unsigned)sps->mb_height >= INT_MAX / 16 ||

442 av_image_check_size(16 * sps->mb_width,

443 16 * sps->mb_height, 0, h->avctx)) {

444 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");

445 goto fail;

446 }

447

448 sps->frame_mbs_only_flag = get_bits1(&h->gb);

449 if (!sps->frame_mbs_only_flag)

450 sps->mb_aff = get_bits1(&h->gb);

451 else

452 sps->mb_aff = 0;

453

454 sps->direct_8x8_inference_flag = get_bits1(&h->gb);

455

456 #ifndef ALLOW_INTERLACE

457 if (sps->mb_aff)

458 av_log(h->avctx, AV_LOG_ERROR,

459 "MBAFF support not included; enable it at compile-time.\n");

460 #endif

461 sps->crop = get_bits1(&h->gb);

462 if (sps->crop) {

463 int crop_left = get_ue_golomb(&h->gb);

464 int crop_right = get_ue_golomb(&h->gb);

465 int crop_top = get_ue_golomb(&h->gb);

466 int crop_bottom = get_ue_golomb(&h->gb);

467 int width = 16 * sps->mb_width;

468 int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);

469

470 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {

471 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "

472 "values are l:%d r:%d t:%d b:%d\n",

473 crop_left, crop_right, crop_top, crop_bottom);

474

475 sps->crop_left =

476 sps->crop_right =

477 sps->crop_top =

478 sps->crop_bottom = 0;

479 } else {

480 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;

481 int hsub = (sps->chroma_format_idc == 1 ||

482 sps->chroma_format_idc == 2) ? 1 : 0;

483 int step_x = 1 << hsub;

484 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;

485

486 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&

487 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {

488 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));

489 av_log(h->avctx, AV_LOG_WARNING,

490 "Reducing left cropping to %d "

491 "chroma samples to preserve alignment.\n",

492 crop_left);

493 }

494

495 if (crop_left > (unsigned)INT_MAX / 4 / step_x ||

496 crop_right > (unsigned)INT_MAX / 4 / step_x ||

497 crop_top > (unsigned)INT_MAX / 4 / step_y ||

498 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||

499 (crop_left + crop_right ) * step_x >= width ||

500 (crop_top + crop_bottom) * step_y >= height

501 ) {

502 av_log(h->avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);

503 goto fail;

504 }

505

506 sps->crop_left = crop_left * step_x;

507 sps->crop_right = crop_right * step_x;

508 sps->crop_top = crop_top * step_y;

509 sps->crop_bottom = crop_bottom * step_y;

510 }

511 } else {

512 sps->crop_left =

513 sps->crop_right =

514 sps->crop_top =

515 sps->crop_bottom =

516 sps->crop = 0;

517 }

518

519 sps->vui_parameters_present_flag = get_bits1(&h->gb);

520 if (sps->vui_parameters_present_flag) {

521 int ret = decode_vui_parameters(h, sps);

522 if (ret < 0)

523 goto fail;

524 }

525

526 if (!sps->sar.den)

527 sps->sar.den = 1;

528

529 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {

530 static const char csp[4][5] = { "Gray", "420", "422", "444" };

531 av_log(h->avctx, AV_LOG_DEBUG,

532 "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%u/%u/%u/%u %s %s %"PRId32"/%"PRId32" b%d reo:%d\n",

533 sps_id, sps->profile_idc, sps->level_idc,

534 sps->poc_type,

535 sps->ref_frame_count,

536 sps->mb_width, sps->mb_height,

537 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),

538 sps->direct_8x8_inference_flag ? "8B8" : "",

539 sps->crop_left, sps->crop_right,

540 sps->crop_top, sps->crop_bottom,

541 sps->vui_parameters_present_flag ? "VUI" : "",

542 csp[sps->chroma_format_idc],

543 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,

544 sps->timing_info_present_flag ? sps->time_scale : 0,

545 sps->bit_depth_luma,

546 sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1

547 );

548 }

549 sps->new = 1;

550

551 av_free(h->sps_buffers[sps_id]);

552 h->sps_buffers[sps_id] = sps;

553

554 return 0;

555

556 fail:

557 av_free(sps);

558 return -1;

559 }

560

561 static void build_qp_table(PPS *pps, int t, int index, const int depth)

562 {

563 int i;

564 const int max_qp = 51 + 6 * (depth - 8);

565 for (i = 0; i < max_qp + 1; i++)

566 pps->chroma_qp_table[t][i] =

567 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];

568 }

569

570 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)

571 {

572 const SPS *sps = h->sps_buffers[pps->sps_id];

573 int profile_idc = sps->profile_idc;

574

575 if ((profile_idc == 66 || profile_idc == 77 ||

576 profile_idc == 88) && (sps->constraint_set_flags & 7)) {

577 av_log(h->avctx, AV_LOG_VERBOSE,

578 "Current profile doesn't provide more RBSP data in PPS, skipping\n");

579 return 0;

580 }

581

582 return 1;

583 }

584

585 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)

586 {

587 unsigned int pps_id = get_ue_golomb(&h->gb);

588 PPS *pps;

589 SPS *sps;

590 int qp_bd_offset;

591 int bits_left;

592

593 if (pps_id >= MAX_PPS_COUNT) {

594 av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);

595 return AVERROR_INVALIDDATA;

596 }

597

598 pps = av_mallocz(sizeof(PPS));

599 if (!pps)

600 return AVERROR(ENOMEM);

601 pps->sps_id = get_ue_golomb_31(&h->gb);

602 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||

603 !h->sps_buffers[pps->sps_id]) {

604 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);

605 goto fail;

606 }

607 sps = h->sps_buffers[pps->sps_id];

608 qp_bd_offset = 6 * (sps->bit_depth_luma - 8);

609 if (sps->bit_depth_luma > 14) {

610 av_log(h->avctx, AV_LOG_ERROR,

611 "Invalid luma bit depth=%d\n",

612 sps->bit_depth_luma);

613 goto fail;

614 } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {

615 av_log(h->avctx, AV_LOG_ERROR,

616 "Unimplemented luma bit depth=%d\n",

617 sps->bit_depth_luma);

618 goto fail;

619 }

620

621 pps->cabac = get_bits1(&h->gb);

622 pps->pic_order_present = get_bits1(&h->gb);

623 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;

624 if (pps->slice_group_count > 1) {

625 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);

626 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");

627 switch (pps->mb_slice_group_map_type) {

628 case 0:

629 #if 0

630 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |

631 | run_length[i] |1 |ue(v) |

632 #endif

633 break;

634 case 2:

635 #if 0

636 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |

637 | top_left_mb[i] |1 |ue(v) |

638 | bottom_right_mb[i] |1 |ue(v) |

639 | } | | |

640 #endif

641 break;

642 case 3:

643 case 4:

644 case 5:

645 #if 0

646 | slice_group_change_direction_flag |1 |u(1) |

647 | slice_group_change_rate_minus1 |1 |ue(v) |

648 #endif

649 break;

650 case 6:

651 #if 0

652 | slice_group_id_cnt_minus1 |1 |ue(v) |

653 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |

654 | slice_group_id[i] |1 |u(v) |

655 #endif

656 break;

657 }

658 }

659 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;

660 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;

661 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {

662 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");

663 goto fail;

664 }

665

666 pps->weighted_pred = get_bits1(&h->gb);

667 pps->weighted_bipred_idc = get_bits(&h->gb, 2);

668 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;

669 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;

670 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);

671 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);

672 pps->constrained_intra_pred = get_bits1(&h->gb);

673 pps->redundant_pic_cnt_present = get_bits1(&h->gb);

674

675 pps->transform_8x8_mode = 0;

676 // contents of sps/pps can change even if id doesn't, so reinit

677 h->dequant_coeff_pps = -1;

678 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,

679 sizeof(pps->scaling_matrix4));

680 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,

681 sizeof(pps->scaling_matrix8));

682

683 bits_left = bit_length - get_bits_count(&h->gb);

684 if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {

685 pps->transform_8x8_mode = get_bits1(&h->gb);

686 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,

687 pps->scaling_matrix4, pps->scaling_matrix8);

688 // second_chroma_qp_index_offset

689 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);

690 } else {

691 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];

692 }

693

694 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);

695 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);

696 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])

697 pps->chroma_qp_diff = 1;

698

699 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {

700 av_log(h->avctx, AV_LOG_DEBUG,

701 "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",

702 pps_id, pps->sps_id,

703 pps->cabac ? "CABAC" : "CAVLC",

704 pps->slice_group_count,

705 pps->ref_count[0], pps->ref_count[1],

706 pps->weighted_pred ? "weighted" : "",

707 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],

708 pps->deblocking_filter_parameters_present ? "LPAR" : "",

709 pps->constrained_intra_pred ? "CONSTR" : "",

710 pps->redundant_pic_cnt_present ? "REDU" : "",

711 pps->transform_8x8_mode ? "8x8DCT" : "");

712 }

713

714 av_free(h->pps_buffers[pps_id]);

715 h->pps_buffers[pps_id] = pps;

716 return 0;

717

718 fail:

719 av_free(pps);

720 return -1;

721 }

Generated on Sun Mar 8 2015 02:34:52 for FFmpeg by doxygen 1.8.2