1/* 2 * H.26L/H.264/AVC/JVT/14496-10/... SEI decoding 3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> 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 */ 21 22/** 23 * @file 24 * H.264 / AVC / MPEG-4 part10 SEI decoding. 25 * @author Michael Niedermayer <michaelni@gmx.at> 26 */ 27 28#include <limits.h> 29#include <stdio.h> 30#include <string.h> 31#include "libavutil/error.h" 32#include "libavutil/log.h" 33#include "libavutil/macros.h" 34#include "libavutil/mem.h" 35#include "atsc_a53.h" 36#include "get_bits.h" 37#include "golomb.h" 38#include "h264_ps.h" 39#include "h264_sei.h" 40#include "sei.h" 41 42#define AVERROR_PS_NOT_FOUND FFERRTAG(0xF8,'?','P','S') 43 44static const uint8_t sei_num_clock_ts_table[9] = { 45 1, 1, 1, 2, 2, 3, 3, 2, 3 46}; 47 48void ff_h264_sei_uninit(H264SEIContext *h) 49{ 50 h->recovery_point.recovery_frame_cnt = -1; 51 52 h->picture_timing.dpb_output_delay = 0; 53 h->picture_timing.cpb_removal_delay = -1; 54 55 h->picture_timing.present = 0; 56 h->buffering_period.present = 0; 57 h->frame_packing.present = 0; 58 h->film_grain_characteristics.present = 0; 59 h->display_orientation.present = 0; 60 h->afd.present = 0; 61 62 av_buffer_unref(&h->a53_caption.buf_ref); 63 for (int i = 0; i < h->unregistered.nb_buf_ref; i++) 64 av_buffer_unref(&h->unregistered.buf_ref[i]); 65 h->unregistered.nb_buf_ref = 0; 66 av_freep(&h->unregistered.buf_ref); 67} 68 69int ff_h264_sei_process_picture_timing(H264SEIPictureTiming *h, const SPS *sps, 70 void *logctx) 71{ 72 GetBitContext gb; 73 74 init_get_bits(&gb, h->payload, h->payload_size_bits); 75 76 if (sps->nal_hrd_parameters_present_flag || 77 sps->vcl_hrd_parameters_present_flag) { 78 h->cpb_removal_delay = get_bits_long(&gb, sps->cpb_removal_delay_length); 79 h->dpb_output_delay = get_bits_long(&gb, sps->dpb_output_delay_length); 80 } 81 if (sps->pic_struct_present_flag) { 82 unsigned int i, num_clock_ts; 83 84 h->pic_struct = get_bits(&gb, 4); 85 h->ct_type = 0; 86 87 if (h->pic_struct > H264_SEI_PIC_STRUCT_FRAME_TRIPLING) 88 return AVERROR_INVALIDDATA; 89 90 num_clock_ts = sei_num_clock_ts_table[h->pic_struct]; 91 h->timecode_cnt = 0; 92 for (i = 0; i < num_clock_ts; i++) { 93 if (get_bits(&gb, 1)) { /* clock_timestamp_flag */ 94 H264SEITimeCode *tc = &h->timecode[h->timecode_cnt++]; 95 unsigned int full_timestamp_flag; 96 unsigned int counting_type, cnt_dropped_flag; 97 h->ct_type |= 1 << get_bits(&gb, 2); 98 skip_bits(&gb, 1); /* nuit_field_based_flag */ 99 counting_type = get_bits(&gb, 5); /* counting_type */ 100 full_timestamp_flag = get_bits(&gb, 1); 101 skip_bits(&gb, 1); /* discontinuity_flag */ 102 cnt_dropped_flag = get_bits(&gb, 1); /* cnt_dropped_flag */ 103 if (cnt_dropped_flag && counting_type > 1 && counting_type < 7) 104 tc->dropframe = 1; 105 tc->frame = get_bits(&gb, 8); /* n_frames */ 106 if (full_timestamp_flag) { 107 tc->full = 1; 108 tc->seconds = get_bits(&gb, 6); /* seconds_value 0..59 */ 109 tc->minutes = get_bits(&gb, 6); /* minutes_value 0..59 */ 110 tc->hours = get_bits(&gb, 5); /* hours_value 0..23 */ 111 } else { 112 tc->seconds = tc->minutes = tc->hours = tc->full = 0; 113 if (get_bits(&gb, 1)) { /* seconds_flag */ 114 tc->seconds = get_bits(&gb, 6); 115 if (get_bits(&gb, 1)) { /* minutes_flag */ 116 tc->minutes = get_bits(&gb, 6); 117 if (get_bits(&gb, 1)) /* hours_flag */ 118 tc->hours = get_bits(&gb, 5); 119 } 120 } 121 } 122 123 if (sps->time_offset_length > 0) 124 skip_bits(&gb, 125 sps->time_offset_length); /* time_offset */ 126 } 127 } 128 129 av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n", 130 h->ct_type, h->pic_struct); 131 } 132 133 return 0; 134} 135 136static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb, 137 void *logctx) 138{ 139 int index = get_bits_count(gb); 140 int size_bits = get_bits_left(gb); 141 int size = (size_bits + 7) / 8; 142 143 if (index & 7) { 144 av_log(logctx, AV_LOG_ERROR, "Unaligned SEI payload\n"); 145 return AVERROR_INVALIDDATA; 146 } 147 if (size > sizeof(h->payload)) { 148 av_log(logctx, AV_LOG_ERROR, "Picture timing SEI payload too large\n"); 149 return AVERROR_INVALIDDATA; 150 } 151 memcpy(h->payload, gb->buffer + index / 8, size); 152 153 h->payload_size_bits = size_bits; 154 155 h->present = 1; 156 return 0; 157} 158 159static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int size) 160{ 161 int flag; 162 163 if (size-- < 1) 164 return AVERROR_INVALIDDATA; 165 skip_bits(gb, 1); // 0 166 flag = get_bits(gb, 1); // active_format_flag 167 skip_bits(gb, 6); // reserved 168 169 if (flag) { 170 if (size-- < 1) 171 return AVERROR_INVALIDDATA; 172 skip_bits(gb, 4); // reserved 173 h->active_format_description = get_bits(gb, 4); 174 h->present = 1; 175 } 176 177 return 0; 178} 179 180static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h, 181 GetBitContext *gb, void *logctx, 182 int size) 183{ 184 if (size < 3) 185 return AVERROR(EINVAL); 186 187 return ff_parse_a53_cc(&h->buf_ref, gb->buffer + get_bits_count(gb) / 8, size); 188} 189 190static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb, 191 void *logctx, int size) 192{ 193 int country_code, provider_code; 194 195 if (size < 3) 196 return AVERROR_INVALIDDATA; 197 size -= 3; 198 199 country_code = get_bits(gb, 8); // itu_t_t35_country_code 200 if (country_code == 0xFF) { 201 if (size < 1) 202 return AVERROR_INVALIDDATA; 203 204 skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte 205 size--; 206 } 207 208 if (country_code != 0xB5) { // usa_country_code 209 av_log(logctx, AV_LOG_VERBOSE, 210 "Unsupported User Data Registered ITU-T T35 SEI message (country_code = %d)\n", 211 country_code); 212 return 0; 213 } 214 215 /* itu_t_t35_payload_byte follows */ 216 provider_code = get_bits(gb, 16); 217 218 switch (provider_code) { 219 case 0x31: { // atsc_provider_code 220 uint32_t user_identifier; 221 222 if (size < 4) 223 return AVERROR_INVALIDDATA; 224 size -= 4; 225 226 user_identifier = get_bits_long(gb, 32); 227 switch (user_identifier) { 228 case MKBETAG('D', 'T', 'G', '1'): // afd_data 229 return decode_registered_user_data_afd(&h->afd, gb, size); 230 case MKBETAG('G', 'A', '9', '4'): // closed captions 231 return decode_registered_user_data_closed_caption(&h->a53_caption, gb, 232 logctx, size); 233 default: 234 av_log(logctx, AV_LOG_VERBOSE, 235 "Unsupported User Data Registered ITU-T T35 SEI message (atsc user_identifier = 0x%04x)\n", 236 user_identifier); 237 break; 238 } 239 break; 240 } 241 default: 242 av_log(logctx, AV_LOG_VERBOSE, 243 "Unsupported User Data Registered ITU-T T35 SEI message (provider_code = %d)\n", 244 provider_code); 245 break; 246 } 247 248 return 0; 249} 250 251static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb, 252 void *logctx, int size) 253{ 254 uint8_t *user_data; 255 int e, build, i; 256 AVBufferRef *buf_ref, **tmp; 257 258 if (size < 16 || size >= INT_MAX - 1) 259 return AVERROR_INVALIDDATA; 260 261 tmp = av_realloc_array(h->buf_ref, h->nb_buf_ref + 1, sizeof(*h->buf_ref)); 262 if (!tmp) 263 return AVERROR(ENOMEM); 264 h->buf_ref = tmp; 265 266 buf_ref = av_buffer_alloc(size + 1); 267 if (!buf_ref) 268 return AVERROR(ENOMEM); 269 user_data = buf_ref->data; 270 271 for (i = 0; i < size; i++) 272 user_data[i] = get_bits(gb, 8); 273 274 user_data[i] = 0; 275 buf_ref->size = size; 276 h->buf_ref[h->nb_buf_ref++] = buf_ref; 277 278 e = sscanf(user_data + 16, "x264 - core %d", &build); 279 if (e == 1 && build > 0) 280 h->x264_build = build; 281 if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16)) 282 h->x264_build = 67; 283 284 return 0; 285} 286 287static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb, void *logctx) 288{ 289 unsigned recovery_frame_cnt = get_ue_golomb_long(gb); 290 291 if (recovery_frame_cnt >= (1<<MAX_LOG2_MAX_FRAME_NUM)) { 292 av_log(logctx, AV_LOG_ERROR, "recovery_frame_cnt %u is out of range\n", recovery_frame_cnt); 293 return AVERROR_INVALIDDATA; 294 } 295 296 h->recovery_frame_cnt = recovery_frame_cnt; 297 /* 1b exact_match_flag, 298 * 1b broken_link_flag, 299 * 2b changing_slice_group_idc */ 300 skip_bits(gb, 4); 301 302 return 0; 303} 304 305static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, 306 const H264ParamSets *ps, void *logctx) 307{ 308 unsigned int sps_id; 309 int sched_sel_idx; 310 const SPS *sps; 311 312 sps_id = get_ue_golomb_31(gb); 313 if (sps_id > 31 || !ps->sps_list[sps_id]) { 314 av_log(logctx, AV_LOG_ERROR, 315 "non-existing SPS %d referenced in buffering period\n", sps_id); 316 return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND; 317 } 318 sps = (const SPS*)ps->sps_list[sps_id]->data; 319 320 // NOTE: This is really so duplicated in the standard... See H.264, D.1.1 321 if (sps->nal_hrd_parameters_present_flag) { 322 for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) { 323 h->initial_cpb_removal_delay[sched_sel_idx] = 324 get_bits_long(gb, sps->initial_cpb_removal_delay_length); 325 // initial_cpb_removal_delay_offset 326 skip_bits(gb, sps->initial_cpb_removal_delay_length); 327 } 328 } 329 if (sps->vcl_hrd_parameters_present_flag) { 330 for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) { 331 h->initial_cpb_removal_delay[sched_sel_idx] = 332 get_bits_long(gb, sps->initial_cpb_removal_delay_length); 333 // initial_cpb_removal_delay_offset 334 skip_bits(gb, sps->initial_cpb_removal_delay_length); 335 } 336 } 337 338 h->present = 1; 339 return 0; 340} 341 342static int decode_frame_packing_arrangement(H264SEIFramePacking *h, 343 GetBitContext *gb) 344{ 345 h->arrangement_id = get_ue_golomb_long(gb); 346 h->arrangement_cancel_flag = get_bits1(gb); 347 h->present = !h->arrangement_cancel_flag; 348 349 if (h->present) { 350 h->arrangement_type = get_bits(gb, 7); 351 h->quincunx_sampling_flag = get_bits1(gb); 352 h->content_interpretation_type = get_bits(gb, 6); 353 354 // spatial_flipping_flag, frame0_flipped_flag, field_views_flag 355 skip_bits(gb, 3); 356 h->current_frame_is_frame0_flag = get_bits1(gb); 357 // frame0_self_contained_flag, frame1_self_contained_flag 358 skip_bits(gb, 2); 359 360 if (!h->quincunx_sampling_flag && h->arrangement_type != 5) 361 skip_bits(gb, 16); // frame[01]_grid_position_[xy] 362 skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte 363 h->arrangement_repetition_period = get_ue_golomb_long(gb); 364 } 365 skip_bits1(gb); // frame_packing_arrangement_extension_flag 366 367 return 0; 368} 369 370static int decode_display_orientation(H264SEIDisplayOrientation *h, 371 GetBitContext *gb) 372{ 373 h->present = !get_bits1(gb); 374 375 if (h->present) { 376 h->hflip = get_bits1(gb); // hor_flip 377 h->vflip = get_bits1(gb); // ver_flip 378 379 h->anticlockwise_rotation = get_bits(gb, 16); 380 get_ue_golomb_long(gb); // display_orientation_repetition_period 381 skip_bits1(gb); // display_orientation_extension_flag 382 } 383 384 return 0; 385} 386 387static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb) 388{ 389 h->green_metadata_type = get_bits(gb, 8); 390 391 if (h->green_metadata_type == 0) { 392 h->period_type = get_bits(gb, 8); 393 394 if (h->period_type == 2) 395 h->num_seconds = get_bits(gb, 16); 396 else if (h->period_type == 3) 397 h->num_pictures = get_bits(gb, 16); 398 399 h->percent_non_zero_macroblocks = get_bits(gb, 8); 400 h->percent_intra_coded_macroblocks = get_bits(gb, 8); 401 h->percent_six_tap_filtering = get_bits(gb, 8); 402 h->percent_alpha_point_deblocking_instance = get_bits(gb, 8); 403 404 } else if (h->green_metadata_type == 1) { 405 h->xsd_metric_type = get_bits(gb, 8); 406 h->xsd_metric_value = get_bits(gb, 16); 407 } 408 409 return 0; 410} 411 412static int decode_alternative_transfer(H264SEIAlternativeTransfer *h, 413 GetBitContext *gb) 414{ 415 h->present = 1; 416 h->preferred_transfer_characteristics = get_bits(gb, 8); 417 return 0; 418} 419 420static int decode_film_grain_characteristics(H264SEIFilmGrainCharacteristics *h, 421 GetBitContext *gb) 422{ 423 h->present = !get_bits1(gb); // film_grain_characteristics_cancel_flag 424 425 if (h->present) { 426 memset(h, 0, sizeof(*h)); 427 h->model_id = get_bits(gb, 2); 428 h->separate_colour_description_present_flag = get_bits1(gb); 429 if (h->separate_colour_description_present_flag) { 430 h->bit_depth_luma = get_bits(gb, 3) + 8; 431 h->bit_depth_chroma = get_bits(gb, 3) + 8; 432 h->full_range = get_bits1(gb); 433 h->color_primaries = get_bits(gb, 8); 434 h->transfer_characteristics = get_bits(gb, 8); 435 h->matrix_coeffs = get_bits(gb, 8); 436 } 437 h->blending_mode_id = get_bits(gb, 2); 438 h->log2_scale_factor = get_bits(gb, 4); 439 for (int c = 0; c < 3; c++) 440 h->comp_model_present_flag[c] = get_bits1(gb); 441 for (int c = 0; c < 3; c++) { 442 if (h->comp_model_present_flag[c]) { 443 h->num_intensity_intervals[c] = get_bits(gb, 8) + 1; 444 h->num_model_values[c] = get_bits(gb, 3) + 1; 445 if (h->num_model_values[c] > 6) 446 return AVERROR_INVALIDDATA; 447 for (int i = 0; i < h->num_intensity_intervals[c]; i++) { 448 h->intensity_interval_lower_bound[c][i] = get_bits(gb, 8); 449 h->intensity_interval_upper_bound[c][i] = get_bits(gb, 8); 450 for (int j = 0; j < h->num_model_values[c]; j++) 451 h->comp_model_value[c][i][j] = get_se_golomb_long(gb); 452 } 453 } 454 } 455 h->repetition_period = get_ue_golomb_long(gb); 456 457 h->present = 1; 458 } 459 460 return 0; 461} 462 463int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, 464 const H264ParamSets *ps, void *logctx) 465{ 466 int master_ret = 0; 467 468 while (get_bits_left(gb) > 16 && show_bits(gb, 16)) { 469 GetBitContext gb_payload; 470 int type = 0; 471 unsigned size = 0; 472 int ret = 0; 473 474 do { 475 if (get_bits_left(gb) < 8) 476 return AVERROR_INVALIDDATA; 477 type += show_bits(gb, 8); 478 } while (get_bits(gb, 8) == 255); 479 480 do { 481 if (get_bits_left(gb) < 8) 482 return AVERROR_INVALIDDATA; 483 size += show_bits(gb, 8); 484 } while (get_bits(gb, 8) == 255); 485 486 if (size > get_bits_left(gb) / 8) { 487 av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n", 488 type, 8*size, get_bits_left(gb)); 489 return AVERROR_INVALIDDATA; 490 } 491 492 ret = init_get_bits8(&gb_payload, gb->buffer + get_bits_count(gb) / 8, size); 493 if (ret < 0) 494 return ret; 495 496 switch (type) { 497 case SEI_TYPE_PIC_TIMING: // Picture timing SEI 498 ret = decode_picture_timing(&h->picture_timing, &gb_payload, logctx); 499 break; 500 case SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35: 501 ret = decode_registered_user_data(h, &gb_payload, logctx, size); 502 break; 503 case SEI_TYPE_USER_DATA_UNREGISTERED: 504 ret = decode_unregistered_user_data(&h->unregistered, &gb_payload, logctx, size); 505 break; 506 case SEI_TYPE_RECOVERY_POINT: 507 ret = decode_recovery_point(&h->recovery_point, &gb_payload, logctx); 508 break; 509 case SEI_TYPE_BUFFERING_PERIOD: 510 ret = decode_buffering_period(&h->buffering_period, &gb_payload, ps, logctx); 511 break; 512 case SEI_TYPE_FRAME_PACKING_ARRANGEMENT: 513 ret = decode_frame_packing_arrangement(&h->frame_packing, &gb_payload); 514 break; 515 case SEI_TYPE_DISPLAY_ORIENTATION: 516 ret = decode_display_orientation(&h->display_orientation, &gb_payload); 517 break; 518 case SEI_TYPE_GREEN_METADATA: 519 ret = decode_green_metadata(&h->green_metadata, &gb_payload); 520 break; 521 case SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS: 522 ret = decode_alternative_transfer(&h->alternative_transfer, &gb_payload); 523 break; 524 case SEI_TYPE_FILM_GRAIN_CHARACTERISTICS: 525 ret = decode_film_grain_characteristics(&h->film_grain_characteristics, &gb_payload); 526 break; 527 default: 528 av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type); 529 } 530 if (ret < 0 && ret != AVERROR_PS_NOT_FOUND) 531 return ret; 532 if (ret < 0) 533 master_ret = ret; 534 535 if (get_bits_left(&gb_payload) < 0) { 536 av_log(logctx, AV_LOG_WARNING, "SEI type %d overread by %d bits\n", 537 type, -get_bits_left(&gb_payload)); 538 } 539 540 skip_bits_long(gb, 8 * size); 541 } 542 543 return master_ret; 544} 545 546const char *ff_h264_sei_stereo_mode(const H264SEIFramePacking *h) 547{ 548 if (h->arrangement_cancel_flag == 0) { 549 switch (h->arrangement_type) { 550 case H264_SEI_FPA_TYPE_CHECKERBOARD: 551 if (h->content_interpretation_type == 2) 552 return "checkerboard_rl"; 553 else 554 return "checkerboard_lr"; 555 case H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN: 556 if (h->content_interpretation_type == 2) 557 return "col_interleaved_rl"; 558 else 559 return "col_interleaved_lr"; 560 case H264_SEI_FPA_TYPE_INTERLEAVE_ROW: 561 if (h->content_interpretation_type == 2) 562 return "row_interleaved_rl"; 563 else 564 return "row_interleaved_lr"; 565 case H264_SEI_FPA_TYPE_SIDE_BY_SIDE: 566 if (h->content_interpretation_type == 2) 567 return "right_left"; 568 else 569 return "left_right"; 570 case H264_SEI_FPA_TYPE_TOP_BOTTOM: 571 if (h->content_interpretation_type == 2) 572 return "bottom_top"; 573 else 574 return "top_bottom"; 575 case H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL: 576 if (h->content_interpretation_type == 2) 577 return "block_rl"; 578 else 579 return "block_lr"; 580 case H264_SEI_FPA_TYPE_2D: 581 default: 582 return "mono"; 583 } 584 } else if (h->arrangement_cancel_flag == 1) { 585 return "mono"; 586 } else { 587 return NULL; 588 } 589} 590