diff --git a/mpp/codec/dec/vp9/vp9d_parser.c b/mpp/codec/dec/vp9/vp9d_parser.c index 8431b0ba..7123445d 100644 --- a/mpp/codec/dec/vp9/vp9d_parser.c +++ b/mpp/codec/dec/vp9/vp9d_parser.c @@ -454,7 +454,7 @@ static RK_S32 inv_recenter_nonneg(RK_S32 v, RK_S32 m) } // differential forward probability updates -static RK_S32 update_prob(VpxRangeCoder *c, RK_S32 p) +static RK_S32 update_prob(VpxRangeCoder *c, RK_S32 p, RK_U8 *delta) { static const RK_S32 inv_map_table[255] = { 7, 20, 33, 46, 59, 72, 85, 98, 111, 124, 137, 150, 163, 176, @@ -507,7 +507,7 @@ static RK_S32 update_prob(VpxRangeCoder *c, RK_S32 p) d += 64; //av_assert2(d < FF_ARRAY_ELEMS(inv_map_table)); } - + *delta = d; return p <= 128 ? 1 + inv_recenter_nonneg(inv_map_table[d], p - 1) : 255 - inv_recenter_nonneg(inv_map_table[d], 255 - p); } @@ -1069,6 +1069,7 @@ static RK_S32 decode_parser_header(Vp9CodecContext *ctx, // as explicit copies if the fw update is missing (and skip the copy upon // fw update)? s->prob.p = s->prob_ctx[c].p; + memset(&s->prob_flag_delta, 0, sizeof(s->prob_flag_delta)); // txfm updates if (s->lossless) { s->txfmmode = TX_4X4; @@ -1080,23 +1081,32 @@ static RK_S32 decode_parser_header(Vp9CodecContext *ctx, if (s->txfmmode == TX_SWITCHABLE) { for (i = 0; i < 2; i++) { - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.tx8p[i] = update_prob(&s->c, s->prob.p.tx8p[i]); + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.tx8p[i] = 1; + s->prob.p.tx8p[i] = update_prob(&s->c, s->prob.p.tx8p[i], + &s->prob_flag_delta.p_delta.tx8p[i]); + } + } for (i = 0; i < 2; i++) for (j = 0; j < 2; j++) { - if (vpx_rac_get_prob_branchy(&s->c, 252)) + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.tx16p[i][j] = 1; s->prob.p.tx16p[i][j] = - update_prob(&s->c, s->prob.p.tx16p[i][j]); + update_prob(&s->c, s->prob.p.tx16p[i][j], + &s->prob_flag_delta.p_delta.tx16p[i][j]); + } } for (i = 0; i < 2; i++) for (j = 0; j < 3; j++) { - if (vpx_rac_get_prob_branchy(&s->c, 252)) + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.tx32p[i][j] = 1; s->prob.p.tx32p[i][j] = - update_prob(&s->c, s->prob.p.tx32p[i][j]); - + update_prob(&s->c, s->prob.p.tx32p[i][j], + &s->prob_flag_delta.p_delta.tx32p[i][j]); + } } } } @@ -1110,17 +1120,20 @@ static RK_S32 decode_parser_header(Vp9CodecContext *ctx, for (l = 0; l < 6; l++) for (m = 0; m < 6; m++) { RK_U8 *p = s->prob.coef[i][j][k][l][m]; + RK_U8 *p_flag = s->prob_flag_delta.coef_flag[i][j][k][l][m]; + RK_U8 *p_delta = s->prob_flag_delta.coef_delta[i][j][k][l][m]; RK_U8 *r = ref[j][k][l][m]; - if (m >= 3 && l == 0) // dc only has 3 pt + if (l == 0 && m >= 3) // dc only has 3 pt break; for (n = 0; n < 3; n++) { if (vpx_rac_get_prob_branchy(&s->c, 252)) { - p[n] = update_prob(&s->c, r[n]); + p_flag[n] = 1; + p[n] = update_prob(&s->c, r[n], &p_delta[n]); } else { + p_flag[n] = 0; p[n] = r[n]; } } - p[3] = 0; } } else { for (j = 0; j < 2; j++) @@ -1129,10 +1142,9 @@ static RK_S32 decode_parser_header(Vp9CodecContext *ctx, for (m = 0; m < 6; m++) { RK_U8 *p = s->prob.coef[i][j][k][l][m]; RK_U8 *r = ref[j][k][l][m]; - if (m > 3 && l == 0) // dc only has 3 pt + if (m >= 3 && l == 0) // dc only has 3 pt break; memcpy(p, r, 3); - p[3] = 0; } } if (s->txfmmode == (RK_U32)i) @@ -1142,28 +1154,42 @@ static RK_S32 decode_parser_header(Vp9CodecContext *ctx, // mode updates for (i = 0; i < 3; i++) { - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.skip[i] = update_prob(&s->c, s->prob.p.skip[i]); + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.skip[i] = 1; + s->prob.p.skip[i] = update_prob(&s->c, s->prob.p.skip[i], + &s->prob_flag_delta.p_delta.skip[i]); + } } if (!s->keyframe && !s->intraonly) { for (i = 0; i < 7; i++) - for (j = 0; j < 3; j++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) + for (j = 0; j < 3; j++) { + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.mv_mode[i][j] = 1; s->prob.p.mv_mode[i][j] = - update_prob(&s->c, s->prob.p.mv_mode[i][j]); + update_prob(&s->c, s->prob.p.mv_mode[i][j], + &s->prob_flag_delta.p_delta.mv_mode[i][j]); + } + } if (s->filtermode == FILTER_SWITCHABLE) for (i = 0; i < 4; i++) - for (j = 0; j < 2; j++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) + for (j = 0; j < 2; j++) { + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.filter[i][j] = 1; s->prob.p.filter[i][j] = - update_prob(&s->c, s->prob.p.filter[i][j]); + update_prob(&s->c, s->prob.p.filter[i][j], + &s->prob_flag_delta.p_delta.filter[i][j]); + } + } for (i = 0; i < 4; i++) { - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.intra[i] = update_prob(&s->c, s->prob.p.intra[i]); + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.intra[i] = 1; + s->prob.p.intra[i] = update_prob(&s->c, s->prob.p.intra[i], + &s->prob_flag_delta.p_delta.intra[i]); + } } @@ -1172,90 +1198,135 @@ static RK_S32 decode_parser_header(Vp9CodecContext *ctx, if (s->comppredmode) s->comppredmode += vpx_rac_get(&s->c); if (s->comppredmode == PRED_SWITCHABLE) - for (i = 0; i < 5; i++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) + for (i = 0; i < 5; i++) { + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.comp[i] = 1; s->prob.p.comp[i] = - update_prob(&s->c, s->prob.p.comp[i]); + update_prob(&s->c, s->prob.p.comp[i], + &s->prob_flag_delta.p_delta.comp[i]); + } + } } else { s->comppredmode = PRED_SINGLEREF; } if (s->comppredmode != PRED_COMPREF) { for (i = 0; i < 5; i++) { - if (vpx_rac_get_prob_branchy(&s->c, 252)) + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.single_ref[i][0] = 1; s->prob.p.single_ref[i][0] = - update_prob(&s->c, s->prob.p.single_ref[i][0]); - if (vpx_rac_get_prob_branchy(&s->c, 252)) + update_prob(&s->c, s->prob.p.single_ref[i][0], + &s->prob_flag_delta.p_delta.single_ref[i][0]); + } + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.single_ref[i][1] = 1; s->prob.p.single_ref[i][1] = - update_prob(&s->c, s->prob.p.single_ref[i][1]); + update_prob(&s->c, s->prob.p.single_ref[i][1], + &s->prob_flag_delta.p_delta.single_ref[i][1]); + } } } if (s->comppredmode != PRED_SINGLEREF) { - for (i = 0; i < 5; i++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) + for (i = 0; i < 5; i++) { + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.comp_ref[i] = 1; s->prob.p.comp_ref[i] = - update_prob(&s->c, s->prob.p.comp_ref[i]); + update_prob(&s->c, s->prob.p.comp_ref[i], + &s->prob_flag_delta.p_delta.comp_ref[i]); + } + } } for (i = 0; i < 4; i++) - for (j = 0; j < 9; j++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) + for (j = 0; j < 9; j++) { + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.y_mode[i][j] = 1; s->prob.p.y_mode[i][j] = - update_prob(&s->c, s->prob.p.y_mode[i][j]); - + update_prob(&s->c, s->prob.p.y_mode[i][j], + &s->prob_flag_delta.p_delta.y_mode[i][j]); + } + } for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) - for (k = 0; k < 3; k++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) + for (k = 0; k < 3; k++) { + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.partition[3 - i][j][k] = 1; s->prob.p.partition[3 - i][j][k] = - update_prob(&s->c, s->prob.p.partition[3 - i][j][k]); + update_prob(&s->c, s->prob.p.partition[3 - i][j][k], + &s->prob_flag_delta.p_delta.partition[3 - i][j][k]); + } + } + // mv fields don't use the update_prob subexp model for some reason - for (i = 0; i < 3; i++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.mv_joint[i] = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + for (i = 0; i < 3; i++) { + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.mv_joint[i] = 1; + s->prob_flag_delta.p_delta.mv_joint[i] = + s->prob.p.mv_joint[i] = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + } + } for (i = 0; i < 2; i++) { - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.mv_comp[i].sign = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.mv_comp[i].sign = 1; + s->prob_flag_delta.p_delta.mv_comp[i].sign = + s->prob.p.mv_comp[i].sign = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + } for (j = 0; j < 10; j++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.mv_comp[i].classes[j] = - (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.mv_comp[i].classes[j] = 1; + s->prob_flag_delta.p_delta.mv_comp[i].classes[j] = + s->prob.p.mv_comp[i].classes[j] = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + } - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.mv_comp[i].class0 = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.mv_comp[i].class0 = 1; + s->prob_flag_delta.p_delta.mv_comp[i].class0 = + s->prob.p.mv_comp[i].class0 = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + } for (j = 0; j < 10; j++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.mv_comp[i].bits[j] = - (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.mv_comp[i].bits[j] = 1; + s->prob_flag_delta.p_delta.mv_comp[i].bits[j] = + s->prob.p.mv_comp[i].bits[j] = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + } } for (i = 0; i < 2; i++) { for (j = 0; j < 2; j++) for (k = 0; k < 3; k++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.mv_comp[i].class0_fp[j][k] = - (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.mv_comp[i].class0_fp[j][k] = 1; + s->prob_flag_delta.p_delta.mv_comp[i].class0_fp[j][k] = + s->prob.p.mv_comp[i].class0_fp[j][k] = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + } for (j = 0; j < 3; j++) - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.mv_comp[i].fp[j] = - (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.mv_comp[i].fp[j] = 1; + s->prob_flag_delta.p_delta.mv_comp[i].fp[j] = + s->prob.p.mv_comp[i].fp[j] = + (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + } } if (s->highprecisionmvs) { for (i = 0; i < 2; i++) { - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.mv_comp[i].class0_hp = - (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.mv_comp[i].class0_hp = 1; + s->prob_flag_delta.p_delta.mv_comp[i].class0_hp = + s->prob.p.mv_comp[i].class0_hp = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + } - if (vpx_rac_get_prob_branchy(&s->c, 252)) - s->prob.p.mv_comp[i].hp = - (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + if (vpx_rac_get_prob_branchy(&s->c, 252)) { + s->prob_flag_delta.p_flag.mv_comp[i].hp = 1; + s->prob_flag_delta.p_delta.mv_comp[i].hp = + s->prob.p.mv_comp[i].hp = (vpx_rac_get_uint(&s->c, 7) << 1) | 1; + } } } } diff --git a/mpp/codec/dec/vp9/vp9d_parser.h b/mpp/codec/dec/vp9/vp9d_parser.h index 056667a9..ae5a151d 100644 --- a/mpp/codec/dec/vp9/vp9d_parser.h +++ b/mpp/codec/dec/vp9/vp9d_parser.h @@ -188,10 +188,16 @@ typedef struct VP9Context { } prob_ctx[4]; struct { prob_context p; - RK_U8 coef[4][2][2][6][6][11]; + RK_U8 coef[4][2][2][6][6][3]; RK_U8 seg[7]; RK_U8 segpred[3]; } prob; + struct { + prob_context p_flag; + prob_context p_delta; + RK_U8 coef_flag[4][2][2][6][6][3]; + RK_U8 coef_delta[4][2][2][6][6][3]; + } prob_flag_delta; struct { RK_U32 partition[4][4][4]; RK_U32 skip[3][2]; diff --git a/mpp/codec/dec/vp9/vp9d_parser2_syntax.c b/mpp/codec/dec/vp9/vp9d_parser2_syntax.c index 8ac3deb3..1df60ee0 100644 --- a/mpp/codec/dec/vp9/vp9d_parser2_syntax.c +++ b/mpp/codec/dec/vp9/vp9d_parser2_syntax.c @@ -3,6 +3,29 @@ #include "vp9d_parser.h" #include "vp9d_syntax.h" +#define TRANS_TO_HW_STYLE(uv_mode) \ +do{ \ + RK_U8 *uv_ptr = NULL; \ + RK_U8 uv_mode_prob[10][9]; \ + for (i = 0; i < 10; i++) { \ + if (i == 0) { \ + uv_ptr = uv_mode[2]; \ + } else if ( i == 1) { \ + uv_ptr = uv_mode[0]; \ + } else if ( i == 2) { \ + uv_ptr = uv_mode[1]; \ + } else if ( i == 7) { \ + uv_ptr = uv_mode[8]; \ + } else if (i == 8) { \ + uv_ptr = uv_mode[7]; \ + } else { \ + uv_ptr = uv_mode[i]; \ + } \ + memcpy(&uv_mode_prob[i], uv_ptr, 9); \ + } \ + memcpy(uv_mode, uv_mode_prob, sizeof(uv_mode_prob)); \ +}while(0) + static int vp9d_fill_segmentation(VP9Context *s, DXVA_segmentation_VP9 *seg) { int i; @@ -49,7 +72,10 @@ static int vp9d_fill_picparams(Vp9CodecContext *ctx, DXVA_PicParams_VP9 *pic) { VP9Context *s = ctx->priv_data; RK_U8 partition_probs[16][3]; - RK_U8 uv_mode_prob[10][9]; + RK_U8 partition_probs_flag[16][3]; + RK_U8 partition_probs_delata[16][3]; + DXVA_prob_vp9* prob_flag = &pic->prob_flag_delta.p_flag; + DXVA_prob_vp9* prob_delta = &pic->prob_flag_delta.p_delta; int i; pic->profile = ctx->profile; @@ -105,10 +131,9 @@ static int vp9d_fill_picparams(Vp9CodecContext *ctx, DXVA_PicParams_VP9 *pic) pic->log2_tile_rows = s->tiling.log2_tile_rows; pic->first_partition_size = s->first_partition_size; memcpy(pic->mvscale, s->mvscale, sizeof(s->mvscale)); - memcpy(&ctx->pic_params.prob, &s->prob, sizeof(ctx->pic_params.prob)); + memcpy(&pic->prob, &s->prob, sizeof(pic->prob)); + memcpy(&pic->prob_flag_delta, &s->prob_flag_delta, sizeof(pic->prob_flag_delta)); { - RK_U8 *uv_ptr = NULL; - RK_U32 m = 0; /*change partition to hardware need style*/ /* hardware syntax @@ -117,11 +142,20 @@ static int vp9d_fill_picparams(Vp9CodecContext *ctx, DXVA_PicParams_VP9 *pic) *+++++32x32+++* *++++16x16++++* *+++++64x64+++* *++++8x8++++++* */ - m = 0; - for (i = 3; i >= 0; i--) { - memcpy(&partition_probs[m][0], &ctx->pic_params.prob.partition[i][0][0], 12); - m += 4; + RK_U32 m = 0; + RK_U32 len = sizeof(pic->prob.partition[0]); + RK_U32 step = len / sizeof(partition_probs[0]); + + for (i = MPP_ARRAY_ELEMS(pic->prob.partition) - 1; i >= 0; i--) { + memcpy(&partition_probs[m][0], &pic->prob.partition[i][0][0], len); + memcpy(&partition_probs_flag[m][0], &prob_flag->partition[i][0][0], len); + memcpy(&partition_probs_delata[m][0], &prob_delta->partition[i][0][0], len); + m += step; } + memcpy(pic->prob.partition, partition_probs, sizeof(partition_probs)); + memcpy(prob_flag->partition, partition_probs_flag, sizeof(partition_probs_flag)); + memcpy(prob_delta->partition, partition_probs_delata, sizeof(partition_probs_delata)); + /*change uv_mode to hardware need style*/ /* hardware syntax @@ -137,24 +171,9 @@ static int vp9d_fill_picparams(Vp9CodecContext *ctx, DXVA_PicParams_VP9 *pic) *+++++ tm ++++* *++++ tm ++++* */ - for (i = 0; i < 10; i++) { - if (i == 0) { - uv_ptr = ctx->pic_params.prob.uv_mode[2];//dc - } else if ( i == 1) { - uv_ptr = ctx->pic_params.prob.uv_mode[0]; //h - } else if ( i == 2) { - uv_ptr = ctx->pic_params.prob.uv_mode[1]; //h - } else if ( i == 7) { - uv_ptr = ctx->pic_params.prob.uv_mode[8]; //d207 - } else if (i == 8) { - uv_ptr = ctx->pic_params.prob.uv_mode[7]; //d63 - } else { - uv_ptr = ctx->pic_params.prob.uv_mode[i]; - } - memcpy(&uv_mode_prob[i], uv_ptr, 9); - } - memcpy(ctx->pic_params.prob.partition, partition_probs, sizeof(partition_probs)); - memcpy(ctx->pic_params.prob.uv_mode, uv_mode_prob, sizeof(uv_mode_prob)); + TRANS_TO_HW_STYLE(pic->prob.uv_mode); + TRANS_TO_HW_STYLE(prob_flag->uv_mode); + TRANS_TO_HW_STYLE(prob_delta->uv_mode); } return 0; } diff --git a/mpp/common/vp9d_syntax.h b/mpp/common/vp9d_syntax.h index 9691c512..31bc130a 100644 --- a/mpp/common/vp9d_syntax.h +++ b/mpp/common/vp9d_syntax.h @@ -60,6 +60,33 @@ typedef struct _segmentation_VP9 { UCHAR feature_mask[8]; } DXVA_segmentation_VP9; +typedef struct { + RK_U8 y_mode[4][9]; + RK_U8 uv_mode[10][9]; + RK_U8 filter[4][2]; + RK_U8 mv_mode[7][3]; + RK_U8 intra[4]; + RK_U8 comp[5]; + RK_U8 single_ref[5][2]; + RK_U8 comp_ref[5]; + RK_U8 tx32p[2][3]; + RK_U8 tx16p[2][2]; + RK_U8 tx8p[2]; + RK_U8 skip[3]; + RK_U8 mv_joint[3]; + struct { + RK_U8 sign; + RK_U8 classes[10]; + RK_U8 class0; + RK_U8 bits[10]; + RK_U8 class0_fp[2][3]; + RK_U8 fp[3]; + RK_U8 class0_hp; + RK_U8 hp; + } mv_comp[2]; + RK_U8 partition[4][4][3]; +} DXVA_prob_vp9; + typedef struct _DXVA_PicParams_VP9 { DXVA_PicEntry_VPx CurrPic; UCHAR profile; @@ -142,7 +169,7 @@ typedef struct _DXVA_PicParams_VP9 { UCHAR hp; } mv_comp[2]; UCHAR partition[4][4][3]; - UCHAR coef[4][2][2][6][6][11]; + UCHAR coef[4][2][2][6][6][3]; } prob; struct { UINT partition[4][4][4]; @@ -170,6 +197,12 @@ typedef struct _DXVA_PicParams_VP9 { UINT coef[4][2][2][6][6][3]; UINT eob[4][2][2][6][6][2]; } counts; + struct { + DXVA_prob_vp9 p_flag; + DXVA_prob_vp9 p_delta; + RK_U8 coef_flag[4][2][2][6][6][3]; + RK_U8 coef_delta[4][2][2][6][6][3]; + } prob_flag_delta; USHORT mvscale[3][2]; CHAR txmode; CHAR refmode; diff --git a/mpp/hal/rkdec/inc/vdpu34x_vp9d.h b/mpp/hal/rkdec/inc/vdpu34x_vp9d.h index 5624acd1..cba80b43 100644 --- a/mpp/hal/rkdec/inc/vdpu34x_vp9d.h +++ b/mpp/hal/rkdec/inc/vdpu34x_vp9d.h @@ -228,7 +228,7 @@ typedef struct Vdpu34xRegVp9dAddr_t { RK_U32 reg161_pps_base; - RK_U32 reg162_last_porb_base; + RK_U32 reg162_last_prob_base; RK_U32 reg163_rps_base; @@ -250,7 +250,6 @@ typedef struct Vdpu34xRegVp9dAddr_t { RK_U32 reg172_update_prob_wr_base; - RK_U32 reg173_179_no_use[7]; RK_U32 reg180_scanlist_base; diff --git a/mpp/hal/rkdec/vp9d/hal_vp9d_com.c b/mpp/hal/rkdec/vp9d/hal_vp9d_com.c index c907d674..571cccb9 100644 --- a/mpp/hal/rkdec/vp9d/hal_vp9d_com.c +++ b/mpp/hal/rkdec/vp9d/hal_vp9d_com.c @@ -22,6 +22,822 @@ #include "vp9d_syntax.h" #include "hal_vp9d_com.h" +typedef struct { + RK_U8 y_mode[4][9]; + RK_U8 uv_mode[10][9]; + RK_U8 filter[4][2]; + RK_U8 mv_mode[7][3]; + RK_U8 intra[4]; + RK_U8 comp[5]; + RK_U8 single_ref[5][2]; + RK_U8 comp_ref[5]; + RK_U8 tx32p[2][3]; + RK_U8 tx16p[2][2]; + RK_U8 tx8p[2]; + RK_U8 skip[3]; + RK_U8 mv_joint[3]; + struct { + RK_U8 sign; + RK_U8 classes[10]; + RK_U8 class0; + RK_U8 bits[10]; + RK_U8 class0_fp[2][3]; + RK_U8 fp[3]; + RK_U8 class0_hp; + RK_U8 hp; + } mv_comp[2]; + RK_U8 partition[4][4][3]; +} prob_context; + +static const prob_context vp9_default_probs = { + { /* y_mode */ + { 65, 32, 18, 144, 162, 194, 41, 51, 98 } /* bsize < 8x8 */, + { 132, 68, 18, 165, 217, 196, 45, 40, 78 } /* bsize < 16x16 */, + { 173, 80, 19, 176, 240, 193, 64, 35, 46 } /* bsize < 32x32 */, + { 221, 135, 38, 194, 248, 121, 96, 85, 29 } /* bsize >= 32x32 */ + }, { /* uv_mode */ + { 48, 12, 154, 155, 139, 90, 34, 117, 119 } /* y = v */, + { 67, 6, 25, 204, 243, 158, 13, 21, 96 } /* y = h */, + { 120, 7, 76, 176, 208, 126, 28, 54, 103 } /* y = dc */, + { 97, 5, 44, 131, 176, 139, 48, 68, 97 } /* y = d45 */, + { 83, 5, 42, 156, 111, 152, 26, 49, 152 } /* y = d135 */, + { 80, 5, 58, 178, 74, 83, 33, 62, 145 } /* y = d117 */, + { 86, 5, 32, 154, 192, 168, 14, 22, 163 } /* y = d153 */, + { 77, 7, 64, 116, 132, 122, 37, 126, 120 } /* y = d63 */, + { 85, 5, 32, 156, 216, 148, 19, 29, 73 } /* y = d207 */, + { 101, 21, 107, 181, 192, 103, 19, 67, 125 } /* y = tm */ + }, { /* filter */ + { 235, 162, }, + { 36, 255, }, + { 34, 3, }, + { 149, 144, }, + }, { /* mv_mode */ + { 2, 173, 34}, // 0 = both zero mv + { 7, 145, 85}, // 1 = one zero mv + one a predicted mv + { 7, 166, 63}, // 2 = two predicted mvs + { 7, 94, 66}, // 3 = one predicted/zero and one new mv + { 8, 64, 46}, // 4 = two new mvs + { 17, 81, 31}, // 5 = one intra neighbour + x + { 25, 29, 30}, // 6 = two intra neighbours + }, { /* intra */ + 9, 102, 187, 225 + }, { /* comp */ + 239, 183, 119, 96, 41 + }, { /* single_ref */ + { 33, 16 }, + { 77, 74 }, + { 142, 142 }, + { 172, 170 }, + { 238, 247 } + }, { /* comp_ref */ + 50, 126, 123, 221, 226 + }, { /* tx32p */ + { 3, 136, 37, }, + { 5, 52, 13, }, + }, { /* tx16p */ + { 20, 152, }, + { 15, 101, }, + }, { /* tx8p */ + 100, 66 + }, { /* skip */ + 192, 128, 64 + }, { /* mv_joint */ + 32, 64, 96 + }, { + { /* mv vertical component */ + 128, /* sign */ + { 224, 144, 192, 168, 192, 176, 192, 198, 198, 245 }, /* class */ + 216, /* class0 */ + { 136, 140, 148, 160, 176, 192, 224, 234, 234, 240}, /* bits */ + { /* class0_fp */ + { 128, 128, 64 }, + { 96, 112, 64 } + }, + { 64, 96, 64 }, /* fp */ + 160, /* class0_hp bit */ + 128, /* hp */ + }, { /* mv horizontal component */ + 128, /* sign */ + { 216, 128, 176, 160, 176, 176, 192, 198, 198, 208 }, /* class */ + 208, /* class0 */ + { 136, 140, 148, 160, 176, 192, 224, 234, 234, 240 }, /* bits */ + { /* class0_fp */ + { 128, 128, 64 }, + { 96, 112, 64 } + }, + { 64, 96, 64 }, /* fp */ + 160, /* class0_hp bit */ + 128, /* hp */ + } + }, { /* partition */ + { /* 64x64 -> 32x32 */ + { 222, 34, 30 } /* a/l both not split */, + { 72, 16, 44 } /* a split, l not split */, + { 58, 32, 12 } /* l split, a not split */, + { 10, 7, 6 } /* a/l both split */, + }, { /* 32x32 -> 16x16 */ + { 177, 58, 59 } /* a/l both not split */, + { 68, 26, 63 } /* a split, l not split */, + { 52, 79, 25 } /* l split, a not split */, + { 17, 14, 12 } /* a/l both split */, + }, { /* 16x16 -> 8x8 */ + { 174, 73, 87 } /* a/l both not split */, + { 92, 41, 83 } /* a split, l not split */, + { 82, 99, 50 } /* l split, a not split */, + { 53, 39, 39 } /* a/l both split */, + }, { /* 8x8 -> 4x4 */ + { 199, 122, 141 } /* a/l both not split */, + { 147, 63, 159 } /* a split, l not split */, + { 148, 133, 118 } /* l split, a not split */, + { 121, 104, 114 } /* a/l both split */, + } + }, +}; + +static const RK_U8 vp9_default_coef_probs[4][2][2][6][6][3] = { + { /* tx = 4x4 */ + { /* block Type 0 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 195, 29, 183 }, + { 84, 49, 136 }, + { 8, 42, 71 } + }, { /* Coeff Band 1 */ + { 31, 107, 169 }, + { 35, 99, 159 }, + { 17, 82, 140 }, + { 8, 66, 114 }, + { 2, 44, 76 }, + { 1, 19, 32 } + }, { /* Coeff Band 2 */ + { 40, 132, 201 }, + { 29, 114, 187 }, + { 13, 91, 157 }, + { 7, 75, 127 }, + { 3, 58, 95 }, + { 1, 28, 47 } + }, { /* Coeff Band 3 */ + { 69, 142, 221 }, + { 42, 122, 201 }, + { 15, 91, 159 }, + { 6, 67, 121 }, + { 1, 42, 77 }, + { 1, 17, 31 } + }, { /* Coeff Band 4 */ + { 102, 148, 228 }, + { 67, 117, 204 }, + { 17, 82, 154 }, + { 6, 59, 114 }, + { 2, 39, 75 }, + { 1, 15, 29 } + }, { /* Coeff Band 5 */ + { 156, 57, 233 }, + { 119, 57, 212 }, + { 58, 48, 163 }, + { 29, 40, 124 }, + { 12, 30, 81 }, + { 3, 12, 31 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 191, 107, 226 }, + { 124, 117, 204 }, + { 25, 99, 155 } + }, { /* Coeff Band 1 */ + { 29, 148, 210 }, + { 37, 126, 194 }, + { 8, 93, 157 }, + { 2, 68, 118 }, + { 1, 39, 69 }, + { 1, 17, 33 } + }, { /* Coeff Band 2 */ + { 41, 151, 213 }, + { 27, 123, 193 }, + { 3, 82, 144 }, + { 1, 58, 105 }, + { 1, 32, 60 }, + { 1, 13, 26 } + }, { /* Coeff Band 3 */ + { 59, 159, 220 }, + { 23, 126, 198 }, + { 4, 88, 151 }, + { 1, 66, 114 }, + { 1, 38, 71 }, + { 1, 18, 34 } + }, { /* Coeff Band 4 */ + { 114, 136, 232 }, + { 51, 114, 207 }, + { 11, 83, 155 }, + { 3, 56, 105 }, + { 1, 33, 65 }, + { 1, 17, 34 } + }, { /* Coeff Band 5 */ + { 149, 65, 234 }, + { 121, 57, 215 }, + { 61, 49, 166 }, + { 28, 36, 114 }, + { 12, 25, 76 }, + { 3, 16, 42 } + } + } + }, { /* block Type 1 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 214, 49, 220 }, + { 132, 63, 188 }, + { 42, 65, 137 } + }, { /* Coeff Band 1 */ + { 85, 137, 221 }, + { 104, 131, 216 }, + { 49, 111, 192 }, + { 21, 87, 155 }, + { 2, 49, 87 }, + { 1, 16, 28 } + }, { /* Coeff Band 2 */ + { 89, 163, 230 }, + { 90, 137, 220 }, + { 29, 100, 183 }, + { 10, 70, 135 }, + { 2, 42, 81 }, + { 1, 17, 33 } + }, { /* Coeff Band 3 */ + { 108, 167, 237 }, + { 55, 133, 222 }, + { 15, 97, 179 }, + { 4, 72, 135 }, + { 1, 45, 85 }, + { 1, 19, 38 } + }, { /* Coeff Band 4 */ + { 124, 146, 240 }, + { 66, 124, 224 }, + { 17, 88, 175 }, + { 4, 58, 122 }, + { 1, 36, 75 }, + { 1, 18, 37 } + }, { /* Coeff Band 5 */ + { 141, 79, 241 }, + { 126, 70, 227 }, + { 66, 58, 182 }, + { 30, 44, 136 }, + { 12, 34, 96 }, + { 2, 20, 47 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 229, 99, 249 }, + { 143, 111, 235 }, + { 46, 109, 192 } + }, { /* Coeff Band 1 */ + { 82, 158, 236 }, + { 94, 146, 224 }, + { 25, 117, 191 }, + { 9, 87, 149 }, + { 3, 56, 99 }, + { 1, 33, 57 } + }, { /* Coeff Band 2 */ + { 83, 167, 237 }, + { 68, 145, 222 }, + { 10, 103, 177 }, + { 2, 72, 131 }, + { 1, 41, 79 }, + { 1, 20, 39 } + }, { /* Coeff Band 3 */ + { 99, 167, 239 }, + { 47, 141, 224 }, + { 10, 104, 178 }, + { 2, 73, 133 }, + { 1, 44, 85 }, + { 1, 22, 47 } + }, { /* Coeff Band 4 */ + { 127, 145, 243 }, + { 71, 129, 228 }, + { 17, 93, 177 }, + { 3, 61, 124 }, + { 1, 41, 84 }, + { 1, 21, 52 } + }, { /* Coeff Band 5 */ + { 157, 78, 244 }, + { 140, 72, 231 }, + { 69, 58, 184 }, + { 31, 44, 137 }, + { 14, 38, 105 }, + { 8, 23, 61 } + } + } + } + }, { /* tx = 8x8 */ + { /* block Type 0 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 125, 34, 187 }, + { 52, 41, 133 }, + { 6, 31, 56 } + }, { /* Coeff Band 1 */ + { 37, 109, 153 }, + { 51, 102, 147 }, + { 23, 87, 128 }, + { 8, 67, 101 }, + { 1, 41, 63 }, + { 1, 19, 29 } + }, { /* Coeff Band 2 */ + { 31, 154, 185 }, + { 17, 127, 175 }, + { 6, 96, 145 }, + { 2, 73, 114 }, + { 1, 51, 82 }, + { 1, 28, 45 } + }, { /* Coeff Band 3 */ + { 23, 163, 200 }, + { 10, 131, 185 }, + { 2, 93, 148 }, + { 1, 67, 111 }, + { 1, 41, 69 }, + { 1, 14, 24 } + }, { /* Coeff Band 4 */ + { 29, 176, 217 }, + { 12, 145, 201 }, + { 3, 101, 156 }, + { 1, 69, 111 }, + { 1, 39, 63 }, + { 1, 14, 23 } + }, { /* Coeff Band 5 */ + { 57, 192, 233 }, + { 25, 154, 215 }, + { 6, 109, 167 }, + { 3, 78, 118 }, + { 1, 48, 69 }, + { 1, 21, 29 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 202, 105, 245 }, + { 108, 106, 216 }, + { 18, 90, 144 } + }, { /* Coeff Band 1 */ + { 33, 172, 219 }, + { 64, 149, 206 }, + { 14, 117, 177 }, + { 5, 90, 141 }, + { 2, 61, 95 }, + { 1, 37, 57 } + }, { /* Coeff Band 2 */ + { 33, 179, 220 }, + { 11, 140, 198 }, + { 1, 89, 148 }, + { 1, 60, 104 }, + { 1, 33, 57 }, + { 1, 12, 21 } + }, { /* Coeff Band 3 */ + { 30, 181, 221 }, + { 8, 141, 198 }, + { 1, 87, 145 }, + { 1, 58, 100 }, + { 1, 31, 55 }, + { 1, 12, 20 } + }, { /* Coeff Band 4 */ + { 32, 186, 224 }, + { 7, 142, 198 }, + { 1, 86, 143 }, + { 1, 58, 100 }, + { 1, 31, 55 }, + { 1, 12, 22 } + }, { /* Coeff Band 5 */ + { 57, 192, 227 }, + { 20, 143, 204 }, + { 3, 96, 154 }, + { 1, 68, 112 }, + { 1, 42, 69 }, + { 1, 19, 32 } + } + } + }, { /* block Type 1 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 212, 35, 215 }, + { 113, 47, 169 }, + { 29, 48, 105 } + }, { /* Coeff Band 1 */ + { 74, 129, 203 }, + { 106, 120, 203 }, + { 49, 107, 178 }, + { 19, 84, 144 }, + { 4, 50, 84 }, + { 1, 15, 25 } + }, { /* Coeff Band 2 */ + { 71, 172, 217 }, + { 44, 141, 209 }, + { 15, 102, 173 }, + { 6, 76, 133 }, + { 2, 51, 89 }, + { 1, 24, 42 } + }, { /* Coeff Band 3 */ + { 64, 185, 231 }, + { 31, 148, 216 }, + { 8, 103, 175 }, + { 3, 74, 131 }, + { 1, 46, 81 }, + { 1, 18, 30 } + }, { /* Coeff Band 4 */ + { 65, 196, 235 }, + { 25, 157, 221 }, + { 5, 105, 174 }, + { 1, 67, 120 }, + { 1, 38, 69 }, + { 1, 15, 30 } + }, { /* Coeff Band 5 */ + { 65, 204, 238 }, + { 30, 156, 224 }, + { 7, 107, 177 }, + { 2, 70, 124 }, + { 1, 42, 73 }, + { 1, 18, 34 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 225, 86, 251 }, + { 144, 104, 235 }, + { 42, 99, 181 } + }, { /* Coeff Band 1 */ + { 85, 175, 239 }, + { 112, 165, 229 }, + { 29, 136, 200 }, + { 12, 103, 162 }, + { 6, 77, 123 }, + { 2, 53, 84 } + }, { /* Coeff Band 2 */ + { 75, 183, 239 }, + { 30, 155, 221 }, + { 3, 106, 171 }, + { 1, 74, 128 }, + { 1, 44, 76 }, + { 1, 17, 28 } + }, { /* Coeff Band 3 */ + { 73, 185, 240 }, + { 27, 159, 222 }, + { 2, 107, 172 }, + { 1, 75, 127 }, + { 1, 42, 73 }, + { 1, 17, 29 } + }, { /* Coeff Band 4 */ + { 62, 190, 238 }, + { 21, 159, 222 }, + { 2, 107, 172 }, + { 1, 72, 122 }, + { 1, 40, 71 }, + { 1, 18, 32 } + }, { /* Coeff Band 5 */ + { 61, 199, 240 }, + { 27, 161, 226 }, + { 4, 113, 180 }, + { 1, 76, 129 }, + { 1, 46, 80 }, + { 1, 23, 41 } + } + } + } + }, { /* tx = 16x16 */ + { /* block Type 0 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 7, 27, 153 }, + { 5, 30, 95 }, + { 1, 16, 30 } + }, { /* Coeff Band 1 */ + { 50, 75, 127 }, + { 57, 75, 124 }, + { 27, 67, 108 }, + { 10, 54, 86 }, + { 1, 33, 52 }, + { 1, 12, 18 } + }, { /* Coeff Band 2 */ + { 43, 125, 151 }, + { 26, 108, 148 }, + { 7, 83, 122 }, + { 2, 59, 89 }, + { 1, 38, 60 }, + { 1, 17, 27 } + }, { /* Coeff Band 3 */ + { 23, 144, 163 }, + { 13, 112, 154 }, + { 2, 75, 117 }, + { 1, 50, 81 }, + { 1, 31, 51 }, + { 1, 14, 23 } + }, { /* Coeff Band 4 */ + { 18, 162, 185 }, + { 6, 123, 171 }, + { 1, 78, 125 }, + { 1, 51, 86 }, + { 1, 31, 54 }, + { 1, 14, 23 } + }, { /* Coeff Band 5 */ + { 15, 199, 227 }, + { 3, 150, 204 }, + { 1, 91, 146 }, + { 1, 55, 95 }, + { 1, 30, 53 }, + { 1, 11, 20 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 19, 55, 240 }, + { 19, 59, 196 }, + { 3, 52, 105 } + }, { /* Coeff Band 1 */ + { 41, 166, 207 }, + { 104, 153, 199 }, + { 31, 123, 181 }, + { 14, 101, 152 }, + { 5, 72, 106 }, + { 1, 36, 52 } + }, { /* Coeff Band 2 */ + { 35, 176, 211 }, + { 12, 131, 190 }, + { 2, 88, 144 }, + { 1, 60, 101 }, + { 1, 36, 60 }, + { 1, 16, 28 } + }, { /* Coeff Band 3 */ + { 28, 183, 213 }, + { 8, 134, 191 }, + { 1, 86, 142 }, + { 1, 56, 96 }, + { 1, 30, 53 }, + { 1, 12, 20 } + }, { /* Coeff Band 4 */ + { 20, 190, 215 }, + { 4, 135, 192 }, + { 1, 84, 139 }, + { 1, 53, 91 }, + { 1, 28, 49 }, + { 1, 11, 20 } + }, { /* Coeff Band 5 */ + { 13, 196, 216 }, + { 2, 137, 192 }, + { 1, 86, 143 }, + { 1, 57, 99 }, + { 1, 32, 56 }, + { 1, 13, 24 } + } + } + }, { /* block Type 1 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 211, 29, 217 }, + { 96, 47, 156 }, + { 22, 43, 87 } + }, { /* Coeff Band 1 */ + { 78, 120, 193 }, + { 111, 116, 186 }, + { 46, 102, 164 }, + { 15, 80, 128 }, + { 2, 49, 76 }, + { 1, 18, 28 } + }, { /* Coeff Band 2 */ + { 71, 161, 203 }, + { 42, 132, 192 }, + { 10, 98, 150 }, + { 3, 69, 109 }, + { 1, 44, 70 }, + { 1, 18, 29 } + }, { /* Coeff Band 3 */ + { 57, 186, 211 }, + { 30, 140, 196 }, + { 4, 93, 146 }, + { 1, 62, 102 }, + { 1, 38, 65 }, + { 1, 16, 27 } + }, { /* Coeff Band 4 */ + { 47, 199, 217 }, + { 14, 145, 196 }, + { 1, 88, 142 }, + { 1, 57, 98 }, + { 1, 36, 62 }, + { 1, 15, 26 } + }, { /* Coeff Band 5 */ + { 26, 219, 229 }, + { 5, 155, 207 }, + { 1, 94, 151 }, + { 1, 60, 104 }, + { 1, 36, 62 }, + { 1, 16, 28 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 233, 29, 248 }, + { 146, 47, 220 }, + { 43, 52, 140 } + }, { /* Coeff Band 1 */ + { 100, 163, 232 }, + { 179, 161, 222 }, + { 63, 142, 204 }, + { 37, 113, 174 }, + { 26, 89, 137 }, + { 18, 68, 97 } + }, { /* Coeff Band 2 */ + { 85, 181, 230 }, + { 32, 146, 209 }, + { 7, 100, 164 }, + { 3, 71, 121 }, + { 1, 45, 77 }, + { 1, 18, 30 } + }, { /* Coeff Band 3 */ + { 65, 187, 230 }, + { 20, 148, 207 }, + { 2, 97, 159 }, + { 1, 68, 116 }, + { 1, 40, 70 }, + { 1, 14, 29 } + }, { /* Coeff Band 4 */ + { 40, 194, 227 }, + { 8, 147, 204 }, + { 1, 94, 155 }, + { 1, 65, 112 }, + { 1, 39, 66 }, + { 1, 14, 26 } + }, { /* Coeff Band 5 */ + { 16, 208, 228 }, + { 3, 151, 207 }, + { 1, 98, 160 }, + { 1, 67, 117 }, + { 1, 41, 74 }, + { 1, 17, 31 } + } + } + } + }, { /* tx = 32x32 */ + { /* block Type 0 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 17, 38, 140 }, + { 7, 34, 80 }, + { 1, 17, 29 } + }, { /* Coeff Band 1 */ + { 37, 75, 128 }, + { 41, 76, 128 }, + { 26, 66, 116 }, + { 12, 52, 94 }, + { 2, 32, 55 }, + { 1, 10, 16 } + }, { /* Coeff Band 2 */ + { 50, 127, 154 }, + { 37, 109, 152 }, + { 16, 82, 121 }, + { 5, 59, 85 }, + { 1, 35, 54 }, + { 1, 13, 20 } + }, { /* Coeff Band 3 */ + { 40, 142, 167 }, + { 17, 110, 157 }, + { 2, 71, 112 }, + { 1, 44, 72 }, + { 1, 27, 45 }, + { 1, 11, 17 } + }, { /* Coeff Band 4 */ + { 30, 175, 188 }, + { 9, 124, 169 }, + { 1, 74, 116 }, + { 1, 48, 78 }, + { 1, 30, 49 }, + { 1, 11, 18 } + }, { /* Coeff Band 5 */ + { 10, 222, 223 }, + { 2, 150, 194 }, + { 1, 83, 128 }, + { 1, 48, 79 }, + { 1, 27, 45 }, + { 1, 11, 17 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 36, 41, 235 }, + { 29, 36, 193 }, + { 10, 27, 111 } + }, { /* Coeff Band 1 */ + { 85, 165, 222 }, + { 177, 162, 215 }, + { 110, 135, 195 }, + { 57, 113, 168 }, + { 23, 83, 120 }, + { 10, 49, 61 } + }, { /* Coeff Band 2 */ + { 85, 190, 223 }, + { 36, 139, 200 }, + { 5, 90, 146 }, + { 1, 60, 103 }, + { 1, 38, 65 }, + { 1, 18, 30 } + }, { /* Coeff Band 3 */ + { 72, 202, 223 }, + { 23, 141, 199 }, + { 2, 86, 140 }, + { 1, 56, 97 }, + { 1, 36, 61 }, + { 1, 16, 27 } + }, { /* Coeff Band 4 */ + { 55, 218, 225 }, + { 13, 145, 200 }, + { 1, 86, 141 }, + { 1, 57, 99 }, + { 1, 35, 61 }, + { 1, 13, 22 } + }, { /* Coeff Band 5 */ + { 15, 235, 212 }, + { 1, 132, 184 }, + { 1, 84, 139 }, + { 1, 57, 97 }, + { 1, 34, 56 }, + { 1, 14, 23 } + } + } + }, { /* block Type 1 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 181, 21, 201 }, + { 61, 37, 123 }, + { 10, 38, 71 } + }, { /* Coeff Band 1 */ + { 47, 106, 172 }, + { 95, 104, 173 }, + { 42, 93, 159 }, + { 18, 77, 131 }, + { 4, 50, 81 }, + { 1, 17, 23 } + }, { /* Coeff Band 2 */ + { 62, 147, 199 }, + { 44, 130, 189 }, + { 28, 102, 154 }, + { 18, 75, 115 }, + { 2, 44, 65 }, + { 1, 12, 19 } + }, { /* Coeff Band 3 */ + { 55, 153, 210 }, + { 24, 130, 194 }, + { 3, 93, 146 }, + { 1, 61, 97 }, + { 1, 31, 50 }, + { 1, 10, 16 } + }, { /* Coeff Band 4 */ + { 49, 186, 223 }, + { 17, 148, 204 }, + { 1, 96, 142 }, + { 1, 53, 83 }, + { 1, 26, 44 }, + { 1, 11, 17 } + }, { /* Coeff Band 5 */ + { 13, 217, 212 }, + { 2, 136, 180 }, + { 1, 78, 124 }, + { 1, 50, 83 }, + { 1, 29, 49 }, + { 1, 14, 23 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 197, 13, 247 }, + { 82, 17, 222 }, + { 25, 17, 162 } + }, { /* Coeff Band 1 */ + { 126, 186, 247 }, + { 234, 191, 243 }, + { 176, 177, 234 }, + { 104, 158, 220 }, + { 66, 128, 186 }, + { 55, 90, 137 } + }, { /* Coeff Band 2 */ + { 111, 197, 242 }, + { 46, 158, 219 }, + { 9, 104, 171 }, + { 2, 65, 125 }, + { 1, 44, 80 }, + { 1, 17, 91 } + }, { /* Coeff Band 3 */ + { 104, 208, 245 }, + { 39, 168, 224 }, + { 3, 109, 162 }, + { 1, 79, 124 }, + { 1, 50, 102 }, + { 1, 43, 102 } + }, { /* Coeff Band 4 */ + { 84, 220, 246 }, + { 31, 177, 231 }, + { 2, 115, 180 }, + { 1, 79, 134 }, + { 1, 55, 77 }, + { 1, 60, 79 } + }, { /* Coeff Band 5 */ + { 43, 243, 240 }, + { 8, 180, 217 }, + { 1, 115, 166 }, + { 1, 84, 121 }, + { 1, 51, 67 }, + { 1, 16, 6 } + } + } + } + } +}; + const vp9_prob vp9_kf_y_mode_prob[INTRA_MODES][INTRA_MODES][INTRA_MODES - 1] = { { // above = dc @@ -423,7 +1239,684 @@ MPP_RET hal_vp9d_output_probe(void *buf, void *dxva) } fflush(vp9_fp); #endif + MPP_FREE(probe_packet); + return 0; +} + +MPP_RET hal_vp9d_prob_default(void *buf, void *dxva) +{ + RK_S32 i, j, k, m, n; + RK_S32 fifo_len = PROB_SIZE >> 3; + RK_U64 *probe_packet = NULL; + BitputCtx_t bp; + DXVA_PicParams_VP9 *pic_param = (DXVA_PicParams_VP9*)dxva; + RK_S32 intraFlag = (!pic_param->frame_type || pic_param->intra_only); + vp9_prob partition_probs[PARTITION_CONTEXTS][PARTITION_TYPES - 1]; + memset(buf, 0, PROB_SIZE); + + if (intraFlag) { + memcpy(&pic_param->prob.tx32p, &vp9_default_probs.tx32p, sizeof(vp9_default_probs.tx32p)); + memcpy(&pic_param->prob.tx16p, &vp9_default_probs.tx16p, sizeof(vp9_default_probs.tx16p)); + memcpy(&pic_param->prob.tx8p, &vp9_default_probs.tx8p, sizeof(vp9_default_probs.tx8p)); + memcpy(&pic_param->prob.skip, &vp9_default_probs.skip, sizeof(vp9_default_probs.skip)); + memcpy(&pic_param->prob.coef, &vp9_default_coef_probs, sizeof(vp9_default_coef_probs)); + } + memcpy(partition_probs, pic_param->prob.partition, sizeof(partition_probs)); + + probe_packet = mpp_calloc(RK_U64, fifo_len); + memset(probe_packet, 0, fifo_len); + mpp_set_bitput_ctx(&bp, probe_packet, fifo_len); + + //sb info 5 x 128 bit + for (i = 0; i < 16; i++) //kf_partition_prob + for (j = 0; j < 3; j++) + mpp_put_bits(&bp, partition_probs[i][j], 8); //48 + + for (i = 0; i < PREDICTION_PROBS; i++) //Segment_id_pred_prob //3 + mpp_put_bits(&bp, 0, 8); + + for (i = 0; i < SEG_TREE_PROBS; i++) //Segment_id_probs + mpp_put_bits(&bp, 0, 8); //7 + + for (i = 0; i < SKIP_CONTEXTS; i++) //Skip_flag_probs //3 + mpp_put_bits(&bp, pic_param->prob.skip[i], 8); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //6 + for (j = 0; j < TX_SIZES - 1; j++) + mpp_put_bits(&bp, pic_param->prob.tx32p[i][j], 8); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //4 + for (j = 0; j < TX_SIZES - 2; j++) + mpp_put_bits(&bp, pic_param->prob.tx16p[i][j], 8); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //2 + mpp_put_bits(&bp, pic_param->prob.tx8p[i], 8); + + for (i = 0; i < INTRA_INTER_CONTEXTS; i++) //Tx_size_probs //4 + mpp_put_bits(&bp, pic_param->prob.intra[i], 8); + + mpp_put_align(&bp, 128, 0); + + //intra_y_mode & inter_block info 6 x 128 bit + for (i = 0; i < BLOCK_SIZE_GROUPS; i++) //intra_y_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, pic_param->prob.y_mode[i][j], 8); + + for (i = 0; i < COMP_INTER_CONTEXTS; i++) //reference_mode prob + mpp_put_bits(&bp, pic_param->prob.comp[i], 8); + + for (i = 0; i < REF_CONTEXTS; i++) //comp ref bit + mpp_put_bits(&bp, pic_param->prob.comp_ref[i], 8); + + for (i = 0; i < REF_CONTEXTS; i++) //single ref bit + for (j = 0; j < 2; j++) + mpp_put_bits(&bp, pic_param->prob.single_ref[i][j], 8); + + for (i = 0; i < INTER_MODE_CONTEXTS; i++) //mv mode bit + for (j = 0; j < INTER_MODES - 1; j++) + mpp_put_bits(&bp, pic_param->prob.mv_mode[i][j], 8); + + + for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) //comp ref bit + for (j = 0; j < SWITCHABLE_FILTERS - 1; j++) + mpp_put_bits(&bp, pic_param->prob.filter[i][j], 8); + + mpp_put_align(&bp, 128, 0); + + //128 x 128bit + //coeff releated + for (i = 0; i < TX_SIZES; i++) + for (j = 0; j < PLANE_TYPES; j++) { + RK_S32 byte_count = 0; + for (k = 0; k < COEF_BANDS; k++) { + for (m = 0; m < COEFF_CONTEXTS; m++) + for (n = 0; n < UNCONSTRAINED_NODES; n++) { + mpp_put_bits(&bp, pic_param->prob.coef[i][j][0][k][m][n], 8); + byte_count++; + if (byte_count == 27) { + mpp_put_align(&bp, 128, 0); + byte_count = 0; + } + } + } + mpp_put_align(&bp, 128, 0); + } + for (i = 0; i < TX_SIZES; i++) + for (j = 0; j < PLANE_TYPES; j++) { + RK_S32 byte_count = 0; + for (k = 0; k < COEF_BANDS; k++) { + for (m = 0; m < COEFF_CONTEXTS; m++) { + for (n = 0; n < UNCONSTRAINED_NODES; n++) { + mpp_put_bits(&bp, pic_param->prob.coef[i][j][1][k][m][n], 8); + byte_count++; + if (byte_count == 27) { + mpp_put_align(&bp, 128, 0); + byte_count = 0; + } + } + + } + } + mpp_put_align(&bp, 128, 0); + } + + //intra uv mode 6 x 128 + for (i = 0; i < 3; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, pic_param->prob.uv_mode[i][j], 8); + mpp_put_align(&bp, 128, 0); + + for (; i < 6; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, pic_param->prob.uv_mode[i][j], 8); + mpp_put_align(&bp, 128, 0); + + for (; i < 9; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, pic_param->prob.uv_mode[i][j], 8); + mpp_put_align(&bp, 128, 0); + for (; i < INTRA_MODES; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, pic_param->prob.uv_mode[i][j], 8); + + mpp_put_align(&bp, 128, 0); + mpp_put_bits(&bp, 0, 8); + mpp_put_align(&bp, 128, 0); + + //mv releated 6 x 128 + for (i = 0; i < MV_JOINTS - 1; i++) //mv_joint_type + mpp_put_bits(&bp, pic_param->prob.mv_joint[i], 8); + + for (i = 0; i < 2; i++) { //sign bit + mpp_put_bits(&bp, pic_param->prob.mv_comp[i].sign, 8); + } + for (i = 0; i < 2; i++) { //classes bit + for (j = 0; j < MV_CLASSES - 1; j++) + mpp_put_bits(&bp, pic_param->prob.mv_comp[i].classes[j], 8); + } + for (i = 0; i < 2; i++) { //classe0 bit + mpp_put_bits(&bp, pic_param->prob.mv_comp[i].class0, 8); + } + for (i = 0; i < 2; i++) { // bits + for (j = 0; j < MV_OFFSET_BITS; j++) + mpp_put_bits(&bp, pic_param->prob.mv_comp[i].bits[j], 8); + } + for (i = 0; i < 2; i++) { //class0_fp bit + for (j = 0; j < CLASS0_SIZE; j++) + for (k = 0; k < MV_FP_SIZE - 1; k++) + mpp_put_bits(&bp, pic_param->prob.mv_comp[i].class0_fp[j][k], 8); + } + for (i = 0; i < 2; i++) { //comp ref bit + for (j = 0; j < MV_FP_SIZE - 1; j++) + mpp_put_bits(&bp, pic_param->prob.mv_comp[i].fp[j], 8); + } + for (i = 0; i < 2; i++) { //class0_hp bit + + mpp_put_bits(&bp, pic_param->prob.mv_comp[i].class0_hp, 8); + } + for (i = 0; i < 2; i++) { //hp bit + mpp_put_bits(&bp, pic_param->prob.mv_comp[i].hp, 8); + } + mpp_put_align(&bp, 128, 0); + mpp_put_bits(&bp, 0, 8); + mpp_put_align(&bp, 128, 0); + + memcpy(buf, probe_packet, fifo_len << 3); + +#if VP9_DUMP + { + static RK_U32 file_cnt = 0; + char file_name[128]; + sprintf(file_name, "/data/vp9/prob_default_%d.txt", file_cnt); + FILE *vp9_fp = fopen(file_name, "wb"); + RK_U32 *tmp = (RK_U32 *)buf; + for (i = 0; i < bp.index * 2; i += 2) { + fprintf(vp9_fp, "%08x%08x\n", tmp[i + 1], tmp[i]); + } + file_cnt++; + fflush(vp9_fp); + fclose(vp9_fp); + } +#endif + MPP_FREE(probe_packet); + + return 0; +} + + +MPP_RET hal_vp9d_prob_flag_delta(void *buf, void *dxva) +{ + RK_S32 i, j, k, m, n; + RK_S32 fifo_len = PROB_SIZE >> 3; + RK_U64 *probe_packet = NULL; + BitputCtx_t bp; + DXVA_PicParams_VP9 *pic_param = (DXVA_PicParams_VP9*)dxva; + RK_S32 intraFlag = (!pic_param->frame_type || pic_param->intra_only); + vp9_prob partition_flag[PARTITION_CONTEXTS][PARTITION_TYPES - 1]; + vp9_prob partition_delta[PARTITION_CONTEXTS][PARTITION_TYPES - 1]; + vp9_prob partition_probs[PARTITION_CONTEXTS][PARTITION_TYPES - 1]; + DXVA_prob_vp9 *prob_flag = &pic_param->prob_flag_delta.p_flag; + DXVA_prob_vp9 *prob_delta = &pic_param->prob_flag_delta.p_delta; + + memset(buf, 0, PROB_SIZE); + + if (intraFlag) { + memcpy(partition_probs, vp9_kf_partition_probs, sizeof(partition_probs)); + } else { + memcpy(partition_flag, prob_flag->partition, sizeof(partition_flag)); + memcpy(partition_delta, prob_delta->partition, sizeof(partition_delta)); + } + + probe_packet = mpp_calloc(RK_U64, fifo_len); + memset(probe_packet, 0, fifo_len); + mpp_set_bitput_ctx(&bp, probe_packet, fifo_len); + + if (intraFlag) { //intra probs + //sb info 5 x 128 bit + for (i = 0; i < PARTITION_CONTEXTS; i++) //kf_partition_prob + for (j = 0; j < PARTITION_TYPES - 1; j++) + mpp_put_bits(&bp, 0, 1); //48 + + for (i = 0; i < PREDICTION_PROBS; i++) //Segment_id_pred_prob //3 + mpp_put_bits(&bp, 0, 1); + + for (i = 0; i < SEG_TREE_PROBS; i++) //Segment_id_probs + mpp_put_bits(&bp, 0, 1); //7 + + for (i = 0; i < SKIP_CONTEXTS; i++) //Skip_flag_probs //3 + mpp_put_bits(&bp, prob_flag->skip[i], 1); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //6 + for (j = 0; j < TX_SIZES - 1; j++) + mpp_put_bits(&bp, prob_flag->tx32p[i][j], 1); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //4 + for (j = 0; j < TX_SIZES - 2; j++) + mpp_put_bits(&bp, prob_flag->tx16p[i][j], 1); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //2 + mpp_put_bits(&bp, prob_flag->tx8p[i], 1); + + for (i = 0; i < INTRA_INTER_CONTEXTS; i++) //Tx_size_probs //4 + mpp_put_bits(&bp, 0, 1); + + mpp_put_bits(&bp, 0, 3); //reserve + //intra coeff related prob 64 x 128 bit + for (i = 0; i < 4; i++) + for (j = 0; j < 2; j++) { + RK_U8 *pp = &pic_param->prob_flag_delta.coef_flag[i][j][0][0][0][0]; + for (k = 0; k < 4; k++) { + for (m = 0; m < 27; m++) { + mpp_put_bits(&bp, pp[m + 27 * k], 1);// "coeff_intra_prob" + } + mpp_put_bits(&bp, 0, 5);//"reserve" + } + } + //inter coeff related prob 64 x 128 bit + for (i = 0; i < 4; i++) + for (j = 0; j < 2; j++) { + RK_U8 *pp = &pic_param->prob_flag_delta.coef_flag[i][j][1][0][0][0]; + for (k = 0; k < 4; k++) { + for (m = 0; m < 27; m++) { + mpp_put_bits(&bp, pp[m + 27 * k], 1);// "coeff_intra_prob" + } + mpp_put_bits(&bp, 0, 5);//"reserve" + } + } + mpp_put_align(&bp, 128, 0); + /* ---------------- intra flag prob end ----------------- */ + /* ---------------- intra delat prob start ----------------- */ + for (i = 0; i < PARTITION_CONTEXTS; i++) //kf_partition_prob + for (j = 0; j < PARTITION_TYPES - 1; j++) + mpp_put_bits(&bp, partition_probs[i][j], 8); //48 + + for (i = 0; i < PREDICTION_PROBS; i++) //Segment_id_pred_prob //3 + mpp_put_bits(&bp, pic_param->stVP9Segments.pred_probs[i], 8); + + for (i = 0; i < SEG_TREE_PROBS; i++) //Segment_id_probs + mpp_put_bits(&bp, pic_param->stVP9Segments.tree_probs[i], 8); //7 + + for (i = 0; i < SKIP_CONTEXTS; i++) //Skip_flag_probs //3 + mpp_put_bits(&bp, prob_delta->skip[i], 8); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //6 + for (j = 0; j < TX_SIZES - 1; j++) + mpp_put_bits(&bp, prob_delta->tx32p[i][j], 8); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //4 + for (j = 0; j < TX_SIZES - 2; j++) + mpp_put_bits(&bp, prob_delta->tx16p[i][j], 8); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //2 + mpp_put_bits(&bp, prob_delta->tx8p[i], 8); + + for (i = 0; i < INTRA_INTER_CONTEXTS; i++) //Tx_size_probs //4 + mpp_put_bits(&bp, prob_delta->intra[i], 8); + + mpp_put_align(&bp, 128, 0); + //coeff releated prob 64 x 128 bit + for (i = 0; i < TX_SIZES; i++) + for (j = 0; j < PLANE_TYPES; j++) { + RK_S32 byte_count = 0; + for (k = 0; k < COEF_BANDS; k++) { + for (m = 0; m < COEFF_CONTEXTS; m++) + for (n = 0; n < UNCONSTRAINED_NODES; n++) { + mpp_put_bits(&bp, pic_param->prob_flag_delta.coef_delta[i][j][0][k][m][n], 8); + + byte_count++; + if (byte_count == 27) { + mpp_put_align(&bp, 128, 0); + byte_count = 0; + } + } + } + mpp_put_align(&bp, 128, 0); + } + + //intra mode prob 80 x 128 bit + for (i = 0; i < INTRA_MODES; i++) { //vp9_kf_y_mode_prob + RK_S32 byte_count = 0; + for (j = 0; j < INTRA_MODES; j++) + for (k = 0; k < INTRA_MODES - 1; k++) { + mpp_put_bits(&bp, vp9_kf_y_mode_prob[i][j][k], 8); + byte_count++; + if (byte_count == 27) { + byte_count = 0; + mpp_put_align(&bp, 128, 0); + } + + } + if (i < 4) { + for (m = 0; m < (i < 3 ? 23 : 21); m++) + mpp_put_bits(&bp, ((vp9_prob *)(&vp9_kf_uv_mode_prob[0][0]))[i * 23 + m], 8); + for (; m < 23; m++) + mpp_put_bits(&bp, 0, 8); + } else { + for (m = 0; m < 23; m++) + mpp_put_bits(&bp, 0, 8); + } + mpp_put_align(&bp, 128, 0); + } + + //inter coeff releated prob 64 x 128 bit + for (i = 0; i < 4; i++) + for (j = 0; j < 2; j++) { + int32_t byte_count = 0; // 8 x128bit + for (k = 0; k < 6; k++) + for (m = 0; m < 6; m++) + for (n = 0; n < 3; n++) { + mpp_put_bits(&bp, pic_param->prob_flag_delta.coef_delta[i][j][1][k][m][n], 8); + byte_count++; + if (byte_count == 27) { + mpp_put_align(&bp, 128, 0); + byte_count = 0; + } + } + mpp_put_align(&bp, 128, 0); + } + } else { + //inter probs + //151 x 128 bit ,aligned to 152 x 128 bit + //inter only + //sb info 5 x 128 bit + for (i = 0; i < PARTITION_CONTEXTS; i++) //kf_partition_prob + for (j = 0; j < PARTITION_TYPES - 1; j++) + mpp_put_bits(&bp, partition_flag[i][j], 1); //48 + + for (i = 0; i < PREDICTION_PROBS; i++) //Segment_id_pred_prob //3 + mpp_put_bits(&bp, 0, 1); + + for (i = 0; i < SEG_TREE_PROBS; i++) //Segment_id_probs + mpp_put_bits(&bp, 0, 1); //7 + + for (i = 0; i < SKIP_CONTEXTS; i++) //Skip_flag_probs //3 + mpp_put_bits(&bp, prob_flag->skip[i], 1); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //6 + for (j = 0; j < TX_SIZES - 1; j++) + mpp_put_bits(&bp, prob_flag->tx32p[i][j], 1); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //4 + for (j = 0; j < TX_SIZES - 2; j++) + mpp_put_bits(&bp, prob_flag->tx16p[i][j], 1); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //2 + mpp_put_bits(&bp, prob_flag->tx8p[i], 1); + + for (i = 0; i < INTRA_INTER_CONTEXTS; i++) //Tx_size_probs //4 + mpp_put_bits(&bp, prob_flag->intra[i], 1); + + mpp_put_bits(&bp, 0, 3); //reserve + + //intra_y_mode & inter_block info 6 x 128 bit + for (i = 0; i < BLOCK_SIZE_GROUPS; i++) //intra_y_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, prob_flag->y_mode[i][j], 1); + + for (i = 0; i < COMP_INTER_CONTEXTS; i++) //reference_mode prob + mpp_put_bits(&bp, prob_flag->comp[i], 1); + + for (i = 0; i < REF_CONTEXTS; i++) //comp ref bit + mpp_put_bits(&bp, prob_flag->comp_ref[i], 1); + + for (i = 0; i < REF_CONTEXTS; i++) //single ref bit + for (j = 0; j < 2; j++) + mpp_put_bits(&bp, prob_flag->single_ref[i][j], 1); + + for (i = 0; i < INTER_MODE_CONTEXTS; i++) //mv mode bit + for (j = 0; j < INTER_MODES - 1; j++) + mpp_put_bits(&bp, prob_flag->mv_mode[i][j], 1); + + + for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) //comp ref bit + for (j = 0; j < SWITCHABLE_FILTERS - 1; j++) + mpp_put_bits(&bp, prob_flag->filter[i][j], 1); + + mpp_put_bits(&bp, 0, 11);//reserve + + //intra coeff related prob 64 x 128 bit + for (i = 0; i < 4; i++) + for (j = 0; j < 2; j++) { + RK_U8 *pp = &pic_param->prob_flag_delta.coef_flag[i][j][0][0][0][0]; + for (k = 0; k < 4; k++) { + for (m = 0; m < 27; m++) { + mpp_put_bits(&bp, pp[m + 27 * k], 1);// "coeff_intra_prob" + } + mpp_put_bits(&bp, 0, 5);//"reserve" + } + } + //inter coeff related prob 64 x 128 bit + for (i = 0; i < 4; i++) + for (j = 0; j < 2; j++) { + RK_U8 *pp = &pic_param->prob_flag_delta.coef_flag[i][j][1][0][0][0]; + for (k = 0; k < 4; k++) { + for (m = 0; m < 27; m++) { + mpp_put_bits(&bp, pp[m + 27 * k], 1);// "coeff_intra_prob" + } + mpp_put_bits(&bp, 0, 5);//"reserve" + } + } + + //intra uv mode 6 x 128 + for (i = 0; i < 3; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, prob_flag->uv_mode[i][j], 1); + mpp_put_bits(&bp, 0, 5);//reserve + for (; i < 6; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, prob_flag->uv_mode[i][j], 1); + mpp_put_bits(&bp, 0, 5);//reserve + + for (; i < 9; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, prob_flag->uv_mode[i][j], 1); + mpp_put_bits(&bp, 0, 5);//reserve + for (; i < INTRA_MODES; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, prob_flag->uv_mode[i][j], 1); + mpp_put_bits(&bp, 0, 23);//reserve + + //mv releated 6 x 128 + for (i = 0; i < MV_JOINTS - 1; i++) //mv_joint_type + mpp_put_bits(&bp, prob_flag->mv_joint[i], 1); + + for (i = 0; i < 2; i++) { //sign bit + mpp_put_bits(&bp, prob_flag->mv_comp[i].sign, 1); + } + for (i = 0; i < 2; i++) { //classes bit + for (j = 0; j < MV_CLASSES - 1; j++) + mpp_put_bits(&bp, prob_flag->mv_comp[i].classes[j], 1); + } + for (i = 0; i < 2; i++) { //classe0 bit + mpp_put_bits(&bp, prob_flag->mv_comp[i].class0, 1); + } + for (i = 0; i < 2; i++) { // bits + for (j = 0; j < MV_OFFSET_BITS; j++) + mpp_put_bits(&bp, prob_flag->mv_comp[i].bits[j], 1); + } + for (i = 0; i < 2; i++) { //class0_fp bit + for (j = 0; j < CLASS0_SIZE; j++) + for (k = 0; k < MV_FP_SIZE - 1; k++) + mpp_put_bits(&bp, prob_flag->mv_comp[i].class0_fp[j][k], 1); + } + for (i = 0; i < 2; i++) { //comp ref bit + for (j = 0; j < MV_FP_SIZE - 1; j++) + mpp_put_bits(&bp, prob_flag->mv_comp[i].fp[j], 1); + } + for (i = 0; i < 2; i++) { //class0_hp bit + mpp_put_bits(&bp, prob_flag->mv_comp[i].class0_hp, 1); + } + for (i = 0; i < 2; i++) { //hp bit + mpp_put_bits(&bp, prob_flag->mv_comp[i].hp, 1); + } + mpp_put_bits(&bp, 0, 11);//reserve + + for (i = 0; i < 8; i++) { + mpp_put_bits(&bp, 0, 16);//reserve + } + //sb info 5 x 128 bit + for (i = 0; i < PARTITION_CONTEXTS; i++) //kf_partition_prob + for (j = 0; j < PARTITION_TYPES - 1; j++) + mpp_put_bits(&bp, partition_delta[i][j], 8); //48 + + for (i = 0; i < PREDICTION_PROBS; i++) //Segment_id_pred_prob //3 + mpp_put_bits(&bp, pic_param->stVP9Segments.pred_probs[i], 8); + + for (i = 0; i < SEG_TREE_PROBS; i++) //Segment_id_probs + mpp_put_bits(&bp, pic_param->stVP9Segments.tree_probs[i], 8); //7 + + for (i = 0; i < SKIP_CONTEXTS; i++) //Skip_flag_probs //3 + mpp_put_bits(&bp, prob_delta->skip[i], 8); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //6 + for (j = 0; j < TX_SIZES - 1; j++) + mpp_put_bits(&bp, prob_delta->tx32p[i][j], 8); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //4 + for (j = 0; j < TX_SIZES - 2; j++) + mpp_put_bits(&bp, prob_delta->tx16p[i][j], 8); + + for (i = 0; i < TX_SIZE_CONTEXTS; i++) //Tx_size_probs //2 + mpp_put_bits(&bp, prob_delta->tx8p[i], 8); + + for (i = 0; i < INTRA_INTER_CONTEXTS; i++) //Tx_size_probs //4 + mpp_put_bits(&bp, prob_delta->intra[i], 8); + + mpp_put_bits(&bp, 0, 24); //reserve + + //intra_y_mode & inter_block info 6 x 128 bit + for (i = 0; i < BLOCK_SIZE_GROUPS; i++) //intra_y_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, prob_delta->y_mode[i][j], 8); + + for (i = 0; i < COMP_INTER_CONTEXTS; i++) //reference_mode prob + mpp_put_bits(&bp, prob_delta->comp[i], 8); + + for (i = 0; i < REF_CONTEXTS; i++) //comp ref bit + mpp_put_bits(&bp, prob_delta->comp_ref[i], 8); + + for (i = 0; i < REF_CONTEXTS; i++) //single ref bit + for (j = 0; j < 2; j++) + mpp_put_bits(&bp, prob_delta->single_ref[i][j], 8); + + for (i = 0; i < INTER_MODE_CONTEXTS; i++) //mv mode bit + for (j = 0; j < INTER_MODES - 1; j++) + mpp_put_bits(&bp, prob_delta->mv_mode[i][j], 8); + + + for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) //comp ref bit + for (j = 0; j < SWITCHABLE_FILTERS - 1; j++) + mpp_put_bits(&bp, prob_delta->filter[i][j], 8); + for (i = 0; i < 11; i++) + mpp_put_bits(&bp, 0, 8);//reserve + + //intra coeff related prob 64 x 128 bit + for (i = 0; i < 4; i++) + for (j = 0; j < 2; j++) { + RK_U32 byte_count = 0; + for (k = 0; k < 6; k++) { + for (m = 0; m < 6; m++) + for (n = 0; n < 3; n++) { + mpp_put_bits(&bp, pic_param->prob_flag_delta.coef_delta[i][j][0][k][m][n], 8); + byte_count++; + if (byte_count == 27) { + mpp_put_bits(&bp, 0, 40);//aline + byte_count = 0; + } + } + } + } + for (i = 0; i < 4; i++) + for (j = 0; j < 2; j++) { + int32_t byte_count = 0; + for (k = 0; k < 6; k++) { + for (m = 0; m < 6; m++) + for (n = 0; n < 3; n++) { + mpp_put_bits(&bp, pic_param->prob_flag_delta.coef_delta[i][j][1][k][m][n], 8);//"coeff_inter_prob" + byte_count++; + if (byte_count == 27) { + mpp_put_bits(&bp, 0, 40);//aline + byte_count = 0; + } + } + } + } + + //intra uv mode 6 x 128 + for (i = 0; i < 3; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, prob_delta->uv_mode[i][j], 8); + mpp_put_bits(&bp, 0, 40);//reserve + for (; i < 6; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, prob_delta->uv_mode[i][j], 8); + mpp_put_bits(&bp, 0, 40);//reserve + + for (; i < 9; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, prob_delta->uv_mode[i][j], 8); + mpp_put_bits(&bp, 0, 40);//reserve + for (; i < INTRA_MODES; i++) //intra_uv_mode + for (j = 0; j < INTRA_MODES - 1; j++) + mpp_put_bits(&bp, prob_delta->uv_mode[i][j], 8); + for (i = 0; i < 23; i++) + mpp_put_bits(&bp, 0xff, 8);//reserve + + //mv releated 6 x 128 + for (i = 0; i < MV_JOINTS - 1; i++) //mv_joint_type + mpp_put_bits(&bp, prob_delta->mv_joint[i], 8); + + for (i = 0; i < 2; i++) { //sign bit + mpp_put_bits(&bp, prob_delta->mv_comp[i].sign, 8); + } + for (i = 0; i < 2; i++) { //classes bit + for (j = 0; j < MV_CLASSES - 1; j++) + mpp_put_bits(&bp, prob_delta->mv_comp[i].classes[j], 8); + } + for (i = 0; i < 2; i++) { //classe0 bit + mpp_put_bits(&bp, prob_delta->mv_comp[i].class0, 8); + } + for (i = 0; i < 2; i++) { // bits + for (j = 0; j < MV_OFFSET_BITS; j++) + mpp_put_bits(&bp, prob_delta->mv_comp[i].bits[j], 8); + } + for (i = 0; i < 2; i++) { //class0_fp bit + for (j = 0; j < CLASS0_SIZE; j++) + for (k = 0; k < MV_FP_SIZE - 1; k++) + mpp_put_bits(&bp, prob_delta->mv_comp[i].class0_fp[j][k], 8); + } + for (i = 0; i < 2; i++) { //comp ref bit + for (j = 0; j < MV_FP_SIZE - 1; j++) + mpp_put_bits(&bp, prob_delta->mv_comp[i].fp[j], 8); + } + for (i = 0; i < 2; i++) { //class0_hp bit + mpp_put_bits(&bp, prob_delta->mv_comp[i].class0_hp, 8); + } + for (i = 0; i < 2; i++) { //hp bit + mpp_put_bits(&bp, prob_delta->mv_comp[i].hp, 8); + } + for (i = 0; i < 27; i++) + mpp_put_bits(&bp, 0, 8);//reserve + + } + mpp_put_align(&bp, 128, 0); + + memcpy(buf, probe_packet, fifo_len << 3); + +#if VP9_DUMP + static RK_U32 file_cnt = 0; + char file_name[128]; + sprintf(file_name, "/data/vp9/prob_%d.txt", file_cnt); + FILE *vp9_fp = fopen(file_name, "wb"); + RK_U32 *tmp = (RK_U32 *)buf; + for (i = 0; i < bp.index * 2; i += 2) { + fprintf(vp9_fp, "%08x%08x\n", tmp[i + 1], tmp[i]); + } + file_cnt++; + fflush(vp9_fp); + fclose(vp9_fp); +#endif MPP_FREE(probe_packet); return 0; diff --git a/mpp/hal/rkdec/vp9d/hal_vp9d_com.h b/mpp/hal/rkdec/vp9d/hal_vp9d_com.h index 25b0e269..9eff74e0 100644 --- a/mpp/hal/rkdec/vp9d/hal_vp9d_com.h +++ b/mpp/hal/rkdec/vp9d/hal_vp9d_com.h @@ -52,7 +52,7 @@ typedef RK_U8 vp9_prob; #define MV_OFFSET_BITS (MV_CLASSES + CLASS0_BITS - 2) #define MV_FP_SIZE 4 -#define PROBE_SIZE 4864 +#define PROB_SIZE 4864 #define COUNT_SIZE 13208 /* * nCtuX*nCtuY*8*8/2 @@ -61,6 +61,8 @@ typedef RK_U8 vp9_prob; */ #define MAX_SEGMAP_SIZE 73728 +#define VP9_DUMP 0 + //!< memory malloc check #define MEM_CHECK(ret, val, ...)\ do{\ @@ -83,7 +85,9 @@ RK_U32 vp9_ver_align(RK_U32 val); RK_U32 vp9_hor_align(RK_U32 val); MPP_RET hal_vp9d_output_probe(void *buf, void *dxva); +MPP_RET hal_vp9d_prob_flag_delta(void *buf, void *dxva); void hal_vp9d_update_counts(void *buf, void *dxva); +MPP_RET hal_vp9d_prob_default(void *buf, void *dxva); #ifdef __cplusplus } diff --git a/mpp/hal/rkdec/vp9d/hal_vp9d_rkv.c b/mpp/hal/rkdec/vp9d/hal_vp9d_rkv.c index 321739d8..d75daa72 100644 --- a/mpp/hal/rkdec/vp9d/hal_vp9d_rkv.c +++ b/mpp/hal/rkdec/vp9d/hal_vp9d_rkv.c @@ -61,7 +61,7 @@ static MPP_RET hal_vp9d_alloc_res(HalVp9dCtx *hal) for (i = 0; i < MAX_GEN_REG; i++) { hw_ctx->g_buf[i].hw_regs = mpp_calloc_size(void, sizeof(VP9_REGS)); ret = mpp_buffer_get(p_hal->group, - &hw_ctx->g_buf[i].probe_base, PROBE_SIZE); + &hw_ctx->g_buf[i].probe_base, PROB_SIZE); if (ret) { mpp_err("vp9 probe_base get buffer failed\n"); return ret; @@ -87,7 +87,7 @@ static MPP_RET hal_vp9d_alloc_res(HalVp9dCtx *hal) } } else { hw_ctx->hw_regs = mpp_calloc_size(void, sizeof(VP9_REGS)); - ret = mpp_buffer_get(p_hal->group, &hw_ctx->probe_base, PROBE_SIZE); + ret = mpp_buffer_get(p_hal->group, &hw_ctx->probe_base, PROB_SIZE); if (ret) { mpp_err("vp9 probe_base get buffer failed\n"); return ret; diff --git a/mpp/hal/rkdec/vp9d/hal_vp9d_vdpu34x.c b/mpp/hal/rkdec/vp9d/hal_vp9d_vdpu34x.c index a71ce076..fdb841c7 100644 --- a/mpp/hal/rkdec/vp9d/hal_vp9d_vdpu34x.c +++ b/mpp/hal/rkdec/vp9d/hal_vp9d_vdpu34x.c @@ -34,12 +34,15 @@ #include "vdpu34x_vp9d.h" #include "vp9d_syntax.h" +#define HW_PROB 1 + typedef struct Vdpu34xVp9dCtx_t { Vp9dRegBuf g_buf[MAX_GEN_REG]; MppBuffer probe_base; MppBuffer count_base; MppBuffer segid_cur_base; MppBuffer segid_last_base; + MppBuffer prob_default_base; void* hw_regs; RK_S32 mv_base_addr; RK_S32 pre_mv_base_addr; @@ -61,6 +64,8 @@ typedef struct Vdpu34xVp9dCtx_t { HalBufs cmv_bufs; RK_S32 mv_size; RK_S32 mv_count; + RK_U32 prob_ctx_valid[4]; + MppBuffer prob_loop_base[4]; } Vdpu34xVp9dCtx; static MPP_RET hal_vp9d_alloc_res(HalVp9dCtx *hal) @@ -74,7 +79,7 @@ static MPP_RET hal_vp9d_alloc_res(HalVp9dCtx *hal) for (i = 0; i < MAX_GEN_REG; i++) { hw_ctx->g_buf[i].hw_regs = mpp_calloc_size(void, sizeof(Vdpu34xVp9dRegSet)); ret = mpp_buffer_get(p_hal->group, - &hw_ctx->g_buf[i].probe_base, PROBE_SIZE); + &hw_ctx->g_buf[i].probe_base, PROB_SIZE); if (ret) { mpp_err("vp9 probe_base get buffer failed\n"); return ret; @@ -100,11 +105,24 @@ static MPP_RET hal_vp9d_alloc_res(HalVp9dCtx *hal) } } else { hw_ctx->hw_regs = mpp_calloc_size(void, sizeof(Vdpu34xVp9dRegSet)); - ret = mpp_buffer_get(p_hal->group, &hw_ctx->probe_base, PROBE_SIZE); + ret = mpp_buffer_get(p_hal->group, &hw_ctx->probe_base, PROB_SIZE); if (ret) { mpp_err("vp9 probe_base get buffer failed\n"); return ret; } + ret = mpp_buffer_get(p_hal->group, &hw_ctx->prob_default_base, PROB_SIZE); + if (ret) { + mpp_err("vp9 probe_default_base get buffer failed\n"); + return ret; + } + for (i = 0; i < 4; i++) { + ret = mpp_buffer_get(p_hal->group, &hw_ctx->prob_loop_base[i], PROB_SIZE); + if (ret) { + mpp_err("vp9 probe_loop_base get buffer failed\n"); + return ret; + } + } + ret = mpp_buffer_get(p_hal->group, &hw_ctx->count_base, COUNT_SIZE); if (ret) { mpp_err("vp9 count_base get buffer failed\n"); @@ -174,6 +192,22 @@ static MPP_RET hal_vp9d_release_res(HalVp9dCtx *hal) return ret; } } + if (hw_ctx->prob_default_base) { + ret = mpp_buffer_put(hw_ctx->prob_default_base); + if (ret) { + mpp_err("vp9 probe_wr_base get buffer failed\n"); + return ret; + } + } + for (i = 0; i < 4; i++) { + if (hw_ctx->prob_loop_base[i]) { + ret = mpp_buffer_put(hw_ctx->prob_loop_base[i]); + if (ret) { + mpp_err("vp9 probe_base put buffer failed\n"); + return ret; + } + } + } if (hw_ctx->count_base) { ret = mpp_buffer_put(hw_ctx->count_base); if (ret) { @@ -309,8 +343,9 @@ static MPP_RET hal_vp9d_vdpu34x_gen_regs(void *hal, HalTaskInfo *task) Vdpu34xVp9dCtx *hw_ctx = (Vdpu34xVp9dCtx*)p_hal->hw_ctx; DXVA_PicParams_VP9 *pic_param = (DXVA_PicParams_VP9*)task->dec.syntax.data; RK_S32 mv_size = pic_param->width * pic_param->height / 2; + RK_U32 frame_ctx_id = pic_param->frame_context_idx; - if (p_hal ->fast_mode) { + if (p_hal->fast_mode) { for (i = 0; i < MAX_GEN_REG; i++) { if (!hw_ctx->g_buf[i].use_flag) { task->dec.reg_index = i; @@ -349,10 +384,80 @@ static MPP_RET hal_vp9d_vdpu34x_gen_regs(void *hal, HalTaskInfo *task) Vdpu34xVp9dRegSet *vp9_hw_regs = (Vdpu34xVp9dRegSet*)hw_ctx->hw_regs; intraFlag = (!pic_param->frame_type || pic_param->intra_only); - hal_vp9d_output_probe(mpp_buffer_get_ptr(hw_ctx->probe_base), task->dec.syntax.data); stream_len = (RK_S32)mpp_packet_get_length(task->dec.input_packet); memset(hw_ctx->hw_regs, 0, sizeof(Vdpu34xVp9dRegSet)); - vp9_hw_regs->common.reg013.cur_pic_is_idr = intraFlag; +#if HW_PROB + hal_vp9d_prob_flag_delta(mpp_buffer_get_ptr(hw_ctx->probe_base), task->dec.syntax.data); + if (intraFlag) + hal_vp9d_prob_default(mpp_buffer_get_ptr(hw_ctx->prob_default_base), task->dec.syntax.data); + + /* config reg103 */ + vp9_hw_regs->vp9d_param.reg103.prob_update_en = 1; + vp9_hw_regs->vp9d_param.reg103.intra_only_flag = intraFlag; + if (!intraFlag) { + vp9_hw_regs->vp9d_param.reg103.txfmmode_rfsh_en = (pic_param->txmode == 4) ? 1 : 0; + vp9_hw_regs->vp9d_param.reg103.interp_filter_switch_en = pic_param->interp_filter == 4 ? 1 : 0; + } + vp9_hw_regs->vp9d_param.reg103.ref_mode_rfsh_en = 1; + vp9_hw_regs->vp9d_param.reg103.single_ref_rfsh_en = 1; + vp9_hw_regs->vp9d_param.reg103.comp_ref_rfsh_en = 1; + vp9_hw_regs->vp9d_param.reg103.inter_coef_rfsh_flag = 0; + vp9_hw_regs->vp9d_param.reg103.refresh_en = + !pic_param->error_resilient_mode && !pic_param->parallelmode; + vp9_hw_regs->vp9d_param.reg103.prob_save_en = pic_param->refresh_frame_context; + vp9_hw_regs->vp9d_param.reg103.allow_high_precision_mv = pic_param->allow_high_precision_mv; + vp9_hw_regs->vp9d_param.reg103.last_key_frame_flag = hw_ctx->ls_info.last_intra_only; + + + /* config last prob base and update write base */ + { + + if (intraFlag || pic_param->error_resilient_mode) { + if (intraFlag + || pic_param->error_resilient_mode + || (pic_param->reset_frame_context == 3)) { + memset(hw_ctx->prob_ctx_valid, 0, sizeof(hw_ctx->prob_ctx_valid)); + } else if (pic_param->reset_frame_context == 2) { + hw_ctx->prob_ctx_valid[frame_ctx_id] = 0; + } + } + +#if VP9_DUMP + { + static RK_U32 file_cnt = 0; + char file_name[128]; + RK_U32 i = 0; + sprintf(file_name, "/data/vp9/prob_last_%d.txt", file_cnt); + FILE *fp = fopen(file_name, "wb"); + RK_U32 *tmp = NULL; + if (hw_ctx->prob_ctx_valid[frame_ctx_id]) { + tmp = (RK_U32 *)mpp_buffer_get_ptr(hw_ctx->prob_loop_base[pic_param->frame_context_idx]); + } else { + tmp = (RK_U32 *)mpp_buffer_get_ptr(hw_ctx->prob_default_base); + } + for (i = 0; i < PROB_SIZE / 4; i += 2) { + fprintf(fp, "%08x%08x\n", tmp[i + 1], tmp[i]); + } + file_cnt++; + fflush(fp); + fclose(fp); + } +#endif + if (hw_ctx->prob_ctx_valid[frame_ctx_id]) { + vp9_hw_regs->vp9d_addr.reg162_last_prob_base = + mpp_buffer_get_fd(hw_ctx->prob_loop_base[frame_ctx_id]); + } else { + vp9_hw_regs->vp9d_addr.reg162_last_prob_base = mpp_buffer_get_fd(hw_ctx->prob_default_base); + hw_ctx->prob_ctx_valid[frame_ctx_id] |= pic_param->refresh_frame_context; + } + vp9_hw_regs->vp9d_addr.reg172_update_prob_wr_base = + mpp_buffer_get_fd(hw_ctx->prob_loop_base[frame_ctx_id]); + } + vp9_hw_regs->vp9d_addr.reg160_delta_prob_base = mpp_buffer_get_fd(hw_ctx->probe_base); +#else + hal_vp9d_output_probe(mpp_buffer_get_ptr(hw_ctx->probe_base), task->dec.syntax.data); +#endif + vp9_hw_regs->common.reg013.cur_pic_is_idr = !pic_param->frame_type; vp9_hw_regs->common.reg009.dec_mode = 2; //set as vp9 dec vp9_hw_regs->common.reg016_str_len = ((stream_len + 15) & (~15)) + 0x80; @@ -488,13 +593,13 @@ static MPP_RET hal_vp9d_vdpu34x_gen_regs(void *hal, HalTaskInfo *task) } for (i = 0; i < 8; i++) { - vp9_hw_regs->vp9d_param.reg67_74[i].segid_frame_qp_delta_en = (hw_ctx->ls_info.feature_mask[i]) & 0x1; - vp9_hw_regs->vp9d_param.reg67_74[i].segid_frame_qp_delta = hw_ctx->ls_info.feature_data[i][0]; - vp9_hw_regs->vp9d_param.reg67_74[i].segid_frame_loopfitler_value_en = (hw_ctx->ls_info.feature_mask[i] >> 1) & 0x1; - vp9_hw_regs->vp9d_param.reg67_74[i].segid_frame_loopfilter_value = hw_ctx->ls_info.feature_data[i][1]; - vp9_hw_regs->vp9d_param.reg67_74[i].segid_referinfo_en = (hw_ctx->ls_info.feature_mask[i] >> 2) & 0x1; - vp9_hw_regs->vp9d_param.reg67_74[i].segid_referinfo = hw_ctx->ls_info.feature_data[i][2]; - vp9_hw_regs->vp9d_param.reg67_74[i].segid_frame_skip_en = (hw_ctx->ls_info.feature_mask[i] >> 3) & 0x1; + vp9_hw_regs->vp9d_param.reg67_74[i].segid_frame_qp_delta_en = (hw_ctx->ls_info.feature_mask[i]) & 0x1; + vp9_hw_regs->vp9d_param.reg67_74[i].segid_frame_qp_delta = hw_ctx->ls_info.feature_data[i][0]; + vp9_hw_regs->vp9d_param.reg67_74[i].segid_frame_loopfitler_value_en = (hw_ctx->ls_info.feature_mask[i] >> 1) & 0x1; + vp9_hw_regs->vp9d_param.reg67_74[i].segid_frame_loopfilter_value = hw_ctx->ls_info.feature_data[i][1]; + vp9_hw_regs->vp9d_param.reg67_74[i].segid_referinfo_en = (hw_ctx->ls_info.feature_mask[i] >> 2) & 0x1; + vp9_hw_regs->vp9d_param.reg67_74[i].segid_referinfo = hw_ctx->ls_info.feature_data[i][2]; + vp9_hw_regs->vp9d_param.reg67_74[i].segid_frame_skip_en = (hw_ctx->ls_info.feature_mask[i] >> 3) & 0x1; } vp9_hw_regs->vp9d_param.reg67_74[0].segid_abs_delta = hw_ctx->ls_info.abs_delta_last; @@ -507,18 +612,17 @@ static MPP_RET hal_vp9d_vdpu34x_gen_regs(void *hal, HalTaskInfo *task) vp9_hw_regs->vp9d_param.reg94.ref_deltas_lastframe |= (hw_ctx->ls_info.last_ref_deltas[i] & 0x7f) << (7 * i); for (i = 0; i < 2; i++) - vp9_hw_regs->vp9d_param.reg75.mode_deltas_lastframe |= (hw_ctx->ls_info.last_mode_deltas[i] & 0x7f) << (7 * i); + vp9_hw_regs->vp9d_param.reg75.mode_deltas_lastframe |= (hw_ctx->ls_info.last_mode_deltas[i] & 0x7f) << (7 * i); } else { hw_ctx->ls_info.segmentation_enable_flag_last = 0; hw_ctx->ls_info.last_intra_only = 1; } - vp9_hw_regs->vp9d_param.reg75.mode_deltas_lastframe = 0; vp9_hw_regs->vp9d_param.reg75.segmentation_enable_lstframe = hw_ctx->ls_info.segmentation_enable_flag_last; vp9_hw_regs->vp9d_param.reg75.last_show_frame = hw_ctx->ls_info.last_show_frame; vp9_hw_regs->vp9d_param.reg75.last_intra_only = hw_ctx->ls_info.last_intra_only; vp9_hw_regs->vp9d_param.reg75.last_widthheight_eqcur = (pic_param->width == hw_ctx->ls_info.last_width) && (pic_param->height == hw_ctx->ls_info.last_height); - vp9_hw_regs->vp9d_param.reg78.lasttile_size = stream_len - pic_param->first_partition_size; + vp9_hw_regs->vp9d_param.reg78.lasttile_size = stream_len - pic_param->first_partition_size; if (!intraFlag) { @@ -530,7 +634,7 @@ static MPP_RET hal_vp9d_vdpu34x_gen_regs(void *hal, HalTaskInfo *task) vp9_hw_regs->vp9d_param.reg93.aref_ver_scale = pic_param->mvscale[2][1]; } - vp9_hw_regs->common.reg010.dec_e = 1; + vp9_hw_regs->common.reg010.dec_e = 1; vp9_hw_regs->common.reg011.dec_timeout_e = 1; vp9_hw_regs->common.reg011.buf_empty_en = 1; @@ -608,13 +712,39 @@ static MPP_RET hal_vp9d_vdpu34x_start(void *hal, HalTaskInfo *task) mpp_assert(hw_regs); - if (hal_vp9d_debug & HAL_VP9D_DBG_REG) { - RK_U32 *p = (RK_U32 *)hw_ctx->hw_regs; - RK_U32 i = 0; - for (i = 0; i < sizeof(Vdpu34xVp9dRegSet) / 4; i++) - mpp_log("set regs[%02d]: %08X\n", i, *p++); +#if VP9_DUMP + { + static RK_U32 file_cnt = 0; + char file_name[128]; + sprintf(file_name, "/data/vp9_regs/reg_%d.txt", file_cnt); + FILE *fp = fopen(file_name, "wb"); + RK_U32 i = 0; + RK_U32 *tmp = NULL; + tmp = (RK_U32 *)&hw_regs->common; + for (i = 0; i < sizeof(hw_regs->common) / 4; i++) { + fprintf(fp, "reg[%d] 0x%08x\n", i + 8, tmp[i]); + } + fprintf(fp, "\n"); + tmp = (RK_U32 *)&hw_regs->vp9d_param; + for (i = 0; i < sizeof(hw_regs->vp9d_param) / 4; i++) { + fprintf(fp, "reg[%d] 0x%08x\n", i + 64, tmp[i]); + } + fprintf(fp, "\n"); + tmp = (RK_U32 *)&hw_regs->common_addr; + for (i = 0; i < sizeof(hw_regs->common_addr) / 4; i++) { + fprintf(fp, "reg[%d] 0x%08x\n", i + 128, tmp[i]); + } + fprintf(fp, "\n"); + tmp = (RK_U32 *)&hw_regs->vp9d_addr; + for (i = 0; i < sizeof(hw_regs->vp9d_addr) / 4; i++) { + fprintf(fp, "reg[%d] 0x%08x\n", i + 160, tmp[i]); + } + file_cnt++; + fflush(fp); + fclose(fp); } +#endif do { MppDevRegWrCfg wr_cfg; @@ -712,12 +842,13 @@ static MPP_RET hal_vp9d_vdpu34x_wait(void *hal, HalTaskInfo *task) mpp_buf_slot_get_prop(p_hal->slots, task->dec.output, SLOT_FRAME_PTR, &mframe); mpp_frame_set_errinfo(mframe, 1); } - +#if !HW_PROB if (p_hal->dec_cb && task->dec.flags.wait_done) { DXVA_PicParams_VP9 *pic_param = (DXVA_PicParams_VP9*)task->dec.syntax.data; hal_vp9d_update_counts(mpp_buffer_get_ptr(hw_ctx->count_base), task->dec.syntax.data); mpp_callback(p_hal->dec_cb, DEC_PARSER_CALLBACK, &pic_param->counts); } +#endif if (p_hal->fast_mode) { hw_ctx->g_buf[task->dec.reg_index].use_flag = 0; }