[FFmpeg-devel] [PATCH 1/4] avcodec/cbs_h265: fix range of sps_max_sub_layers_minus1

[FFmpeg-devel] [PATCH 1/4] avcodec/cbs_h265: fix range of sps_max_sub_layers_minus1

[James Almer]

The VPS referenced by the SPS must always be present as the max value for
sps_max_sub_layers_minus1 is vps_max_sub_layers_minus1. This replaces a buggy
custom range check for the aforementioned field.
Also, add the missing conformance check for sps_temporal_id_nesting_flag while
at it.

Signed-off-by: James Almer <jamrial@gmail.com>
---
 libavcodec/cbs_h265_syntax_template.c | 37 +++++++++++++++------------
 1 file changed, 20 insertions(+), 17 deletions(-)

diff --git a/libavcodec/cbs_h265_syntax_template.c b/libavcodec/cbs_h265_syntax_template.c
index 86ca00a0c9..c6db439b3b 100644
--- a/libavcodec/cbs_h265_syntax_template.c
+++ b/libavcodec/cbs_h265_syntax_template.c
@@ -788,25 +788,28 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
 
     ub(4, sps_video_parameter_set_id);
     h265->active_vps = vps = h265->vps[current->sps_video_parameter_set_id];
+    if (!vps) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "VPS id %d not available.\n",
+               current->sps_video_parameter_set_id);
+        return AVERROR_INVALIDDATA;
+    }
 
-    u(3, sps_max_sub_layers_minus1, 0, HEVC_MAX_SUB_LAYERS - 1);
+    u(3, sps_max_sub_layers_minus1, 0, vps->vps_max_sub_layers_minus1);
     flag(sps_temporal_id_nesting_flag);
