--- /dev/null
+/* GStreamer
+ * Copyright (C) 2020 Intel Corporation
+ * Author: He Junyan <junyan.he@intel.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the0
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <gst/check/gstcheck.h>
+#include <gst/codecparsers/gsth264bitwriter.h>
+
+/* *INDENT-OFF* */
+static const GstH264SPS sps = {
+ .id = 0,
+ .profile_idc = 100,
+ .constraint_set0_flag = 0,
+ .constraint_set1_flag = 0,
+ .constraint_set2_flag = 0,
+ .constraint_set3_flag = 0,
+ .constraint_set4_flag = 0,
+ .constraint_set5_flag = 0,
+ .level_idc = 31,
+
+ .chroma_format_idc = 1,
+ .bit_depth_luma_minus8 = 0,
+ .bit_depth_chroma_minus8 = 0,
+
+ .scaling_matrix_present_flag = 1,
+ .scaling_lists_4x4[0] = { 17, 32, 31, 30, 23, 15, 33, 39, 39, 35, 35, 14, 28, 32, 27, 27 },
+
+ .log2_max_frame_num_minus4 = 2,
+ .pic_order_cnt_type = 0,
+ .log2_max_pic_order_cnt_lsb_minus4 = 3,
+
+ .num_ref_frames = 8,
+ .gaps_in_frame_num_value_allowed_flag = 0,
+ .pic_width_in_mbs_minus1 = 49,
+ .pic_height_in_map_units_minus1 = 37,
+ .frame_mbs_only_flag = 1,
+ .mb_adaptive_frame_field_flag = 0,
+ .direct_8x8_inference_flag = 1,
+ .frame_cropping_flag = 1,
+ .frame_crop_left_offset = 8,
+ .frame_crop_right_offset = 8,
+ .frame_crop_top_offset = 16,
+ .frame_crop_bottom_offset = 8,
+
+ .vui_parameters_present_flag = 1,
+ .vui_parameters = {
+ .aspect_ratio_info_present_flag = 1,
+ .aspect_ratio_idc = 255,
+ .sar_width = 1,
+ .sar_height = 1,
+ .overscan_info_present_flag = 0,
+ .overscan_appropriate_flag = 0,
+ .chroma_loc_info_present_flag = 0,
+ .timing_info_present_flag = 1,
+ .num_units_in_tick = 1,
+ .time_scale = 60,
+ .fixed_frame_rate_flag = 1,
+
+ .nal_hrd_parameters_present_flag = 1,
+ .nal_hrd_parameters = {
+ .cpb_cnt_minus1 = 0,
+ .bit_rate_scale = 4,
+ .cpb_size_scale = 2,
+ .bit_rate_value_minus1[0] = 1999,
+ .cpb_size_value_minus1[0] = 63999,
+ .cbr_flag[0] = 1,
+ .initial_cpb_removal_delay_length_minus1 = 23,
+ .cpb_removal_delay_length_minus1 = 23,
+ .dpb_output_delay_length_minus1 = 23,
+ .time_offset_length = 24,
+ },
+
+ .vcl_hrd_parameters_present_flag = 0,
+ .low_delay_hrd_flag = 0,
+ .pic_struct_present_flag = 1,
+ .bitstream_restriction_flag = 1,
+ .motion_vectors_over_pic_boundaries_flag = 1,
+ .max_bytes_per_pic_denom = 2,
+ .max_bits_per_mb_denom = 1,
+ .log2_max_mv_length_horizontal = 13,
+ .log2_max_mv_length_vertical = 11,
+ .num_reorder_frames = 3,
+ .max_dec_frame_buffering = 8,
+ },
+};
+
+static const GstH264PPS pps = {
+ .id = 2,
+ .entropy_coding_mode_flag = 1,
+ .pic_order_present_flag = 0,
+ .num_slice_groups_minus1 = 0,
+
+ .num_ref_idx_l0_active_minus1 = 4,
+ .num_ref_idx_l1_active_minus1 = 2,
+
+ .weighted_pred_flag = 0,
+ .weighted_bipred_idc = 0,
+ .pic_init_qp_minus26 = 2,
+ .pic_init_qs_minus26 = 0,
+ .chroma_qp_index_offset = 1,
+ .deblocking_filter_control_present_flag = 1,
+ .constrained_intra_pred_flag = 0,
+ .redundant_pic_cnt_present_flag = 0,
+ .transform_8x8_mode_flag = 0,
+
+ .pic_scaling_matrix_present_flag = 0,
+ .second_chroma_qp_index_offset = 0,
+
+ .sequence = (GstH264SPS *) &sps,
+};
+
+static const GstH264SliceHdr slice_hdr = {
+ .first_mb_in_slice = 0,
+ .type = 1,
+ .frame_num = 10,
+
+ .field_pic_flag = 0,
+ .bottom_field_flag = 0,
+ .idr_pic_id = 0,
+
+ .pic_order_cnt_lsb = 4,
+ .delta_pic_order_cnt_bottom = 0,
+
+ .direct_spatial_mv_pred_flag = 1,
+
+ .num_ref_idx_active_override_flag = 1,
+ .num_ref_idx_l0_active_minus1 = 2,
+ .num_ref_idx_l1_active_minus1 = 2,
+
+ .ref_pic_list_modification_flag_l0 = 0,
+ .ref_pic_list_modification_flag_l1 = 0,
+
+ .dec_ref_pic_marking.no_output_of_prior_pics_flag = 0,
+ .dec_ref_pic_marking.long_term_reference_flag = 0,
+ .dec_ref_pic_marking.adaptive_ref_pic_marking_mode_flag = 0,
+
+ .cabac_init_idc = 1,
+ .slice_qp_delta = 8,
+
+ .disable_deblocking_filter_idc = 0,
+ .slice_alpha_c0_offset_div2 = 2,
+ .slice_beta_offset_div2 = 2,
+
+ .pps = (GstH264PPS *) &pps,
+};
+/* *INDENT-ON* */
+
+GST_START_TEST (test_h264_bitwriter_sps_pps_slice_hdr)
+{
+ GstH264ParserResult res;
+ gboolean ret;
+ GstH264NalUnit nalu;
+ GstH264NalParser *const parser = gst_h264_nal_parser_new ();
+ GstH264SPS sps_parsed;
+ GstH264PPS pps_parsed;
+ GstH264SliceHdr slice_parsed;
+ guint8 header_data[128] = { 0, };
+ guint8 header_nal[128] = { 0, };
+ gsize size;
+ guint32 nal_size;
+ guint i;
+
+ size = sizeof (header_data);
+ ret = gst_h264_bit_writer_sps (&sps, TRUE, header_data, &size);
+ fail_if (ret != GST_H264_BIT_WRITER_OK);
+
+ nal_size = sizeof (header_nal);
+ ret = gst_h264_bit_writer_convert_to_nal (4, FALSE, TRUE, FALSE,
+ header_data, size, header_nal, &nal_size);
+ fail_if (ret != GST_H264_BIT_WRITER_OK);
+ fail_if (nal_size < GST_ROUND_UP_8 (size) / 8);
+
+ /* Parse it again */
+ res = gst_h264_parser_identify_nalu (parser, header_nal, 0,
+ sizeof (header_nal), &nalu);
+ assert_equals_int (res, GST_H264_PARSER_NO_NAL_END);
+
+ res = gst_h264_parser_parse_sps (parser, &nalu, &sps_parsed);
+ assert_equals_int (res, GST_H264_PARSER_OK);
+
+ /* We can not do simply memcmp, the parser may set some default
+ value for the fields which are not used for writing. */
+#define CHECK_FIELD(FIELD) fail_if(sps_parsed.FIELD != sps.FIELD)
+ CHECK_FIELD (id);
+ CHECK_FIELD (profile_idc);
+ CHECK_FIELD (constraint_set0_flag);
+ CHECK_FIELD (constraint_set1_flag);
+ CHECK_FIELD (constraint_set2_flag);
+ CHECK_FIELD (constraint_set3_flag);
+ CHECK_FIELD (constraint_set4_flag);
+ CHECK_FIELD (constraint_set5_flag);
+ CHECK_FIELD (level_idc);
+
+ CHECK_FIELD (chroma_format_idc);
+ CHECK_FIELD (bit_depth_luma_minus8);
+ CHECK_FIELD (bit_depth_chroma_minus8);
+
+ CHECK_FIELD (scaling_matrix_present_flag);
+ for (i = 0; i < 16; i++)
+ CHECK_FIELD (scaling_lists_4x4[0][i]);
+
+ CHECK_FIELD (log2_max_frame_num_minus4);
+ CHECK_FIELD (pic_order_cnt_type);
+ CHECK_FIELD (log2_max_pic_order_cnt_lsb_minus4);
+
+ CHECK_FIELD (num_ref_frames);
+ CHECK_FIELD (gaps_in_frame_num_value_allowed_flag);
+ CHECK_FIELD (pic_width_in_mbs_minus1);
+ CHECK_FIELD (pic_height_in_map_units_minus1);
+ CHECK_FIELD (frame_mbs_only_flag);
+ CHECK_FIELD (mb_adaptive_frame_field_flag);
+ CHECK_FIELD (direct_8x8_inference_flag);
+ CHECK_FIELD (frame_cropping_flag);
+ CHECK_FIELD (frame_crop_left_offset);
+ CHECK_FIELD (frame_crop_right_offset);
+ CHECK_FIELD (frame_crop_top_offset);
+ CHECK_FIELD (frame_crop_bottom_offset);
+
+ CHECK_FIELD (vui_parameters_present_flag);
+ CHECK_FIELD (vui_parameters.aspect_ratio_info_present_flag);
+ CHECK_FIELD (vui_parameters.aspect_ratio_idc);
+ CHECK_FIELD (vui_parameters.sar_width);
+ CHECK_FIELD (vui_parameters.sar_height);
+ CHECK_FIELD (vui_parameters.overscan_info_present_flag);
+ CHECK_FIELD (vui_parameters.overscan_appropriate_flag);
+ CHECK_FIELD (vui_parameters.chroma_loc_info_present_flag);
+ CHECK_FIELD (vui_parameters.timing_info_present_flag);
+ CHECK_FIELD (vui_parameters.num_units_in_tick);
+ CHECK_FIELD (vui_parameters.time_scale);
+ CHECK_FIELD (vui_parameters.fixed_frame_rate_flag);
+
+ CHECK_FIELD (vui_parameters.nal_hrd_parameters_present_flag);
+ CHECK_FIELD (vui_parameters.nal_hrd_parameters.cpb_cnt_minus1);
+ CHECK_FIELD (vui_parameters.nal_hrd_parameters.bit_rate_scale);
+ CHECK_FIELD (vui_parameters.nal_hrd_parameters.cpb_size_scale);
+ CHECK_FIELD (vui_parameters.nal_hrd_parameters.bit_rate_value_minus1[0]);
+ CHECK_FIELD (vui_parameters.nal_hrd_parameters.cpb_size_value_minus1[0]);
+ CHECK_FIELD (vui_parameters.nal_hrd_parameters.cbr_flag[0]);
+ CHECK_FIELD (vui_parameters.
+ nal_hrd_parameters.initial_cpb_removal_delay_length_minus1);
+ CHECK_FIELD (vui_parameters.
+ nal_hrd_parameters.cpb_removal_delay_length_minus1);
+ CHECK_FIELD (vui_parameters.
+ nal_hrd_parameters.dpb_output_delay_length_minus1);
+ CHECK_FIELD (vui_parameters.nal_hrd_parameters.time_offset_length);
+
+ CHECK_FIELD (vui_parameters.vcl_hrd_parameters_present_flag);
+ CHECK_FIELD (vui_parameters.low_delay_hrd_flag);
+ CHECK_FIELD (vui_parameters.pic_struct_present_flag);
+ CHECK_FIELD (vui_parameters.bitstream_restriction_flag);
+ CHECK_FIELD (vui_parameters.motion_vectors_over_pic_boundaries_flag);
+ CHECK_FIELD (vui_parameters.max_bytes_per_pic_denom);
+ CHECK_FIELD (vui_parameters.max_bits_per_mb_denom);
+ CHECK_FIELD (vui_parameters.log2_max_mv_length_horizontal);
+ CHECK_FIELD (vui_parameters.log2_max_mv_length_vertical);
+ CHECK_FIELD (vui_parameters.num_reorder_frames);
+ CHECK_FIELD (vui_parameters.max_dec_frame_buffering);
+#undef CHECK_FIELD
+
+ memset (header_data, 0, sizeof (header_data));
+ memset (header_nal, 0, sizeof (header_nal));
+
+ size = sizeof (header_data);
+ ret = gst_h264_bit_writer_pps (&pps, TRUE, header_data, &size);
+ fail_if (ret != GST_H264_BIT_WRITER_OK);
+
+ nal_size = sizeof (header_nal);
+ ret = gst_h264_bit_writer_convert_to_nal (4, FALSE, TRUE, FALSE,
+ header_data, size, header_nal, &nal_size);
+ fail_if (ret != GST_H264_BIT_WRITER_OK);
+ fail_if (nal_size < GST_ROUND_UP_8 (size) / 8);
+
+ /* Parse it again */
+ res = gst_h264_parser_identify_nalu (parser, header_nal, 0,
+ sizeof (header_nal), &nalu);
+ assert_equals_int (res, GST_H264_PARSER_NO_NAL_END);
+
+ res = gst_h264_parser_parse_pps (parser, &nalu, &pps_parsed);
+ assert_equals_int (res, GST_H264_PARSER_OK);
+
+#define CHECK_FIELD(FIELD) fail_if(pps_parsed.FIELD != pps.FIELD)
+ CHECK_FIELD (id);
+ CHECK_FIELD (entropy_coding_mode_flag);
+ CHECK_FIELD (pic_order_present_flag);
+ CHECK_FIELD (num_slice_groups_minus1);
+
+ CHECK_FIELD (num_ref_idx_l0_active_minus1);
+ CHECK_FIELD (num_ref_idx_l1_active_minus1);
+
+ CHECK_FIELD (weighted_pred_flag);
+ CHECK_FIELD (weighted_bipred_idc);
+ CHECK_FIELD (pic_init_qp_minus26);
+ CHECK_FIELD (pic_init_qs_minus26);
+ CHECK_FIELD (chroma_qp_index_offset);
+ CHECK_FIELD (deblocking_filter_control_present_flag);
+ CHECK_FIELD (constrained_intra_pred_flag);
+ CHECK_FIELD (redundant_pic_cnt_present_flag);
+ CHECK_FIELD (transform_8x8_mode_flag);
+
+ CHECK_FIELD (pic_scaling_matrix_present_flag);
+ CHECK_FIELD (second_chroma_qp_index_offset);
+#undef CHECK_FIELD
+
+ memset (header_data, 0, sizeof (header_data));
+ memset (header_nal, 0, sizeof (header_nal));
+
+ size = sizeof (header_data);
+ ret = gst_h264_bit_writer_slice_hdr (&slice_hdr, TRUE, GST_H264_NAL_SLICE,
+ FALSE, header_data, &size);
+ fail_if (ret != GST_H264_BIT_WRITER_OK);
+
+ nal_size = sizeof (header_nal);
+ ret = gst_h264_bit_writer_convert_to_nal (4, FALSE, TRUE, FALSE,
+ header_data, GST_ROUND_UP_8 (size), header_nal, &nal_size);
+ fail_if (ret != GST_H264_BIT_WRITER_OK);
+ fail_if (nal_size < GST_ROUND_UP_8 (size) / 8);
+
+ /* Parse it again */
+ res = gst_h264_parser_identify_nalu (parser, header_nal, 0,
+ sizeof (header_nal), &nalu);
+ assert_equals_int (res, GST_H264_PARSER_NO_NAL_END);
+
+ res = gst_h264_parser_parse_slice_hdr (parser, &nalu, &slice_parsed,
+ TRUE, TRUE);
+ assert_equals_int (res, GST_H264_PARSER_OK);
+
+#define CHECK_FIELD(FIELD) fail_if(slice_parsed.FIELD != slice_hdr.FIELD)
+ CHECK_FIELD (first_mb_in_slice);
+ CHECK_FIELD (type);
+ CHECK_FIELD (frame_num);
+ CHECK_FIELD (field_pic_flag);
+ CHECK_FIELD (bottom_field_flag);
+ CHECK_FIELD (idr_pic_id);
+ CHECK_FIELD (pic_order_cnt_lsb);
+ CHECK_FIELD (delta_pic_order_cnt_bottom);
+ CHECK_FIELD (direct_spatial_mv_pred_flag);
+ CHECK_FIELD (num_ref_idx_active_override_flag);
+ CHECK_FIELD (num_ref_idx_l0_active_minus1);
+ CHECK_FIELD (num_ref_idx_l1_active_minus1);
+ CHECK_FIELD (ref_pic_list_modification_flag_l0);
+ CHECK_FIELD (ref_pic_list_modification_flag_l1);
+ CHECK_FIELD (dec_ref_pic_marking.no_output_of_prior_pics_flag);
+ CHECK_FIELD (dec_ref_pic_marking.long_term_reference_flag);
+ CHECK_FIELD (dec_ref_pic_marking.adaptive_ref_pic_marking_mode_flag);
+ CHECK_FIELD (cabac_init_idc);
+ CHECK_FIELD (slice_qp_delta);
+ CHECK_FIELD (disable_deblocking_filter_idc);
+ CHECK_FIELD (slice_alpha_c0_offset_div2);
+ CHECK_FIELD (slice_beta_offset_div2);
+#undef CHECK_FIELD
+
+ gst_h264_nal_parser_free (parser);
+}
+
+GST_END_TEST;
+
+static const guint8 nalu_sps[] = {
+ 0x00, 0x00, 0x00, 0x01, 0x27, 0x64, 0x00, 0x32, 0xac, 0x2c, 0xa2,
+ 0x40, 0x78, 0x02, 0x27, 0xe5, 0xc0, 0x50, 0x80, 0x80, 0x80, 0xa0,
+ 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0x07, 0x9d, 0x08, 0x00,
+ 0x7a, 0x10, 0x00, 0x07, 0xa1, 0x23, 0x7b, 0xdf, 0x07, 0x68, 0x70,
+ 0xc2, 0x89, 0x80,
+};
+
+GST_START_TEST (test_h264_bitwriter_sei)
+{
+ GstH264ParserResult res;
+ GstH264NalUnit nalu;
+ GstH264SEIMessage sei_msg = { 0, };
+ gboolean ret;
+ GstH264SPS sps_parsed;
+ GstH264HRDParams *hrd_param = &sps_parsed.vui_parameters.nal_hrd_parameters;
+ GstH264NalParser *const parser = gst_h264_nal_parser_new ();
+ GstH264PicTiming *pic_timing = &sei_msg.payload.pic_timing;
+ GstH264BufferingPeriod *buf_per = &sei_msg.payload.buffering_period;
+ GstH264PicTiming *pic_timing_parsed;
+ GstH264BufferingPeriod *buf_per_parsed;
+ GArray *msg_array;
+ GArray *sei_parsed = NULL;
+ GstH264SEIMessage *sei_msg_parsed;
+ gsize size;
+ guint32 size_nal;
+ guint8 sei_data[128] = { 0, };
+ guint8 sei_nal[128] = { 0, };
+
+ res = gst_h264_parser_identify_nalu (parser, nalu_sps, 0, sizeof (nalu_sps),
+ &nalu);
+ assert_equals_int (res, GST_H264_PARSER_NO_NAL_END);
+ assert_equals_int (nalu.type, GST_H264_NAL_SPS);
+ assert_equals_int (nalu.size, 43);
+ res = gst_h264_parser_parse_sps (parser, &nalu, &sps_parsed);
+ assert_equals_int (res, GST_H264_PARSER_OK);
+
+ msg_array = g_array_new (FALSE, FALSE, sizeof (GstH264SEIMessage));
+
+ sei_msg.payloadType = GST_H264_SEI_PIC_TIMING;
+ pic_timing->CpbDpbDelaysPresentFlag =
+ sps_parsed.vui_parameters.nal_hrd_parameters_present_flag;
+ pic_timing->cpb_removal_delay_length_minus1 =
+ hrd_param->cpb_removal_delay_length_minus1;
+ pic_timing->dpb_output_delay_length_minus1 =
+ hrd_param->dpb_output_delay_length_minus1;
+ pic_timing->cpb_removal_delay = 1020;
+ pic_timing->dpb_output_delay = 80;
+ pic_timing->pic_struct_present_flag = 1;
+ pic_timing->pic_struct = 2;
+
+ pic_timing->clock_timestamp_flag[0] = 1;
+ pic_timing->clock_timestamp_flag[1] = 0;
+ pic_timing->clock_timestamp_flag[2] = 0;
+
+ pic_timing->clock_timestamp[0].ct_type = GST_H264_CT_TYPE_INTERLACED;
+ pic_timing->clock_timestamp[0].nuit_field_based_flag = 1;
+ pic_timing->clock_timestamp[0].counting_type = 0;
+ pic_timing->clock_timestamp[0].discontinuity_flag = 0;
+ pic_timing->clock_timestamp[0].cnt_dropped_flag = 0;
+ pic_timing->clock_timestamp[0].n_frames = 1;
+ pic_timing->clock_timestamp[0].seconds_flag = 1;
+ pic_timing->clock_timestamp[0].seconds_value = 32;
+ pic_timing->clock_timestamp[0].minutes_flag = 1;
+ pic_timing->clock_timestamp[0].minutes_value = 52;
+ pic_timing->clock_timestamp[0].hours_flag = 1;
+ pic_timing->clock_timestamp[0].hours_value = 8;
+ pic_timing->clock_timestamp[0].full_timestamp_flag = 1;
+ pic_timing->clock_timestamp[0].time_offset = 80;
+
+ pic_timing->time_offset_length = 24;
+
+ g_array_append_val (msg_array, sei_msg);
+
+ memset (&sei_msg, 0, sizeof (sei_msg));
+
+ sei_msg.payloadType = GST_H264_SEI_BUF_PERIOD;
+
+ buf_per->sps = &sps_parsed;
+ buf_per->nal_initial_cpb_removal_delay[0] = 90021;
+ buf_per->nal_initial_cpb_removal_delay_offset[0] = 90021;
+
+ g_array_append_val (msg_array, sei_msg);
+
+ size = sizeof (sei_data);
+ ret = gst_h264_bit_writer_sei (msg_array, TRUE, sei_data, &size);
+ fail_if (ret != GST_H264_BIT_WRITER_OK);
+
+ size_nal = sizeof (sei_nal);
+ ret = gst_h264_bit_writer_convert_to_nal (4, FALSE, TRUE, FALSE,
+ sei_data, size, sei_nal, &size_nal);
+ fail_if (ret != GST_H264_BIT_WRITER_OK);
+
+ /* Parse it again. */
+ res = gst_h264_parser_identify_nalu (parser, sei_nal, 0,
+ sizeof (sei_nal), &nalu);
+ assert_equals_int (res, GST_H264_PARSER_NO_NAL_END);
+
+ res = gst_h264_parser_parse_sei (parser, &nalu, &sei_parsed);
+ assert_equals_int (res, GST_H264_PARSER_OK);
+ assert_equals_int (sei_parsed->len, 2);
+
+ sei_msg_parsed = &g_array_index (sei_parsed, GstH264SEIMessage, 0);
+ assert_equals_int (sei_msg_parsed->payloadType, GST_H264_SEI_PIC_TIMING);
+ pic_timing_parsed = &sei_msg_parsed->payload.pic_timing;
+ pic_timing =
+ &((g_array_index (msg_array, GstH264SEIMessage, 0)).payload.pic_timing);
+
+#define CHECK_FIELD(FIELD) fail_if(pic_timing_parsed->FIELD != pic_timing->FIELD)
+ CHECK_FIELD (CpbDpbDelaysPresentFlag);
+ CHECK_FIELD (cpb_removal_delay_length_minus1);
+ CHECK_FIELD (dpb_output_delay_length_minus1);
+ CHECK_FIELD (cpb_removal_delay);
+ CHECK_FIELD (dpb_output_delay);
+ CHECK_FIELD (pic_struct_present_flag);
+ CHECK_FIELD (pic_struct);
+ CHECK_FIELD (clock_timestamp_flag[0]);
+ CHECK_FIELD (clock_timestamp_flag[1]);
+ CHECK_FIELD (clock_timestamp_flag[2]);
+ CHECK_FIELD (clock_timestamp[0].ct_type);
+ CHECK_FIELD (clock_timestamp[0].nuit_field_based_flag);
+ CHECK_FIELD (clock_timestamp[0].counting_type);
+ CHECK_FIELD (clock_timestamp[0].discontinuity_flag);
+ CHECK_FIELD (clock_timestamp[0].cnt_dropped_flag);
+ CHECK_FIELD (clock_timestamp[0].n_frames);
+ CHECK_FIELD (clock_timestamp[0].seconds_flag);
+ CHECK_FIELD (clock_timestamp[0].seconds_value);
+ CHECK_FIELD (clock_timestamp[0].minutes_flag);
+ CHECK_FIELD (clock_timestamp[0].minutes_value);
+ CHECK_FIELD (clock_timestamp[0].hours_flag);
+ CHECK_FIELD (clock_timestamp[0].hours_value);
+ CHECK_FIELD (clock_timestamp[0].full_timestamp_flag);
+ CHECK_FIELD (clock_timestamp[0].time_offset);
+#undef CHECK_FIELD
+
+ sei_msg_parsed = &g_array_index (sei_parsed, GstH264SEIMessage, 1);
+ assert_equals_int (sei_msg_parsed->payloadType, GST_H264_SEI_BUF_PERIOD);
+ buf_per_parsed = &sei_msg_parsed->payload.buffering_period;
+ buf_per = &((g_array_index (msg_array, GstH264SEIMessage,
+ 1)).payload.buffering_period);
+
+ fail_if (buf_per_parsed->nal_initial_cpb_removal_delay[0] !=
+ buf_per->nal_initial_cpb_removal_delay[0]);
+ fail_if (buf_per_parsed->nal_initial_cpb_removal_delay_offset[0] !=
+ buf_per->nal_initial_cpb_removal_delay_offset[0]);
+
+ g_array_unref (sei_parsed);
+ g_array_unref (msg_array);
+ gst_h264_nal_parser_free (parser);
+}
+
+GST_END_TEST;
+
+static Suite *
+h264bitwriter_suite (void)
+{
+ Suite *s = suite_create ("H264 Parser library");
+
+ TCase *tc_chain = tcase_create ("general");
+
+ suite_add_tcase (s, tc_chain);
+ tcase_add_test (tc_chain, test_h264_bitwriter_sps_pps_slice_hdr);
+ tcase_add_test (tc_chain, test_h264_bitwriter_sei);
+
+ return s;
+}
+
+GST_CHECK_MAIN (h264bitwriter);
projects / platform / upstream / gstreamer.git / commitdiff