radeon/uvd: handle HEVC main 10 decode

Signed-off-by: Boyuan Zhang <boyuan.zhang@amd.com>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>

diff --git a/src/gallium/drivers/radeon/radeon_uvd.c b/src/gallium/drivers/radeon/radeon_uvd.c
index 367aabc7a182cdb2920f99d03ee70231eaf02474..b8efc58eaabf11e1f9c6c011ad4a39235bf35e8e 100644 (file)
--- a/src/gallium/drivers/radeon/radeon_uvd.c
+++ b/src/gallium/drivers/radeon/radeon_uvd.c
@@ -207,7 +207,7 @@ static uint32_t profile2stream_type(struct ruvd_decoder *dec, unsigned family)
        }
 }
 
-static unsigned calc_ctx_size(struct ruvd_decoder *dec)
+static unsigned calc_ctx_size_h265_main(struct ruvd_decoder *dec)
 {
        unsigned width = align(dec->base.width, VL_MACROBLOCK_WIDTH);
        unsigned height = align(dec->base.height, VL_MACROBLOCK_HEIGHT);
@@ -224,6 +224,39 @@ static unsigned calc_ctx_size(struct ruvd_decoder *dec)
        return ((width + 255) / 16) * ((height + 255) / 16) * 16 * max_references + 52 * 1024;
 }
 
+static unsigned calc_ctx_size_h265_main10(struct ruvd_decoder *dec, struct pipe_h265_picture_desc *pic)
+{
+       unsigned block_size, log2_ctb_size, width_in_ctb, height_in_ctb, num_16x16_block_per_ctb;
+       unsigned context_buffer_size_per_ctb_row, cm_buffer_size, max_mb_address, db_left_tile_pxl_size;
+       unsigned db_left_tile_ctx_size = 4096 / 16 * (32 + 16 * 4);
+
+       unsigned width = align(dec->base.width, VL_MACROBLOCK_WIDTH);
+       unsigned height = align(dec->base.height, VL_MACROBLOCK_HEIGHT);
+       unsigned coeff_10bit = (pic->pps->sps->bit_depth_luma_minus8 || pic->pps->sps->bit_depth_chroma_minus8) ? 2 : 1;
+
+       unsigned max_references = dec->base.max_references + 1;
+
+       if (dec->base.width * dec->base.height >= 4096*2000)
+               max_references = MAX2(max_references, 8);
+       else
+               max_references = MAX2(max_references, 17);
+
+       block_size = (1 << (pic->pps->sps->log2_min_luma_coding_block_size_minus3 + 3));
+       log2_ctb_size = block_size + pic->pps->sps->log2_diff_max_min_luma_coding_block_size;
+
+       width_in_ctb = (width + ((1 << log2_ctb_size) - 1)) >> log2_ctb_size;
+       height_in_ctb = (height + ((1 << log2_ctb_size) - 1)) >> log2_ctb_size;
+
+       num_16x16_block_per_ctb = ((1 << log2_ctb_size) >> 4) * ((1 << log2_ctb_size) >> 4);
+       context_buffer_size_per_ctb_row = align(width_in_ctb * num_16x16_block_per_ctb * 16, 256);
+       max_mb_address = (unsigned) ceil(height * 8 / 2048.0);
+
+       cm_buffer_size = max_references * context_buffer_size_per_ctb_row * height_in_ctb;
+       db_left_tile_pxl_size = coeff_10bit * (max_mb_address * 2 * 2048 + 1024);
+
+       return cm_buffer_size + db_left_tile_ctx_size + db_left_tile_pxl_size;
+}
+
 /* calculate size of reference picture buffer */
 static unsigned calc_dpb_size(struct ruvd_decoder *dec)
 {
@@ -305,7 +338,10 @@ static unsigned calc_dpb_size(struct ruvd_decoder *dec)
 
                width = align (width, 16);
                height = align (height, 16);
-               dpb_size = align((width * height * 3) / 2, 256) * max_references;
+               if (dec->base.profile == PIPE_VIDEO_PROFILE_HEVC_MAIN_10)
+                       dpb_size = align((width * height * 9) / 4, 256) * max_references;
+               else
+                       dpb_size = align((width * height * 3) / 2, 256) * max_references;
                break;
 
        case PIPE_VIDEO_FORMAT_VC1:
@@ -596,6 +632,15 @@ static struct ruvd_h265 get_h265_msg(struct ruvd_decoder *dec, struct pipe_video
                        result.direct_reflist[i][j] = pic->RefPicList[i][j];
        }
 
+       if ((pic->base.profile == PIPE_VIDEO_PROFILE_HEVC_MAIN_10) &&
+               (target->buffer_format == PIPE_FORMAT_NV12)) {
+               result.p010_mode = 0;
+               result.luma_10to8 = 5;
+               result.chroma_10to8 = 5;
+               result.sclr_luma10to8 = 4;
+               result.sclr_chroma10to8 = 4;
+       }
+
        /* TODO
        result.highestTid;
        result.isNonRef;
@@ -971,6 +1016,17 @@ static void ruvd_end_frame(struct pipe_video_codec *decoder,
 
        case PIPE_VIDEO_FORMAT_HEVC:
                dec->msg->body.decode.codec.h265 = get_h265_msg(dec, target, (struct pipe_h265_picture_desc*)picture);
+               if (dec->ctx.res == NULL) {
+                       unsigned ctx_size;
+                       if (dec->base.profile == PIPE_VIDEO_PROFILE_HEVC_MAIN_10)
+                               ctx_size = calc_ctx_size_h265_main10(dec, (struct pipe_h265_picture_desc*)picture);
+                       else
+                               ctx_size = calc_ctx_size_h265_main(dec);
+                       if (!rvid_create_buffer(dec->screen, &dec->ctx, ctx_size, PIPE_USAGE_DEFAULT)) {
+                               RVID_ERR("Can't allocated context buffer.\n");
+                       }
+                       rvid_clear_buffer(decoder->context, &dec->ctx);
+               }
                break;
 
        case PIPE_VIDEO_FORMAT_VC1:
@@ -1123,15 +1179,6 @@ struct pipe_video_codec *ruvd_create_decoder(struct pipe_context *context,
 
        rvid_clear_buffer(context, &dec->dpb);
 
-       if (u_reduce_video_profile(dec->base.profile) == PIPE_VIDEO_FORMAT_HEVC) {
-               unsigned ctx_size = calc_ctx_size(dec);
-               if (!rvid_create_buffer(dec->screen, &dec->ctx, ctx_size, PIPE_USAGE_DEFAULT)) {
-                       RVID_ERR("Can't allocated context buffer.\n");
-                       goto error;
-               }
-               rvid_clear_buffer(context, &dec->ctx);
-       }
-
        map_msg_fb_it_buf(dec);
        dec->msg->size = sizeof(*dec->msg);
        dec->msg->msg_type = RUVD_MSG_CREATE;