-    if (vps) {
-        if (vps->vps_max_sub_layers_minus1 > current->sps_max_sub_layers_minus1) {
-            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
-                   "sps_max_sub_layers_minus1 (%d) must be less than or equal to "
-                   "vps_max_sub_layers_minus1 (%d).\n",
-                   vps->vps_max_sub_layers_minus1,
-                   current->sps_max_sub_layers_minus1);
-            return AVERROR_INVALIDDATA;
-        }
-        if (vps->vps_temporal_id_nesting_flag &&
-            !current->sps_temporal_id_nesting_flag) {
-            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
-                   "sps_temporal_id_nesting_flag must be 1 if "
-                   "vps_temporal_id_nesting_flag is 1.\n");
-            return AVERROR_INVALIDDATA;
-        }
+
+    if (vps->vps_temporal_id_nesting_flag &&
+        !current->sps_temporal_id_nesting_flag) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
+               "sps_temporal_id_nesting_flag must be 1 if "
+               "vps_temporal_id_nesting_flag is 1.\n");
+        return AVERROR_INVALIDDATA;
+    }
+    if (current->sps_max_sub_layers_minus1 == 0 &&
+        current->sps_temporal_id_nesting_flag != 1) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
+               "sps_temporal_id_nesting_flag must be 1 if "
+               "sps_max_sub_layers_minus1 is 0.\n");
+        return AVERROR_INVALIDDATA;
     }
 
     CHECK(FUNC(profile_tier_level)(ctx, rw, &current->profile_tier_level,
-- 
2.45.2

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 2/4] avcodec/cbs_h265: add partial support for Multilayer extension fields in parameter set NALUs

[James Almer]

Signed-off-by: James Almer <jamrial@gmail.com>
---
 libavcodec/cbs_h2645.c                |   3 +-
 libavcodec/cbs_h265.h                 |  44 ++++++++++
 libavcodec/cbs_h265_syntax_template.c | 113 +++++++++++++++++++++++++-
 libavcodec/hevc/ps.h                  |   4 +-
 4 files changed, 159 insertions(+), 5 deletions(-)

diff --git a/libavcodec/cbs_h2645.c b/libavcodec/cbs_h2645.c
index 5ec781ddab..828e56b8c0 100644
--- a/libavcodec/cbs_h2645.c
+++ b/libavcodec/cbs_h2645.c
@@ -499,7 +499,8 @@ static int cbs_h2645_fragment_add_nals(CodedBitstreamContext *ctx,
         size_t size = nal->size;
         enum AVCodecID codec_id = ctx->codec->codec_id;
 
-        if (codec_id != AV_CODEC_ID_VVC && nal->nuh_layer_id > 0)
+        if (codec_id == AV_CODEC_ID_HEVC && nal->nuh_layer_id > 0 &&
+            (nal->type < HEVC_NAL_VPS || nal->type > HEVC_NAL_PPS))
             continue;
 
         // Remove trailing zeroes.
diff --git a/libavcodec/cbs_h265.h b/libavcodec/cbs_h265.h
index 91a5a55317..afb942ced5 100644
--- a/libavcodec/cbs_h265.h
+++ b/libavcodec/cbs_h265.h
@@ -248,12 +248,16 @@ typedef struct H265RawSPS {
     uint8_t sps_video_parameter_set_id;
 
     uint8_t sps_max_sub_layers_minus1;
+    uint8_t sps_ext_or_max_sub_layers_minus1;
     uint8_t sps_temporal_id_nesting_flag;
 
     H265RawProfileTierLevel profile_tier_level;
 
     uint8_t sps_seq_parameter_set_id;
 
+    uint8_t update_rep_format_flag;
+    uint8_t sps_rep_format_idx;
+
     uint8_t chroma_format_idc;
     uint8_t separate_colour_plane_flag;
 
@@ -284,6 +288,8 @@ typedef struct H265RawSPS {
     uint8_t max_transform_hierarchy_depth_intra;
 
     uint8_t scaling_list_enabled_flag;
+    uint8_t sps_infer_scaling_list_flag;
+    uint8_t sps_scaling_list_ref_layer_id;
     uint8_t sps_scaling_list_data_present_flag;
     H265RawScalingList scaling_list;
 
@@ -342,6 +348,9 @@ typedef struct H265RawSPS {
 
     uint8_t motion_vector_resolution_control_idc;
     uint8_t intra_boundary_filtering_disable_flag;
+
+    // Multilayer extension.
+    uint8_t inter_view_mv_vert_constraint_flag;
 } H265RawSPS;
 
 typedef struct H265RawPPS {
@@ -433,6 +442,41 @@ typedef struct H265RawPPS {
     uint8_t luma_bit_depth_entry_minus8;
     uint8_t chroma_bit_depth_entry_minus8;
     uint16_t pps_palette_predictor_initializers[3][128];
+
+    // Multilayer extension.
+    uint8_t poc_reset_info_present_flag;
+    uint8_t pps_infer_scaling_list_flag;
+    uint8_t pps_scaling_list_ref_layer_id;
+    uint8_t num_ref_loc_offsets;
+    uint8_t ref_loc_offset_layer_id[64];
+    uint8_t scaled_ref_layer_offset_present_flag[64];
+    int16_t scaled_ref_layer_left_offset[64];
+    int16_t scaled_ref_layer_top_offset[64];
+    int16_t scaled_ref_layer_right_offset[64];
+    int16_t scaled_ref_layer_bottom_offset[64];
+    uint8_t ref_region_offset_present_flag[64];
+    int16_t ref_region_left_offset[64];
+    int16_t ref_region_top_offset[64];
+    int16_t ref_region_right_offset[64];
+    int16_t ref_region_bottom_offset[64];
+    uint8_t resample_phase_set_present_flag[64];
+    uint8_t phase_hor_luma[64];
+    uint8_t phase_ver_luma[64];
+    uint8_t phase_hor_chroma_plus8[64];
+    uint8_t phase_ver_chroma_plus8[64];
+    uint8_t colour_mapping_enabled_flag;
+    uint8_t num_cm_ref_layers;
+    uint8_t cm_ref_layer_id[62];
+    uint8_t cm_octant_depth;
+    uint8_t cm_y_part_num_log2;
+    uint8_t luma_bit_depth_cm_input;
+    uint8_t chroma_bit_depth_cm_input;
+    uint8_t luma_bit_depth_cm_output;
+    uint8_t chroma_bit_depth_cm_output;
+    uint8_t cm_res_quant_bits;
+    uint8_t cm_delta_flc_bits;
+    int8_t cm_adapt_threshold_u_delta;
+    int8_t cm_adapt_threshold_v_delta;
 } H265RawPPS;
 
 typedef struct H265RawAUD {
diff --git a/libavcodec/cbs_h265_syntax_template.c b/libavcodec/cbs_h265_syntax_template.c
index c6db439b3b..2f8ee0db10 100644
--- a/libavcodec/cbs_h265_syntax_template.c
+++ b/libavcodec/cbs_h265_syntax_template.c
@@ -747,6 +747,16 @@ static int FUNC(sps_scc_extension)(CodedBitstreamContext *ctx, RWContext *rw,
     return 0;
 }
 
+static int FUNC(sps_multilayer_extension)(CodedBitstreamContext *ctx, RWContext *rw,
+                                          H265RawSPS *current)
+{
+    int err;
+
+    flag(inter_view_mv_vert_constraint_flag);
+
+    return 0;
+}
+
 static int FUNC(vui_parameters_default)(CodedBitstreamContext *ctx,
                                         RWContext *rw, H265RawVUI *current,
                                         H265RawSPS *sps)
@@ -781,6 +791,7 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
     int err, i;
     unsigned int min_cb_log2_size_y, ctb_log2_size_y,
                  min_cb_size_y,   min_tb_log2_size_y;
+    unsigned int multi_layer_ext_sps_flag;
 
     HEADER("Sequence Parameter Set");
 
@@ -794,7 +805,17 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
         return AVERROR_INVALIDDATA;
     }
 
+    if (current->nal_unit_header.nuh_layer_id == 0)
     u(3, sps_max_sub_layers_minus1, 0, vps->vps_max_sub_layers_minus1);
+    else {
+        u(3, sps_ext_or_max_sub_layers_minus1, 0, HEVC_MAX_SUB_LAYERS);
+        infer(sps_max_sub_layers_minus1, current->sps_ext_or_max_sub_layers_minus1 == 7
+                                         ? vps->vps_max_sub_layers_minus1
+                                         : current->sps_ext_or_max_sub_layers_minus1);
+    }
+    multi_layer_ext_sps_flag = current->nal_unit_header.nuh_layer_id &&
+                               current->sps_ext_or_max_sub_layers_minus1 == 7;
+    if (!multi_layer_ext_sps_flag) {
     flag(sps_temporal_id_nesting_flag);
 
     if (vps->vps_temporal_id_nesting_flag &&
@@ -814,9 +835,20 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
 
     CHECK(FUNC(profile_tier_level)(ctx, rw, &current->profile_tier_level,
                                    1, current->sps_max_sub_layers_minus1));
+    } else {
+        if (current->sps_max_sub_layers_minus1 > 0)
+            infer(sps_temporal_id_nesting_flag, vps->vps_temporal_id_nesting_flag);
+        else
+            infer(sps_temporal_id_nesting_flag, 1);
+    }
 
     ue(sps_seq_parameter_set_id, 0, 15);
 
+    if (multi_layer_ext_sps_flag) {
+        flag(update_rep_format_flag);
+        if (current->update_rep_format_flag)
+            ub(8, sps_rep_format_idx);
+    } else {
     ue(chroma_format_idc, 0, 3);
     if (current->chroma_format_idc == 3)
         flag(separate_colour_plane_flag);
@@ -841,9 +873,11 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
 
     ue(bit_depth_luma_minus8,   0, 8);
     ue(bit_depth_chroma_minus8, 0, 8);
+    }
 
     ue(log2_max_pic_order_cnt_lsb_minus4, 0, 12);
 
+    if (!multi_layer_ext_sps_flag) {
     flag(sps_sub_layer_ordering_info_present_flag);
     for (i = (current->sps_sub_layer_ordering_info_present_flag ?
               0 : current->sps_max_sub_layers_minus1);
@@ -865,6 +899,7 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
                   current->sps_max_latency_increase_plus1[current->sps_max_sub_layers_minus1]);
         }
     }
+    }
 
     ue(log2_min_luma_coding_block_size_minus3,   0, 3);
     min_cb_log2_size_y = current->log2_min_luma_coding_block_size_minus3 + 3;
@@ -895,9 +930,17 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
 
     flag(scaling_list_enabled_flag);
     if (current->scaling_list_enabled_flag) {
+        if (multi_layer_ext_sps_flag)
+            flag(sps_infer_scaling_list_flag);
+        else
+            infer(sps_infer_scaling_list_flag, 0);
+        if (current->sps_infer_scaling_list_flag)
+            ub(6, sps_scaling_list_ref_layer_id);
+        else {
         flag(sps_scaling_list_data_present_flag);
         if (current->sps_scaling_list_data_present_flag)
             CHECK(FUNC(scaling_list_data)(ctx, rw, &current->scaling_list));
+        }
     } else {
         infer(sps_scaling_list_data_present_flag, 0);
     }
@@ -955,7 +998,7 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
     if (current->sps_range_extension_flag)
         CHECK(FUNC(sps_range_extension)(ctx, rw, current));
     if (current->sps_multilayer_extension_flag)
-        return AVERROR_PATCHWELCOME;
+        CHECK(FUNC(sps_multilayer_extension)(ctx, rw, current));
     if (current->sps_3d_extension_flag)
         return AVERROR_PATCHWELCOME;
     if (current->sps_scc_extension_flag)
@@ -996,6 +1039,72 @@ static int FUNC(pps_range_extension)(CodedBitstreamContext *ctx, RWContext *rw,
     return 0;
 }
 
+static int FUNC(pps_multilayer_extension)(CodedBitstreamContext *ctx, RWContext *rw,
+                                          H265RawPPS *current)
+{
+    CodedBitstreamH265Context *h265 = ctx->priv_data;
+    const H265RawVPS *vps = h265->active_vps;
+    int offset;
+    int err, i;
+
+    flag(poc_reset_info_present_flag);
+    flag(pps_infer_scaling_list_flag);
+    if (current->pps_infer_scaling_list_flag)
+        ub(6, pps_scaling_list_ref_layer_id);
+
+    if (!vps) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "VPS missing for PPS Multilayer Extension.\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    ue(num_ref_loc_offsets, 0, vps->vps_max_layers_minus1);
+    for (i = 0; i < current->num_ref_loc_offsets; i++) {
+        ubs(6, ref_loc_offset_layer_id[i], 1, i);
+        offset = current->ref_loc_offset_layer_id[i];
+        flags(scaled_ref_layer_offset_present_flag[i], 1, i);
+        if (current->scaled_ref_layer_offset_present_flag[i]) {
+            ses(scaled_ref_layer_left_offset[offset], -16384, 16383, 1, offset);
+            ses(scaled_ref_layer_top_offset[offset], -16384, 16383, 1, offset);
+            ses(scaled_ref_layer_right_offset[offset], -16384, 16383, 1, offset);
+            ses(scaled_ref_layer_bottom_offset[offset], -16384, 16383, 1, offset);
+        } else {
+            infer(scaled_ref_layer_left_offset[offset], 0);
+            infer(scaled_ref_layer_top_offset[offset], 0);
+            infer(scaled_ref_layer_right_offset[offset], 0);
+            infer(scaled_ref_layer_bottom_offset[offset], 0);
+        }
+        flags(ref_region_offset_present_flag[i], 1, i);
+        if (current->ref_region_offset_present_flag[i]) {
+            ses(ref_region_left_offset[offset], -16384, 16383, 1, offset);
+            ses(ref_region_top_offset[offset], -16384, 16383, 1, offset);
+            ses(ref_region_right_offset[offset], -16384, 16383, 1, offset);
+            ses(ref_region_bottom_offset[offset], -16384, 16383, 1, offset);
+        } else {
+            infer(ref_region_left_offset[offset], 0);
+            infer(ref_region_top_offset[offset], 0);
+            infer(ref_region_right_offset[offset], 0);
+            infer(ref_region_bottom_offset[offset], 0);
+        }
+        flags(resample_phase_set_present_flag[i], 1, i);
+        if (current->resample_phase_set_present_flag[i]) {
+            ues(phase_hor_luma[offset], 0, 31, 1, offset);
+            ues(phase_ver_luma[offset], 0, 31, 1, offset);
+            ues(phase_hor_chroma_plus8[offset], 0, 63, 1, offset);
+            ues(phase_ver_chroma_plus8[offset], 0, 63, 1, offset);
+        } else {
+            infer(phase_hor_luma[offset], 0);
+            infer(phase_ver_luma[offset], 0);
+            infer(phase_hor_chroma_plus8[offset], 8);
+        }
+    }
+
+    flag(colour_mapping_enabled_flag);
+    if (current->colour_mapping_enabled_flag)
+        return AVERROR_PATCHWELCOME;
+
+    return 0;
+}
+
 static int FUNC(pps_scc_extension)(CodedBitstreamContext *ctx, RWContext *rw,
                                    H265RawPPS *current)
 {
@@ -1146,7 +1255,7 @@ static int FUNC(pps)(CodedBitstreamContext *ctx, RWContext *rw,
     if (current->pps_range_extension_flag)
         CHECK(FUNC(pps_range_extension)(ctx, rw, current));
     if (current->pps_multilayer_extension_flag)
-        return AVERROR_PATCHWELCOME;
+        CHECK(FUNC(pps_multilayer_extension)(ctx, rw, current));
     if (current->pps_3d_extension_flag)
         return AVERROR_PATCHWELCOME;
     if (current->pps_scc_extension_flag)
diff --git a/libavcodec/hevc/ps.h b/libavcodec/hevc/ps.h
index 17395c5510..fab5a46273 100644
--- a/libavcodec/hevc/ps.h
+++ b/libavcodec/hevc/ps.h
@@ -390,8 +390,8 @@ typedef struct HEVCPPS {
     uint8_t resample_phase_set_present_flag[64];
     uint8_t phase_hor_luma[64];
     uint8_t phase_ver_luma[64];
-    int8_t phase_hor_chroma[64];
-    int8_t phase_ver_chroma[64];
+    uint8_t phase_hor_chroma[64];
+    uint8_t phase_ver_chroma[64];
     uint8_t colour_mapping_enabled_flag;
     uint8_t num_cm_ref_layers;
     uint8_t cm_ref_layer_id[62];
-- 
2.45.2

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 3/4] avcodec/cbs_h265: reindent after the previous commit

[James Almer]

Signed-off-by: James Almer <jamrial@gmail.com>
---
 libavcodec/cbs_h265_syntax_template.c | 124 +++++++++++++-------------
 1 file changed, 62 insertions(+), 62 deletions(-)

diff --git a/libavcodec/cbs_h265_syntax_template.c b/libavcodec/cbs_h265_syntax_template.c
index 2f8ee0db10..1826950e8e 100644
--- a/libavcodec/cbs_h265_syntax_template.c
+++ b/libavcodec/cbs_h265_syntax_template.c
@@ -806,7 +806,7 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
     }
 
     if (current->nal_unit_header.nuh_layer_id == 0)
-    u(3, sps_max_sub_layers_minus1, 0, vps->vps_max_sub_layers_minus1);
+        u(3, sps_max_sub_layers_minus1, 0, vps->vps_max_sub_layers_minus1);
     else {
         u(3, sps_ext_or_max_sub_layers_minus1, 0, HEVC_MAX_SUB_LAYERS);
         infer(sps_max_sub_layers_minus1, current->sps_ext_or_max_sub_layers_minus1 == 7
@@ -816,25 +816,25 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
     multi_layer_ext_sps_flag = current->nal_unit_header.nuh_layer_id &&
                                current->sps_ext_or_max_sub_layers_minus1 == 7;
     if (!multi_layer_ext_sps_flag) {
-    flag(sps_temporal_id_nesting_flag);
+        flag(sps_temporal_id_nesting_flag);
 
-    if (vps->vps_temporal_id_nesting_flag &&
-        !current->sps_temporal_id_nesting_flag) {
-        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
-               "sps_temporal_id_nesting_flag must be 1 if "
-               "vps_temporal_id_nesting_flag is 1.\n");
-        return AVERROR_INVALIDDATA;
-    }
-    if (current->sps_max_sub_layers_minus1 == 0 &&
-        current->sps_temporal_id_nesting_flag != 1) {
-        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
-               "sps_temporal_id_nesting_flag must be 1 if "
-               "sps_max_sub_layers_minus1 is 0.\n");
-        return AVERROR_INVALIDDATA;
-    }
+        if (vps->vps_temporal_id_nesting_flag &&
+            !current->sps_temporal_id_nesting_flag) {
+            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
+                   "sps_temporal_id_nesting_flag must be 1 if "
+                   "vps_temporal_id_nesting_flag is 1.\n");
+            return AVERROR_INVALIDDATA;
+        }
+        if (current->sps_max_sub_layers_minus1 == 0 &&
+            current->sps_temporal_id_nesting_flag != 1) {
+            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
+                   "sps_temporal_id_nesting_flag must be 1 if "
+                   "sps_max_sub_layers_minus1 is 0.\n");
+            return AVERROR_INVALIDDATA;
+        }
 
-    CHECK(FUNC(profile_tier_level)(ctx, rw, &current->profile_tier_level,
-                                   1, current->sps_max_sub_layers_minus1));
+        CHECK(FUNC(profile_tier_level)(ctx, rw, &current->profile_tier_level,
+                                       1, current->sps_max_sub_layers_minus1));
     } else {
         if (current->sps_max_sub_layers_minus1 > 0)
             infer(sps_temporal_id_nesting_flag, vps->vps_temporal_id_nesting_flag);
@@ -849,56 +849,56 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
         if (current->update_rep_format_flag)
             ub(8, sps_rep_format_idx);
     } else {
-    ue(chroma_format_idc, 0, 3);
-    if (current->chroma_format_idc == 3)
-        flag(separate_colour_plane_flag);
-    else
-        infer(separate_colour_plane_flag, 0);
+        ue(chroma_format_idc, 0, 3);
+        if (current->chroma_format_idc == 3)
+            flag(separate_colour_plane_flag);
+        else
+            infer(separate_colour_plane_flag, 0);
 
-    ue(pic_width_in_luma_samples,  1, HEVC_MAX_WIDTH);
-    ue(pic_height_in_luma_samples, 1, HEVC_MAX_HEIGHT);
+        ue(pic_width_in_luma_samples,  1, HEVC_MAX_WIDTH);
+        ue(pic_height_in_luma_samples, 1, HEVC_MAX_HEIGHT);
 
-    flag(conformance_window_flag);
-    if (current->conformance_window_flag) {
-        ue(conf_win_left_offset,   0, current->pic_width_in_luma_samples);
-        ue(conf_win_right_offset,  0, current->pic_width_in_luma_samples);
-        ue(conf_win_top_offset,    0, current->pic_height_in_luma_samples);
-        ue(conf_win_bottom_offset, 0, current->pic_height_in_luma_samples);
-    } else {
-        infer(conf_win_left_offset,   0);
-        infer(conf_win_right_offset,  0);
-        infer(conf_win_top_offset,    0);
-        infer(conf_win_bottom_offset, 0);
-    }
+        flag(conformance_window_flag);
+        if (current->conformance_window_flag) {
+            ue(conf_win_left_offset,   0, current->pic_width_in_luma_samples);
+            ue(conf_win_right_offset,  0, current->pic_width_in_luma_samples);
+            ue(conf_win_top_offset,    0, current->pic_height_in_luma_samples);
+            ue(conf_win_bottom_offset, 0, current->pic_height_in_luma_samples);
+        } else {
+            infer(conf_win_left_offset,   0);
+            infer(conf_win_right_offset,  0);
+            infer(conf_win_top_offset,    0);
+            infer(conf_win_bottom_offset, 0);
+        }
 
-    ue(bit_depth_luma_minus8,   0, 8);
-    ue(bit_depth_chroma_minus8, 0, 8);
+        ue(bit_depth_luma_minus8,   0, 8);
+        ue(bit_depth_chroma_minus8, 0, 8);
     }
 
     ue(log2_max_pic_order_cnt_lsb_minus4, 0, 12);
 
     if (!multi_layer_ext_sps_flag) {
-    flag(sps_sub_layer_ordering_info_present_flag);
-    for (i = (current->sps_sub_layer_ordering_info_present_flag ?
-              0 : current->sps_max_sub_layers_minus1);
-         i <= current->sps_max_sub_layers_minus1; i++) {
-        ues(sps_max_dec_pic_buffering_minus1[i],
-            0, HEVC_MAX_DPB_SIZE - 1,                        1, i);
-        ues(sps_max_num_reorder_pics[i],
-            0, current->sps_max_dec_pic_buffering_minus1[i], 1, i);
-        ues(sps_max_latency_increase_plus1[i],
-            0, UINT32_MAX - 1,                               1, i);
-    }
-    if (!current->sps_sub_layer_ordering_info_present_flag) {
-        for (i = 0; i < current->sps_max_sub_layers_minus1; i++) {
-            infer(sps_max_dec_pic_buffering_minus1[i],
-                  current->sps_max_dec_pic_buffering_minus1[current->sps_max_sub_layers_minus1]);
-            infer(sps_max_num_reorder_pics[i],
-                  current->sps_max_num_reorder_pics[current->sps_max_sub_layers_minus1]);
-            infer(sps_max_latency_increase_plus1[i],
-                  current->sps_max_latency_increase_plus1[current->sps_max_sub_layers_minus1]);
+        flag(sps_sub_layer_ordering_info_present_flag);
+        for (i = (current->sps_sub_layer_ordering_info_present_flag ?
+                  0 : current->sps_max_sub_layers_minus1);
+             i <= current->sps_max_sub_layers_minus1; i++) {
+            ues(sps_max_dec_pic_buffering_minus1[i],
+                0, HEVC_MAX_DPB_SIZE - 1,                        1, i);
+            ues(sps_max_num_reorder_pics[i],
+                0, current->sps_max_dec_pic_buffering_minus1[i], 1, i);
+            ues(sps_max_latency_increase_plus1[i],
+                0, UINT32_MAX - 1,                               1, i);
+        }
+        if (!current->sps_sub_layer_ordering_info_present_flag) {
+            for (i = 0; i < current->sps_max_sub_layers_minus1; i++) {
+                infer(sps_max_dec_pic_buffering_minus1[i],
+                      current->sps_max_dec_pic_buffering_minus1[current->sps_max_sub_layers_minus1]);
+                infer(sps_max_num_reorder_pics[i],
+                      current->sps_max_num_reorder_pics[current->sps_max_sub_layers_minus1]);
+                infer(sps_max_latency_increase_plus1[i],
+                      current->sps_max_latency_increase_plus1[current->sps_max_sub_layers_minus1]);
+            }
         }
-    }
     }
 
     ue(log2_min_luma_coding_block_size_minus3,   0, 3);
@@ -937,9 +937,9 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
         if (current->sps_infer_scaling_list_flag)
             ub(6, sps_scaling_list_ref_layer_id);
         else {
-        flag(sps_scaling_list_data_present_flag);
-        if (current->sps_scaling_list_data_present_flag)
-            CHECK(FUNC(scaling_list_data)(ctx, rw, &current->scaling_list));
+            flag(sps_scaling_list_data_present_flag);
+            if (current->sps_scaling_list_data_present_flag)
+                CHECK(FUNC(scaling_list_data)(ctx, rw, &current->scaling_list));
         }
     } else {
         infer(sps_scaling_list_data_present_flag, 0);
-- 
2.45.2

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 4/4] avcodec/cbs_h265: add support for 3D Reference Displays Information SEI

[James Almer]

Signed-off-by: James Almer <jamrial@gmail.com>
---
 libavcodec/cbs_h2645.c                |  6 ++++
 libavcodec/cbs_h265.h                 | 16 ++++++++++
 libavcodec/cbs_h265_syntax_template.c | 42 +++++++++++++++++++++++++++
 3 files changed, 64 insertions(+)

diff --git a/libavcodec/cbs_h2645.c b/libavcodec/cbs_h2645.c
index 828e56b8c0..d73d77a985 100644
--- a/libavcodec/cbs_h2645.c
+++ b/libavcodec/cbs_h2645.c
@@ -2275,6 +2275,12 @@ static const SEIMessageTypeDescriptor cbs_sei_h265_types[] = {
         sizeof(H265RawSEIAlphaChannelInfo),
         SEI_MESSAGE_RW(h265, sei_alpha_channel_info),
     },
+    {
+        SEI_TYPE_THREE_DIMENSIONAL_REFERENCE_DISPLAYS_INFO,
+        1, 0,
+        sizeof(H265RawSEI3DReferenceDisplaysInfo),
+        SEI_MESSAGE_RW(h265, sei_3d_reference_displays_info),
+    },
     SEI_MESSAGE_TYPE_END
 };
 
diff --git a/libavcodec/cbs_h265.h b/libavcodec/cbs_h265.h
index afb942ced5..52631f9bfb 100644
--- a/libavcodec/cbs_h265.h
+++ b/libavcodec/cbs_h265.h
@@ -715,6 +715,22 @@ typedef struct H265RawSEIAlphaChannelInfo {
     uint8_t  alpha_channel_clip_type_flag;
 } H265RawSEIAlphaChannelInfo;
 
+typedef struct H265RawSEI3DReferenceDisplaysInfo {
+    uint8_t prec_ref_display_width;
+    uint8_t ref_viewing_distance_flag;
+    uint8_t prec_ref_viewing_dist;
+    uint8_t num_ref_displays_minus1;
+    uint8_t left_view_id[31];
+    uint8_t right_view_id[31];
+    uint8_t exponent_ref_display_width[31];
+    uint8_t mantissa_ref_display_width[31];
+    uint8_t exponent_ref_viewing_distance[31];
+    uint8_t mantissa_ref_viewing_distance[31];
+    uint8_t additional_shift_present_flag[31];
+    uint16_t num_sample_shift_plus512[31];
+    uint8_t three_dimensional_reference_displays_extension_flag;
+} H265RawSEI3DReferenceDisplaysInfo;
+
 typedef struct H265RawSEI {
     H265RawNALUnitHeader nal_unit_header;
     SEIRawMessageList    message_list;
diff --git a/libavcodec/cbs_h265_syntax_template.c b/libavcodec/cbs_h265_syntax_template.c
index 1826950e8e..ee01b5e0d0 100644
--- a/libavcodec/cbs_h265_syntax_template.c
+++ b/libavcodec/cbs_h265_syntax_template.c
@@ -2189,6 +2189,48 @@ SEI_FUNC(sei_alpha_channel_info, (CodedBitstreamContext *ctx, RWContext *rw,
     return 0;
 }
 
+SEI_FUNC(sei_3d_reference_displays_info, (CodedBitstreamContext *ctx, RWContext *rw,
+                                          H265RawSEI3DReferenceDisplaysInfo *current,
+                                          SEIMessageState *sei))
+{
+    int length;
+    int err, i;
+
+    HEADER("Three Dimensional Reference Displays Information");
+
+    ue(prec_ref_display_width, 0, 31);
+    flag(ref_viewing_distance_flag);
+    if (current->ref_viewing_distance_flag)
+        ue(prec_ref_viewing_dist, 0, 31);
+    ue(num_ref_displays_minus1, 0, 31);
+    for (i = 0; i <= current->num_ref_displays_minus1; i++) {
+        ues(left_view_id[i], 0, UINT8_MAX, 1, i);
+        ues(right_view_id[i], 0, UINT8_MAX, 1, i);
+        us(6, exponent_ref_display_width[i], 0, 62, 1, i);
+        if (!current->exponent_ref_display_width[i])
+            length = FFMAX(0, (int)current->prec_ref_display_width - 30);
+        else
+            length = FFMAX(0, (int)current->exponent_ref_display_width[i] +
+                              (int)current->prec_ref_display_width - 31);
+        ubs(length, mantissa_ref_display_width[i], 1, i);
+        if (current->ref_viewing_distance_flag) {
+            us(6, exponent_ref_viewing_distance[i], 0, 62, 1, i);
+            if (!current->exponent_ref_viewing_distance[i])
+                length = FFMAX(0, (int)current->prec_ref_viewing_dist - 30);
+            else
+                length = FFMAX(0, (int)current->exponent_ref_viewing_distance[i] +
+                                  (int)current->prec_ref_viewing_dist - 31);
+            ubs(length, mantissa_ref_viewing_distance[i], 1, i);
+        }
+        flags(additional_shift_present_flag[i], 1, i);
+        if (current->additional_shift_present_flag[i])
+            us(10, num_sample_shift_plus512[i], 0, 1023, 1, i);
+    }
+    flag(three_dimensional_reference_displays_extension_flag);
+
+    return 0;
+}
+
 static int FUNC(sei)(CodedBitstreamContext *ctx, RWContext *rw,
                      H265RawSEI *current, int prefix)
 {
-- 
2.45.2

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH 1/4] avcodec/cbs_h265: fix range of sps_max_sub_layers_minus1

[James Almer]

On 7/13/2024 11:58 AM, James Almer wrote:
> The VPS referenced by the SPS must always be present as the max value for
> sps_max_sub_layers_minus1 is vps_max_sub_layers_minus1. This replaces a buggy
> custom range check for the aforementioned field.
> Also, add the missing conformance check for sps_temporal_id_nesting_flag while
> at it.
> 
> Signed-off-by: James Almer <jamrial@gmail.com>
> ---
>   libavcodec/cbs_h265_syntax_template.c | 37 +++++++++++++++------------
>   1 file changed, 20 insertions(+), 17 deletions(-)
> 
> diff --git a/libavcodec/cbs_h265_syntax_template.c b/libavcodec/cbs_h265_syntax_template.c
> index 86ca00a0c9..c6db439b3b 100644
> --- a/libavcodec/cbs_h265_syntax_template.c
> +++ b/libavcodec/cbs_h265_syntax_template.c
> @@ -788,25 +788,28 @@ static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
>   
>       ub(4, sps_video_parameter_set_id);
>       h265->active_vps = vps = h265->vps[current->sps_video_parameter_set_id];
> +    if (!vps) {
> +        av_log(ctx->log_ctx, AV_LOG_ERROR, "VPS id %d not available.\n",
> +               current->sps_video_parameter_set_id);
> +        return AVERROR_INVALIDDATA;
> +    }
>   
> -    u(3, sps_max_sub_layers_minus1, 0, HEVC_MAX_SUB_LAYERS - 1);
> +    u(3, sps_max_sub_layers_minus1, 0, vps->vps_max_sub_layers_minus1);
>       flag(sps_temporal_id_nesting_flag);
> -    if (vps) {
> -        if (vps->vps_max_sub_layers_minus1 > current->sps_max_sub_layers_minus1) {
> -            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
> -                   "sps_max_sub_layers_minus1 (%d) must be less than or equal to "
> -                   "vps_max_sub_layers_minus1 (%d).\n",
> -                   vps->vps_max_sub_layers_minus1,
> -                   current->sps_max_sub_layers_minus1);
> -            return AVERROR_INVALIDDATA;
> -        }
> -        if (vps->vps_temporal_id_nesting_flag &&
> -            !current->sps_temporal_id_nesting_flag) {
> -            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
> -                   "sps_temporal_id_nesting_flag must be 1 if "
> -                   "vps_temporal_id_nesting_flag is 1.\n");
> -            return AVERROR_INVALIDDATA;
> -        }
> +
> +    if (vps->vps_temporal_id_nesting_flag &&
> +        !current->sps_temporal_id_nesting_flag) {
> +        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
> +               "sps_temporal_id_nesting_flag must be 1 if "
> +               "vps_temporal_id_nesting_flag is 1.\n");
> +        return AVERROR_INVALIDDATA;
> +    }
> +    if (current->sps_max_sub_layers_minus1 == 0 &&
> +        current->sps_temporal_id_nesting_flag != 1) {
> +        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
> +               "sps_temporal_id_nesting_flag must be 1 if "
> +               "sps_max_sub_layers_minus1 is 0.\n");
> +        return AVERROR_INVALIDDATA;
>       }
>   
>       CHECK(FUNC(profile_tier_level)(ctx, rw, &current->profile_tier_level,

Will apply set.
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".