diff --git a/subprojects/gst-plugins-bad/tests/check/libs/av1bitwriter.c b/subprojects/gst-plugins-bad/tests/check/libs/av1bitwriter.c new file mode 100644 index 0000000000..ddabad4c66 --- /dev/null +++ b/subprojects/gst-plugins-bad/tests/check/libs/av1bitwriter.c @@ -0,0 +1,662 @@ +/* GStreamer + * Copyright (C) 2022 Intel Corporation + * Author: He Junyan + * + * 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 +#include + +/* *INDENT-OFF* */ +static const GstAV1SequenceHeaderOBU sequence = { + .seq_profile = 0, + .still_picture = 0, + .num_planes = 3, + .reduced_still_picture_header = 0, + .timing_info_present_flag = 1, + .timing_info = { + .num_units_in_display_tick = 127, + .time_scale = 10, + .equal_picture_interval = 1, + .num_ticks_per_picture_minus_1 = 1082, + }, + .decoder_model_info_present_flag = 0, + .initial_display_delay_present_flag = 0, + .operating_points_cnt_minus_1 = 3, + .operating_points = { + { + .seq_level_idx = 1, + .seq_tier = 0, + .idc = 771, + }, + { + .seq_level_idx = 1, + .seq_tier = 0, + .idc = 769, + }, + { + .seq_level_idx = 1, + .seq_tier = 0, + .idc = 259, + }, + { + .seq_level_idx = 1, + .seq_tier = 0, + .idc = 257, + }, + }, + + .frame_width_bits_minus_1 = 10, + .frame_height_bits_minus_1 = 9, + .max_frame_width_minus_1 = 1279, + .max_frame_height_minus_1 = 719, + + .frame_id_numbers_present_flag = 0, + .use_128x128_superblock = 1, + .enable_filter_intra = 1, + .enable_intra_edge_filter = 1, + .enable_interintra_compound = 1, + .enable_masked_compound = 1, + .enable_warped_motion = 1, + .enable_dual_filter = 1, + .enable_order_hint = 1, + .enable_jnt_comp = 1, + .enable_ref_frame_mvs = 1, + .seq_choose_screen_content_tools = 1, + .seq_force_screen_content_tools = GST_AV1_SELECT_SCREEN_CONTENT_TOOLS, + .seq_choose_integer_mv = 1, + .order_hint_bits_minus_1 = 6, + .enable_superres = 0, + .enable_cdef = 1, + .enable_restoration = 1, + + .color_config = { + .high_bitdepth = 0, + .mono_chrome = 0, + .color_description_present_flag = 1, + .color_primaries = 1, + .transfer_characteristics = 1, + .matrix_coefficients = 1, + .color_range = 0, + .subsampling_x = 1, + .subsampling_y = 1, + .chroma_sample_position = 0, + .separate_uv_delta_q = 0, + }, + + .film_grain_params_present = 0, +}; + +static const GstAV1FrameHeaderOBU key_frame = { + /* default setting */ + .frame_is_intra = 1, + .last_frame_idx = -1, + .gold_frame_idx = -1, + .ref_frame_idx = { -1, -1, -1, -1, -1, -1, -1 }, + + .show_existing_frame = 0, + .frame_type = 0, + .show_frame = 1, + .disable_cdf_update = 0, + .allow_screen_content_tools = 0, + .frame_size_override_flag = 1, + .order_hint = 0, + .primary_ref_frame = 7, + .frame_width = 640, + .frame_height = 360, + .use_superres = 0, + .render_and_frame_size_different = 0, + .disable_frame_end_update_cdf = 1, + .tile_info = { + .uniform_tile_spacing_flag = 1, + .tile_cols_log2 = 2, + .tile_rows_log2 = 0, + .context_update_tile_id = 1, + .tile_size_bytes_minus_1 = 3, + }, + .quantization_params = { + .base_q_idx = 19, + .delta_q_y_dc = 2, + .delta_q_u_dc = 3, + .delta_q_u_ac = -5, + .using_qmatrix = 0, + + .delta_q_present = 0, + }, + .segmentation_params = { + .segmentation_enabled = 0, + }, + .loop_filter_params = { + .loop_filter_level = { 0, 0, }, + .loop_filter_sharpness = 1, + .loop_filter_delta_enabled = 1, + .loop_filter_delta_update = 1, + .loop_filter_ref_deltas = { 1, 2, 0, 0, -1, 0, -1, -1 }, + .loop_filter_mode_deltas = { 0, 0 }, + }, + .cdef_params = { + .cdef_damping = 3, + .cdef_bits = 3, + .cdef_y_pri_strength = { 0, 0, 2, 0, 0, 0, 0, 0, }, + .cdef_y_sec_strength = { 0, 1, 0, 1, 1, 1, 3, 0, }, + .cdef_uv_pri_strength = { 0, 0, 2, 1, 0, 0, 0, 0, }, + .cdef_uv_sec_strength = { 1, 1, 0, 0, 0, 3, 0, 3, }, + }, + .loop_restoration_params = { + .uses_lr = 1, + .frame_restoration_type[0] = GST_AV1_FRAME_RESTORE_SWITCHABLE, + .frame_restoration_type[1] = GST_AV1_FRAME_RESTORE_SGRPROJ, + .frame_restoration_type[2] = GST_AV1_FRAME_RESTORE_SGRPROJ, + .lr_unit_shift = 1, + .lr_uv_shift = 0, + }, + .tx_mode = GST_AV1_TX_MODE_SELECT, + .reduced_tx_set = 0, +}; + +static const GstAV1FrameHeaderOBU inter_frame = { + /* default setting */ + .frame_is_intra = 0, + + .show_existing_frame = 0, + .frame_type = 1, + .show_frame = 1, + .error_resilient_mode = 0, + .disable_cdf_update = 0, + .allow_screen_content_tools = 0, + .frame_size_override_flag = 0, + .frame_width = 1280, + .frame_height = 720, + .order_hint = 1, + .primary_ref_frame = 7, + .refresh_frame_flags = 0x08, + .frame_refs_short_signaling = 0, + .ref_frame_idx = { 0, 1, 2, 3, 4, 5, 6 }, + .render_and_frame_size_different = 0, + .allow_high_precision_mv = 1, + .is_filter_switchable = 1, + .is_motion_mode_switchable = 1, + .use_ref_frame_mvs = 1, + .disable_frame_end_update_cdf = 1, + .tile_info = { + .uniform_tile_spacing_flag = 1, + .tile_cols_log2 = 2, + .tile_rows_log2 = 0, + .context_update_tile_id = 1, + .tile_size_bytes_minus_1 = 3, + }, + .quantization_params = { + .base_q_idx = 61, + .delta_q_y_dc = -2, + .delta_q_u_dc = -1, + .delta_q_u_ac = 2, + .using_qmatrix = 0, + + .delta_q_present = 0, + }, + .segmentation_params = { + .segmentation_enabled = 0, + }, + .loop_filter_params = { + .loop_filter_level = { 0, 0, }, + .loop_filter_sharpness = 0, + .loop_filter_delta_enabled = 0, + }, + .cdef_params = { + .cdef_damping = 3, + .cdef_bits = 3, + .cdef_y_pri_strength = { 0, 3, 0, 7, 1, 2, 0, 1, }, + .cdef_y_sec_strength = { 3, 1, 1, 1, 2, 0, 0, 1, }, + .cdef_uv_pri_strength = { 2, 7, 0, 0, 0, 7, 7, 3, }, + .cdef_uv_sec_strength = { 0, 0, 2, 3, 1, 0, 0, 0, }, + }, + .loop_restoration_params = { + .uses_lr = 1, + .frame_restoration_type[0] = GST_AV1_FRAME_RESTORE_WIENER, + .frame_restoration_type[1] = GST_AV1_FRAME_RESTORE_SWITCHABLE, + .frame_restoration_type[2] = GST_AV1_FRAME_RESTORE_WIENER, + .lr_unit_shift = 1, + .lr_uv_shift = 0, + }, + .tx_mode = GST_AV1_TX_MODE_SELECT, + .reference_select = 0, + .allow_warped_motion = 1, + .reduced_tx_set = 0, + .global_motion_params = { + .gm_type = { + GST_AV1_WARP_MODEL_IDENTITY, + GST_AV1_WARP_MODEL_IDENTITY, + GST_AV1_WARP_MODEL_IDENTITY, + GST_AV1_WARP_MODEL_IDENTITY, + GST_AV1_WARP_MODEL_IDENTITY, + GST_AV1_WARP_MODEL_IDENTITY, + GST_AV1_WARP_MODEL_IDENTITY, + GST_AV1_WARP_MODEL_IDENTITY + }, + }, +}; + +static const GstAV1FrameHeaderOBU show_existing_frame = { + .show_existing_frame = 1, + .frame_to_show_map_idx = 3, +}; + +static const GstAV1MetadataOBU hdr_mdcv = { + .metadata_type = GST_AV1_METADATA_TYPE_HDR_MDCV, + .hdr_mdcv = { + .primary_chromaticity_x = { 6554, 19661, 32768 }, + .primary_chromaticity_y = { 13107, 26214, 39322 }, + .white_point_chromaticity_x = 45875, + .white_point_chromaticity_y = 52429, + .luminance_max = 512, + .luminance_min = 16384, + } +}; + +static const GstAV1MetadataOBU hdr_cll = { + .metadata_type = GST_AV1_METADATA_TYPE_HDR_CLL, + .hdr_cll = { + .max_cll = 11122, + .max_fall = 22211, + } +}; +/* *INDENT-ON* */ + +GST_START_TEST (test_av1_bitwriter_sequence_and_frame_hdr) +{ + GstAV1ParserResult res; + gboolean ret; + guint size; + guint i; + GstAV1Parser *const parser = gst_av1_parser_new (); + GstAV1OBU obu; + guint32 consumed; + GstAV1SequenceHeaderOBU seq_header = { 0, }; + GstAV1FrameHeaderOBU frame_header = { 0, }; + guint8 sequence_obu[128] = { 0, }; + guint8 frame_header_obu[256] = { 0, }; + guint8 td_obu[16] = { 0, }; + + size = sizeof (sequence_obu); + ret = gst_av1_bit_writer_sequence_header_obu (&sequence, TRUE, + sequence_obu, &size); + fail_if (ret != GST_AV1_BIT_WRITER_OK); + + /* Parse it again */ + res = gst_av1_parser_identify_one_obu (parser, + sequence_obu, size, &obu, &consumed); + assert_equals_int (res, GST_AV1_PARSER_OK); + assert_equals_int (obu.obu_type, GST_AV1_OBU_SEQUENCE_HEADER); + + res = gst_av1_parser_parse_sequence_header_obu (parser, &obu, &seq_header); + assert_equals_int (res, GST_AV1_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(seq_header.FIELD != sequence.FIELD) + CHECK_FIELD (seq_profile); + CHECK_FIELD (still_picture); + CHECK_FIELD (reduced_still_picture_header); + CHECK_FIELD (frame_width_bits_minus_1); + CHECK_FIELD (frame_height_bits_minus_1); + CHECK_FIELD (max_frame_width_minus_1); + CHECK_FIELD (max_frame_height_minus_1); + CHECK_FIELD (frame_id_numbers_present_flag); + CHECK_FIELD (delta_frame_id_length_minus_2); + CHECK_FIELD (additional_frame_id_length_minus_1); + CHECK_FIELD (use_128x128_superblock); + CHECK_FIELD (enable_filter_intra); + CHECK_FIELD (enable_intra_edge_filter); + CHECK_FIELD (enable_interintra_compound); + CHECK_FIELD (enable_masked_compound); + CHECK_FIELD (enable_warped_motion); + CHECK_FIELD (enable_order_hint); + CHECK_FIELD (enable_dual_filter); + CHECK_FIELD (enable_jnt_comp); + CHECK_FIELD (enable_ref_frame_mvs); + CHECK_FIELD (seq_choose_screen_content_tools); + CHECK_FIELD (seq_force_screen_content_tools); + CHECK_FIELD (seq_choose_integer_mv); + CHECK_FIELD (order_hint_bits_minus_1); + CHECK_FIELD (enable_superres); + CHECK_FIELD (enable_cdef); + CHECK_FIELD (enable_restoration); + CHECK_FIELD (film_grain_params_present); + + CHECK_FIELD (operating_points_cnt_minus_1); + for (i = 0; i < 4; i++) { + CHECK_FIELD (operating_points[i].seq_level_idx); + CHECK_FIELD (operating_points[i].seq_tier); + CHECK_FIELD (operating_points[i].idc); + } + + CHECK_FIELD (decoder_model_info_present_flag); + CHECK_FIELD (initial_display_delay_present_flag); + + CHECK_FIELD (timing_info_present_flag); + CHECK_FIELD (timing_info.num_units_in_display_tick); + CHECK_FIELD (timing_info.time_scale); + CHECK_FIELD (timing_info.equal_picture_interval); + CHECK_FIELD (timing_info.num_ticks_per_picture_minus_1); +#undef CHECK_FIELD + + size = sizeof (frame_header_obu); + ret = gst_av1_bit_writer_frame_header_obu (&key_frame, &sequence, 0, 0, TRUE, + frame_header_obu, &size); + fail_if (ret != GST_AV1_BIT_WRITER_OK); + + /* Parse it again */ + res = gst_av1_parser_identify_one_obu (parser, + frame_header_obu, size, &obu, &consumed); + assert_equals_int (res, GST_AV1_PARSER_OK); + assert_equals_int (obu.obu_type, GST_AV1_OBU_FRAME_HEADER); + + res = gst_av1_parser_parse_frame_header_obu (parser, &obu, &frame_header); + assert_equals_int (res, GST_AV1_PARSER_OK); + +#define CHECK_FIELD(FIELD) fail_if(frame_header.FIELD != key_frame.FIELD) + CHECK_FIELD (show_existing_frame); + CHECK_FIELD (frame_type); + CHECK_FIELD (show_frame); + CHECK_FIELD (disable_cdf_update); + CHECK_FIELD (allow_screen_content_tools); + CHECK_FIELD (frame_size_override_flag); + CHECK_FIELD (order_hint); + CHECK_FIELD (frame_width); + CHECK_FIELD (frame_height); + CHECK_FIELD (use_superres); + CHECK_FIELD (render_and_frame_size_different); + CHECK_FIELD (disable_frame_end_update_cdf); + + CHECK_FIELD (tile_info.uniform_tile_spacing_flag); + CHECK_FIELD (tile_info.tile_cols_log2); + CHECK_FIELD (tile_info.tile_rows_log2); + CHECK_FIELD (tile_info.context_update_tile_id); + CHECK_FIELD (tile_info.tile_size_bytes_minus_1); + + CHECK_FIELD (quantization_params.base_q_idx); + CHECK_FIELD (quantization_params.delta_q_y_dc); + CHECK_FIELD (quantization_params.delta_q_u_dc); + CHECK_FIELD (quantization_params.delta_q_u_ac); + CHECK_FIELD (quantization_params.using_qmatrix); + CHECK_FIELD (quantization_params.delta_q_present); + + CHECK_FIELD (segmentation_params.segmentation_enabled); + + for (i = 0; i < 2; i++) + CHECK_FIELD (loop_filter_params.loop_filter_level[i]); + CHECK_FIELD (loop_filter_params.loop_filter_sharpness); + CHECK_FIELD (loop_filter_params.loop_filter_delta_enabled); + CHECK_FIELD (loop_filter_params.loop_filter_delta_update); + for (i = 0; i < 8; i++) + CHECK_FIELD (loop_filter_params.loop_filter_ref_deltas[i]); + + CHECK_FIELD (cdef_params.cdef_damping); + CHECK_FIELD (cdef_params.cdef_bits); + for (i = 0; i < 8; i++) + CHECK_FIELD (cdef_params.cdef_y_pri_strength[i]); + for (i = 0; i < 8; i++) { + if (frame_header.cdef_params.cdef_y_sec_strength[i] == 4) + frame_header.cdef_params.cdef_y_sec_strength[i]--; + CHECK_FIELD (cdef_params.cdef_y_sec_strength[i]); + } + for (i = 0; i < 8; i++) + CHECK_FIELD (cdef_params.cdef_uv_pri_strength[i]); + for (i = 0; i < 8; i++) { + if (frame_header.cdef_params.cdef_uv_sec_strength[i] == 4) + frame_header.cdef_params.cdef_uv_sec_strength[i]--; + CHECK_FIELD (cdef_params.cdef_uv_sec_strength[i]); + } + + CHECK_FIELD (loop_restoration_params.uses_lr); + for (i = 0; i < 3; i++) + CHECK_FIELD (loop_restoration_params.frame_restoration_type[i]); + CHECK_FIELD (loop_restoration_params.lr_unit_shift); + CHECK_FIELD (loop_restoration_params.lr_uv_shift); + + CHECK_FIELD (tx_mode); + CHECK_FIELD (reduced_tx_set); +#undef CHECK_FIELD + + /* Append a TD */ + size = sizeof (td_obu); + ret = gst_av1_bit_writer_temporal_delimiter_obu (TRUE, td_obu, &size); + fail_if (ret != GST_AV1_BIT_WRITER_OK); + + /* Parse it again */ + res = gst_av1_parser_identify_one_obu (parser, td_obu, size, &obu, &consumed); + assert_equals_int (res, GST_AV1_PARSER_OK); + assert_equals_int (obu.obu_type, GST_AV1_OBU_TEMPORAL_DELIMITER); + + res = gst_av1_parser_parse_temporal_delimiter_obu (parser, &obu); + assert_equals_int (res, GST_AV1_PARSER_OK); + + ret = gst_av1_parser_reference_frame_update (parser, &frame_header); + assert_equals_int (res, GST_AV1_PARSER_OK); + + /* Inter frame */ + size = sizeof (frame_header_obu); + memset (frame_header_obu, 0, size); + + ret = gst_av1_bit_writer_frame_header_obu (&inter_frame, &sequence, 1, 0, + TRUE, frame_header_obu, &size); + fail_if (ret != GST_AV1_BIT_WRITER_OK); + + /* Parse it again */ + res = gst_av1_parser_identify_one_obu (parser, + frame_header_obu, size, &obu, &consumed); + assert_equals_int (res, GST_AV1_PARSER_OK); + assert_equals_int (obu.obu_type, GST_AV1_OBU_FRAME_HEADER); + + res = gst_av1_parser_parse_frame_header_obu (parser, &obu, &frame_header); + assert_equals_int (res, GST_AV1_PARSER_OK); + +#define CHECK_FIELD(FIELD) fail_if(frame_header.FIELD != inter_frame.FIELD) + CHECK_FIELD (show_existing_frame); + CHECK_FIELD (frame_type); + CHECK_FIELD (show_frame); + CHECK_FIELD (error_resilient_mode); + CHECK_FIELD (disable_cdf_update); + CHECK_FIELD (allow_screen_content_tools); + CHECK_FIELD (frame_size_override_flag); + CHECK_FIELD (order_hint); + CHECK_FIELD (primary_ref_frame); + CHECK_FIELD (refresh_frame_flags); + CHECK_FIELD (frame_refs_short_signaling); + for (i = 0; i < 7; i++) + CHECK_FIELD (ref_frame_idx[i]); + CHECK_FIELD (render_and_frame_size_different); + CHECK_FIELD (allow_high_precision_mv); + CHECK_FIELD (is_filter_switchable); + CHECK_FIELD (is_motion_mode_switchable); + CHECK_FIELD (use_ref_frame_mvs); + CHECK_FIELD (disable_frame_end_update_cdf); + + CHECK_FIELD (tile_info.uniform_tile_spacing_flag); + CHECK_FIELD (tile_info.tile_cols_log2); + CHECK_FIELD (tile_info.tile_rows_log2); + CHECK_FIELD (tile_info.context_update_tile_id); + CHECK_FIELD (tile_info.tile_size_bytes_minus_1); + + CHECK_FIELD (quantization_params.base_q_idx); + CHECK_FIELD (quantization_params.delta_q_y_dc); + CHECK_FIELD (quantization_params.delta_q_u_dc); + CHECK_FIELD (quantization_params.delta_q_u_ac); + CHECK_FIELD (quantization_params.using_qmatrix); + CHECK_FIELD (quantization_params.delta_q_present); + + CHECK_FIELD (segmentation_params.segmentation_enabled); + + for (i = 0; i < 2; i++) + CHECK_FIELD (loop_filter_params.loop_filter_level[i]); + CHECK_FIELD (loop_filter_params.loop_filter_sharpness); + CHECK_FIELD (loop_filter_params.loop_filter_delta_enabled); + + CHECK_FIELD (cdef_params.cdef_damping); + CHECK_FIELD (cdef_params.cdef_bits); + for (i = 0; i < 8; i++) + CHECK_FIELD (cdef_params.cdef_y_pri_strength[i]); + for (i = 0; i < 8; i++) { + if (frame_header.cdef_params.cdef_y_sec_strength[i] == 4) + frame_header.cdef_params.cdef_y_sec_strength[i]--; + CHECK_FIELD (cdef_params.cdef_y_sec_strength[i]); + } + for (i = 0; i < 8; i++) + CHECK_FIELD (cdef_params.cdef_uv_pri_strength[i]); + for (i = 0; i < 8; i++) { + if (frame_header.cdef_params.cdef_uv_sec_strength[i] == 4) + frame_header.cdef_params.cdef_uv_sec_strength[i]--; + CHECK_FIELD (cdef_params.cdef_uv_sec_strength[i]); + } + + CHECK_FIELD (loop_restoration_params.uses_lr); + for (i = 0; i < 3; i++) + CHECK_FIELD (loop_restoration_params.frame_restoration_type[i]); + CHECK_FIELD (loop_restoration_params.lr_unit_shift); + CHECK_FIELD (loop_restoration_params.lr_uv_shift); + + CHECK_FIELD (tx_mode); + CHECK_FIELD (reference_select); + CHECK_FIELD (allow_warped_motion); + CHECK_FIELD (reduced_tx_set); + + for (i = 0; i < 8; i++) + CHECK_FIELD (global_motion_params.gm_type[i]); +#undef CHECK_FIELD + + ret = gst_av1_parser_reference_frame_update (parser, &frame_header); + assert_equals_int (res, GST_AV1_PARSER_OK); + + /* Append a TD */ + size = sizeof (td_obu); + ret = gst_av1_bit_writer_temporal_delimiter_obu (TRUE, td_obu, &size); + fail_if (ret != GST_AV1_BIT_WRITER_OK); + + res = gst_av1_parser_identify_one_obu (parser, td_obu, size, &obu, &consumed); + assert_equals_int (res, GST_AV1_PARSER_OK); + assert_equals_int (obu.obu_type, GST_AV1_OBU_TEMPORAL_DELIMITER); + + res = gst_av1_parser_parse_temporal_delimiter_obu (parser, &obu); + assert_equals_int (res, GST_AV1_PARSER_OK); + + /* Show existing frame */ + size = sizeof (frame_header_obu); + memset (frame_header_obu, 0, size); + + ret = gst_av1_bit_writer_frame_header_obu (&show_existing_frame, &sequence, 1, + 0, TRUE, frame_header_obu, &size); + fail_if (ret != GST_AV1_BIT_WRITER_OK); + + /* Parse it again */ + res = gst_av1_parser_identify_one_obu (parser, + frame_header_obu, size, &obu, &consumed); + assert_equals_int (res, GST_AV1_PARSER_OK); + assert_equals_int (obu.obu_type, GST_AV1_OBU_FRAME_HEADER); + + res = gst_av1_parser_parse_frame_header_obu (parser, &obu, &frame_header); + assert_equals_int (res, GST_AV1_PARSER_OK); + + fail_if (frame_header.show_existing_frame != + show_existing_frame.show_existing_frame); + fail_if (frame_header.frame_to_show_map_idx != + show_existing_frame.frame_to_show_map_idx); + + gst_av1_parser_free (parser); +} + +GST_END_TEST; + +GST_START_TEST (test_av1_bitwriter_metadata) +{ + GstAV1ParserResult res; + gboolean ret; + guint size; + guint i; + GstAV1Parser *const parser = gst_av1_parser_new (); + GstAV1OBU obu; + guint32 consumed; + GstAV1MetadataOBU metadata = { 0, }; + guint8 meta_obu[128] = { 0, }; + + size = sizeof (meta_obu); + + ret = gst_av1_bit_writer_metadata_obu (&hdr_mdcv, 0, 0, + TRUE, meta_obu, &size); + fail_if (ret != GST_AV1_BIT_WRITER_OK); + + /* Parse it again */ + res = gst_av1_parser_identify_one_obu (parser, + meta_obu, size, &obu, &consumed); + assert_equals_int (res, GST_AV1_PARSER_OK); + assert_equals_int (obu.obu_type, GST_AV1_OBU_METADATA); + + res = gst_av1_parser_parse_metadata_obu (parser, &obu, &metadata); + assert_equals_int (res, GST_AV1_PARSER_OK); + +#define CHECK_FIELD(FIELD) fail_if(metadata.hdr_mdcv.FIELD != hdr_mdcv.hdr_mdcv.FIELD) + fail_if (metadata.metadata_type != hdr_mdcv.metadata_type); + for (i = 0; i < 3; i++) { + CHECK_FIELD (primary_chromaticity_x[i]); + CHECK_FIELD (primary_chromaticity_y[i]); + } + CHECK_FIELD (white_point_chromaticity_x); + CHECK_FIELD (white_point_chromaticity_y); + CHECK_FIELD (luminance_max); + CHECK_FIELD (luminance_min); +#undef CHECK_FIELD + + size = sizeof (meta_obu); + memset (meta_obu, 0, size); + + ret = gst_av1_bit_writer_metadata_obu (&hdr_cll, 0, 0, TRUE, meta_obu, &size); + fail_if (ret != GST_AV1_BIT_WRITER_OK); + + /* Parse it again */ + res = gst_av1_parser_identify_one_obu (parser, + meta_obu, size, &obu, &consumed); + assert_equals_int (res, GST_AV1_PARSER_OK); + assert_equals_int (obu.obu_type, GST_AV1_OBU_METADATA); + + res = gst_av1_parser_parse_metadata_obu (parser, &obu, &metadata); + assert_equals_int (res, GST_AV1_PARSER_OK); + + fail_if (metadata.metadata_type != hdr_cll.metadata_type); + fail_if (metadata.hdr_cll.max_cll != hdr_cll.hdr_cll.max_cll); + fail_if (metadata.hdr_cll.max_fall != hdr_cll.hdr_cll.max_fall); + + gst_av1_parser_free (parser); +} + +GST_END_TEST; + +static Suite * +av1bitwriter_suite (void) +{ + Suite *s = suite_create ("av1 bitwriter library"); + + TCase *tc_chain = tcase_create ("general"); + + suite_add_tcase (s, tc_chain); + + tcase_add_test (tc_chain, test_av1_bitwriter_sequence_and_frame_hdr); + + tcase_add_test (tc_chain, test_av1_bitwriter_metadata); + + return s; +} + +GST_CHECK_MAIN (av1bitwriter); diff --git a/subprojects/gst-plugins-bad/tests/check/meson.build b/subprojects/gst-plugins-bad/tests/check/meson.build index de602acaba..705bef689a 100644 --- a/subprojects/gst-plugins-bad/tests/check/meson.build +++ b/subprojects/gst-plugins-bad/tests/check/meson.build @@ -95,6 +95,7 @@ base_tests = [ [['libs/h264bitwriter.c'], false, [gstcodecparsers_dep]], [['libs/h265bitwriter.c'], false, [gstcodecparsers_dep]], [['libs/vkformat.c'], not gstvulkan_dep.found(), [gstvulkan_dep]], + [['libs/av1bitwriter.c'], false, [gstcodecparsers_dep]], [['libs/vkmemory.c'], not gstvulkan_dep.found(), [gstvulkan_dep]], [['libs/analyticsmeta.c'], false, [gstanalytics_dep]], [['elements/vkcolorconvert.c'], not gstvulkan_dep.found(), [gstvulkan_dep]],