| /* |
| * Copyright (c) 2025, Alliance for Open Media. All rights reserved |
| * |
| * This source code is subject to the terms of the BSD 3-Clause Clear License |
| * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear |
| * License was not distributed with this source code in the LICENSE file, you |
| * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. If the |
| * Alliance for Open Media Patent License 1.0 was not distributed with this |
| * source code in the PATENTS file, you can obtain it at |
| * aomedia.org/license/patent-license/. |
| */ |
| |
| #include <assert.h> |
| |
| #include "config/aom_config.h" |
| #include "aom_dsp/bitreader_buffer.h" |
| #include "av1/common/common.h" |
| #include "av1/common/obu_util.h" |
| #include "av1/common/timing.h" |
| #include "av1/decoder/decoder.h" |
| #include "av1/decoder/decodeframe.h" |
| #include "av1/decoder/obu.h" |
| #include "av1/common/enums.h" |
| |
| // TODO(hegilmez) to be specified, depending on profile, tier definitions |
| static int read_lcr_profile_tier_level(int isGlobal, int xId) { |
| #if CONFIG_MULTILAYER_HLS_REMOVE_LOGS |
| (void)isGlobal; |
| (void)xId; |
| #else |
| printf( |
| "read_lcr_profile_tier_level(isGlobal=%d,xId=%d): profile, tier, level " |
| "are not defined yet\n", |
| isGlobal, xId); |
| #endif // CONFIG_MULTILAYER_HLS_REMOVE_LOGS |
| return 0; |
| } |
| |
| static int read_lcr_xlayer_color_info(struct AV1Decoder *pbi, int isGlobal, |
| int xId, struct aom_read_bit_buffer *rb) { |
| struct XLayerColorInfo *xlayer = &pbi->common.lcr_params.xlayer_col_params; |
| // layer_color_description_idc: indicates the combination of color primaries, |
| // transfer characteristics and matrix coefficients as defined in CWG-F270. |
| // The value of color_description_idc shall be in the range of 0 to 15, |
| // inclusive. Values larger than 4 are reserved for future use by AOMedia and |
| // should be ignored by decoders conforming to this version of this |
| // specification. |
| // TODO(hegilmez): align with the CI OBU definitions in CWG-F270 after |
| // integrated. |
| xlayer->layer_color_description_idc[isGlobal][xId] = aom_rb_read_uvlc(rb); |
| if (xlayer->layer_color_description_idc[isGlobal][xId] == 0) { |
| xlayer->layer_color_primaries[isGlobal][xId] = aom_rb_read_literal(rb, 8); |
| xlayer->layer_matrix_coefficients[isGlobal][xId] = |
| aom_rb_read_literal(rb, 8); |
| xlayer->layer_transfer_characteristics[isGlobal][xId] = |
| aom_rb_read_literal(rb, 8); |
| } |
| xlayer->layer_full_range_flag[isGlobal][xId] = aom_rb_read_bit(rb); |
| |
| return 0; |
| } |
| |
| static int read_lcr_embedded_layer_info(struct AV1Decoder *pbi, int isGlobal, |
| int xId, |
| struct aom_read_bit_buffer *rb) { |
| struct LayerConfigurationRecord *lcr_params = &pbi->common.lcr_params; |
| struct EmbeddedLayerInfo *mlayer_params = &lcr_params->mlayer_params; |
| |
| mlayer_params->MLayerCount[isGlobal][xId] = 0; |
| |
| mlayer_params->lcr_mlayer_map[isGlobal][xId] = |
| aom_rb_read_literal(rb, MAX_NUM_MLAYERS); |
| |
| for (int j = 0; j < MAX_NUM_MLAYERS; j++) { |
| if ((mlayer_params->lcr_mlayer_map[isGlobal][xId] & (1 << j))) { |
| mlayer_params->LcrMlayerID[isGlobal][xId] |
| [mlayer_params->MLayerCount[isGlobal][xId]] = j; |
| |
| mlayer_params->lcr_tlayer_map[isGlobal][xId][j] = |
| aom_rb_read_literal(rb, MAX_NUM_TLAYERS); |
| |
| mlayer_params->TLayerCount[isGlobal][xId][j] = 0; |
| for (int k = 0; k < MAX_NUM_TLAYERS; k++) { |
| if ((mlayer_params->lcr_tlayer_map[isGlobal][xId][j] & (1 << k))) { |
| mlayer_params |
| ->LcrTlayerID[isGlobal][xId] |
| [mlayer_params->TLayerCount[isGlobal][xId][j]] = k; |
| mlayer_params->TLayerCount[isGlobal][xId][j]++; |
| } |
| } |
| int atlasSegmentPresent = |
| (isGlobal && lcr_params->lcr_global_atlas_id_present_flag) || |
| lcr_params->lcr_local_atlas_id_present_flag[xId]; |
| |
| if (atlasSegmentPresent) { |
| mlayer_params->lcr_layer_atlas_segment_id[isGlobal][xId][j] = |
| aom_rb_read_literal(rb, 8); |
| |
| mlayer_params->lcr_priority_order[isGlobal][xId][j] = |
| aom_rb_read_literal(rb, 8); |
| |
| mlayer_params->lcr_rendering_method[isGlobal][xId][j] = |
| aom_rb_read_literal(rb, 8); |
| } |
| mlayer_params->lcr_layer_type[isGlobal][xId][j] = |
| aom_rb_read_literal(rb, 8); |
| |
| if (mlayer_params->lcr_layer_type[isGlobal][xId][j] == AUX_LAYER) |
| mlayer_params->lcr_auxiliary_type[isGlobal][xId][j] = |
| aom_rb_read_literal(rb, 8); |
| |
| mlayer_params->lcr_view_type[isGlobal][xId][j] = |
| aom_rb_read_literal(rb, 8); |
| |
| if (mlayer_params->lcr_view_type[isGlobal][xId][j] == VIEW_EXPLICIT) |
| mlayer_params->lcr_view_id[isGlobal][xId][j] = |
| aom_rb_read_literal(rb, 8); |
| |
| if (j > 0) |
| mlayer_params->lcr_dependent_layer_map[isGlobal][xId][j] = |
| aom_rb_read_literal(rb, j); |
| |
| // Resolution and cropping info. |
| // If the information is the same as what is in the SCR, then no need to |
| // signal |
| struct CroppingWindow *crop_params = |
| &lcr_params->crop_win_list[isGlobal][xId]; |
| |
| crop_params->crop_info_in_scr_flag = aom_rb_read_bit(rb); |
| if (!crop_params->crop_info_in_scr_flag) { |
| crop_params->crop_max_width = aom_rb_read_uvlc(rb); |
| crop_params->crop_max_height = aom_rb_read_uvlc(rb); |
| } |
| // byte alignment |
| if (av1_check_byte_alignment(&pbi->common, rb) != 0) { |
| aom_internal_error( |
| &pbi->common.error, AOM_CODEC_CORRUPT_FRAME, |
| "Byte alignment error in read_lcr_embedded_layer_info()"); |
| } |
| mlayer_params->MLayerCount[isGlobal][xId]++; |
| } |
| } |
| return 0; |
| } |
| |
| static int read_lcr_rep_info(struct LayerConfigurationRecord *lcr_params, |
| int isGlobal, int xId, |
| struct aom_read_bit_buffer *rb) { |
| struct RepresentationInfo *rep_params = &lcr_params->rep_list[isGlobal][xId]; |
| struct CroppingWindow *crop_win = &lcr_params->crop_win_list[isGlobal][xId]; |
| |
| rep_params->lcr_max_pic_width = aom_rb_read_uvlc(rb); |
| rep_params->lcr_max_pic_height = aom_rb_read_uvlc(rb); |
| rep_params->lcr_format_info_present_flag = aom_rb_read_bit(rb); |
| |
| crop_win->crop_window_present_flag = aom_rb_read_bit(rb); |
| if (rep_params->lcr_format_info_present_flag) { |
| rep_params->lcr_bit_depth_idc = aom_rb_read_uvlc(rb); |
| rep_params->lcr_chroma_format_idc = aom_rb_read_uvlc(rb); |
| } |
| if (crop_win->crop_window_present_flag) { |
| crop_win->crop_win_left_offset = aom_rb_read_uvlc(rb); |
| crop_win->crop_win_right_offset = aom_rb_read_uvlc(rb); |
| crop_win->crop_win_top_offset = aom_rb_read_uvlc(rb); |
| crop_win->crop_win_bottom_offset = aom_rb_read_uvlc(rb); |
| } |
| return 0; |
| } |
| |
| static int read_lcr_xlayer_info(struct AV1Decoder *pbi, int isGlobal, int xId, |
| struct aom_read_bit_buffer *rb) { |
| struct LayerConfigurationRecord *lcr_params = &pbi->common.lcr_params; |
| |
| lcr_params->lcr_rep_info_present_flag[isGlobal][xId] = aom_rb_read_bit(rb); |
| lcr_params->lcr_xlayer_purpose_present_flag[isGlobal][xId] = |
| aom_rb_read_bit(rb); |
| lcr_params->lcr_xlayer_color_info_present_flag[isGlobal][xId] = |
| aom_rb_read_bit(rb); |
| lcr_params->lcr_embedded_layer_info_present_flag[isGlobal][xId] = |
| aom_rb_read_bit(rb); |
| |
| read_lcr_profile_tier_level(isGlobal, xId); |
| |
| if (lcr_params->lcr_rep_info_present_flag[isGlobal][xId]) |
| read_lcr_rep_info(lcr_params, isGlobal, xId, rb); |
| |
| if (lcr_params->lcr_xlayer_purpose_present_flag[isGlobal][xId]) |
| lcr_params->lcr_xlayer_purpose_id[isGlobal][xId] = |
| aom_rb_read_literal(rb, 7); |
| |
| if (lcr_params->lcr_xlayer_color_info_present_flag[isGlobal][xId]) |
| read_lcr_xlayer_color_info(pbi, isGlobal, xId, rb); |
| |
| // byte alignment |
| if (av1_check_byte_alignment(&pbi->common, rb) != 0) { |
| aom_internal_error(&pbi->common.error, AOM_CODEC_CORRUPT_FRAME, |
| "Byte alignment error in read_lcr_xlayer_info()"); |
| } |
| |
| // Add embedded layer information if desired |
| if (lcr_params->lcr_embedded_layer_info_present_flag[isGlobal][xId]) |
| read_lcr_embedded_layer_info(pbi, isGlobal, xId, rb); |
| else { |
| // If no embedded layer info present and if extended layer 31 |
| // then we may wish to have atlas mapping at the xlayer level |
| if (isGlobal && lcr_params->lcr_global_atlas_id_present_flag) { |
| lcr_params->lcr_xlayer_atlas_segment_id[xId] = aom_rb_read_literal(rb, 8); |
| lcr_params->lcr_xlayer_priority_order[xId] = aom_rb_read_literal(rb, 8); |
| lcr_params->lcr_xlayer_rendering_method[xId] = aom_rb_read_literal(rb, 8); |
| } |
| } |
| return 0; |
| } |
| |
| static void read_lcr_global_payload(struct AV1Decoder *pbi, int i, |
| int sizePresent, |
| struct aom_read_bit_buffer *rb) { |
| struct LayerConfigurationRecord lcr_params = pbi->common.lcr_params; |
| (void)sizePresent; |
| |
| lcr_params.lcr_xLayer_id[i] = aom_rb_read_literal(rb, 5); |
| int n = lcr_params.lcr_xLayer_id[i]; |
| if (lcr_params.lcr_dependent_xlayers_flag && n > 0) |
| lcr_params.lcr_num_dependent_xlayer_map[n] = aom_rb_read_literal(rb, 32); |
| |
| read_lcr_xlayer_info(pbi, 1, n, rb); |
| } |
| |
| static int read_lcr_global_info(struct AV1Decoder *pbi, |
| struct aom_read_bit_buffer *rb) { |
| int lcr_global_config_record_id = aom_rb_read_literal(rb, 3); |
| |
| struct LayerConfigurationRecord *lcr_params; |
| int lcr_pos = -1; |
| for (int i = 0; i < pbi->lcr_counter; i++) { |
| if (pbi->lcr_list[i].lcr_global_config_record_id == |
| lcr_global_config_record_id) { |
| lcr_pos = i; |
| break; |
| } |
| } |
| if (lcr_pos != -1) { |
| lcr_params = &pbi->lcr_list[lcr_pos]; |
| } else { |
| if (pbi->lcr_counter >= MAX_NUM_LCR) { |
| aom_internal_error(&pbi->common.error, AOM_CODEC_ERROR, |
| "Failed to decode in read_lcr_global_info()"); |
| } |
| lcr_params = &pbi->lcr_list[pbi->lcr_counter]; |
| pbi->lcr_counter++; |
| } |
| |
| lcr_params->lcr_global_config_record_id = lcr_global_config_record_id; |
| lcr_params->lcr_global_config_record_id = aom_rb_read_literal(rb, 3); |
| lcr_params->lcr_max_num_extended_layers_minus_1 = aom_rb_read_literal(rb, 5); |
| lcr_params->lcr_max_profile_tier_level_info_present_flag = |
| aom_rb_read_bit(rb); |
| lcr_params->lcr_global_atlas_id_present_flag = aom_rb_read_bit(rb); |
| lcr_params->lcr_dependent_xlayers_flag = aom_rb_read_bit(rb); |
| lcr_params->lcr_reserved_zero_2bits = aom_rb_read_literal(rb, 2); |
| |
| if (lcr_params->lcr_global_atlas_id_present_flag) |
| lcr_params->lcr_global_atlas_id = aom_rb_read_literal(rb, 3); |
| else |
| lcr_params->lcr_reserved_zero_3bits = aom_rb_read_literal(rb, 2); |
| lcr_params->lcr_data_size_present_flag = aom_rb_read_bit(rb); |
| lcr_params->lcr_global_purpose_id = aom_rb_read_literal(rb, 7); |
| |
| if (lcr_params->lcr_max_profile_tier_level_info_present_flag) |
| read_lcr_profile_tier_level(31, 31); |
| |
| for (int i = 0; i < lcr_params->lcr_max_num_extended_layers_minus_1 + 1; |
| i++) { |
| lcr_params->lcr_data_size[i] = 0; |
| if (lcr_params->lcr_data_size_present_flag) |
| lcr_params->lcr_data_size[i] = aom_rb_read_uleb(rb); |
| read_lcr_global_payload(pbi, i, lcr_params->lcr_data_size_present_flag, rb); |
| } |
| return 0; |
| } |
| |
| static int read_lcr_local_info(struct AV1Decoder *pbi, int xlayerId, |
| struct aom_read_bit_buffer *rb) { |
| int lcr_global_id = aom_rb_read_literal(rb, 3); |
| |
| struct LayerConfigurationRecord *lcr_params; |
| int lcr_pos = -1; |
| for (int i = 0; i < pbi->lcr_counter; i++) { |
| if (pbi->lcr_list[i].lcr_global_id[xlayerId] == lcr_global_id) { |
| lcr_pos = i; |
| break; |
| } |
| } // i |
| if (lcr_pos != -1) { |
| lcr_params = &pbi->lcr_list[lcr_pos]; |
| } else { |
| if (pbi->lcr_counter >= MAX_NUM_LCR) { |
| aom_internal_error(&pbi->common.error, AOM_CODEC_ERROR, |
| "Failed to decode in read_lcr_local_info()"); |
| } |
| lcr_params = &pbi->lcr_list[pbi->lcr_counter]; |
| pbi->lcr_counter++; |
| } |
| |
| lcr_params->lcr_global_id[xlayerId] = lcr_global_id; |
| lcr_params->lcr_local_id[xlayerId] = aom_rb_read_literal(rb, 3); |
| |
| lcr_params->lcr_local_atlas_id_present_flag[xlayerId] = aom_rb_read_bit(rb); |
| |
| if (lcr_params->lcr_local_atlas_id_present_flag[xlayerId]) |
| lcr_params->lcr_local_atlas_id[xlayerId] = aom_rb_read_literal(rb, 3); |
| else |
| lcr_params->lcr_reserved_zero_3bits = aom_rb_read_literal(rb, 3); |
| |
| lcr_params->lcr_reserved_zero_6bits = aom_rb_read_literal(rb, 6); |
| |
| read_lcr_xlayer_info(pbi, 0, xlayerId, rb); |
| |
| return 0; |
| } |
| |
| uint32_t av1_read_layer_configuration_record_obu( |
| struct AV1Decoder *pbi, int xlayer_id, struct aom_read_bit_buffer *rb) { |
| const uint32_t saved_bit_offset = rb->bit_offset; |
| assert(rb->error_handler); |
| |
| if (xlayer_id == 31) |
| read_lcr_global_info(pbi, rb); |
| else |
| read_lcr_local_info(pbi, xlayer_id, rb); |
| |
| if (av1_check_trailing_bits(pbi, rb) != 0) { |
| return 0; |
| } |
| pbi->lcr_counter++; |
| return ((rb->bit_offset - saved_bit_offset + 7) >> 3); |
| } |
