hevc: remove HEVCContext usage from hevc_ps

Factor out the parameter sets into a separate struct and use it instead.

This will allow us to reuse this code in the parser.

1 files changed, 27 insertions, 27 deletions

diff --git a/libavcodec/hevcpred_template.c b/libavcodec/hevcpred_template.c
index 53b9c590b6..039882bb52 100644
--- a/libavcodec/hevcpred_template.c
+++ b/libavcodec/hevcpred_template.c
@@ -32,7 +32,7 @@ static av_always_inline void FUNC(intra_pred)(HEVCContext *s, int x0, int y0,
                                               int log2_size, int c_idx)
 {
 #define PU(x) \
-    ((x) >> s->sps->log2_min_pu_size)
+    ((x) >> s->ps.sps->log2_min_pu_size)
 #define MVF(x, y) \
     (s->ref->tab_mvf[(x) + (y) * min_pu_width])
 #define MVF_PU(x, y) \
@@ -40,7 +40,7 @@ static av_always_inline void FUNC(intra_pred)(HEVCContext *s, int x0, int y0,
 #define IS_INTRA(x, y) \
     MVF_PU(x, y).is_intra
 #define MIN_TB_ADDR_ZS(x, y) \
-    s->pps->min_tb_addr_zs[(y) * s->sps->min_tb_width + (x)]
+    s->ps.pps->min_tb_addr_zs[(y) * s->ps.sps->min_tb_width + (x)]
 
 #define EXTEND(ptr, val, len)         \
 do {                                  \
@@ -70,21 +70,21 @@ do {                                  \
                 ptr[i] = ptr[i - 1]
     HEVCLocalContext *lc = &s->HEVClc;
     int i;
-    int hshift = s->sps->hshift[c_idx];
-    int vshift = s->sps->vshift[c_idx];
+    int hshift = s->ps.sps->hshift[c_idx];
+    int vshift = s->ps.sps->vshift[c_idx];
     int size = (1 << log2_size);
     int size_in_luma = size << hshift;
-    int size_in_tbs = size_in_luma >> s->sps->log2_min_tb_size;
+    int size_in_tbs = size_in_luma >> s->ps.sps->log2_min_tb_size;
     int x = x0 >> hshift;
     int y = y0 >> vshift;
-    int x_tb = x0 >> s->sps->log2_min_tb_size;
-    int y_tb = y0 >> s->sps->log2_min_tb_size;
+    int x_tb = x0 >> s->ps.sps->log2_min_tb_size;
+    int y_tb = y0 >> s->ps.sps->log2_min_tb_size;
     int cur_tb_addr = MIN_TB_ADDR_ZS(x_tb, y_tb);
 
     ptrdiff_t stride = s->frame->linesize[c_idx] / sizeof(pixel);
     pixel *src = (pixel*)s->frame->data[c_idx] + x + y * stride;
 
-    int min_pu_width = s->sps->min_pu_width;
+    int min_pu_width = s->ps.sps->min_pu_width;
 
     enum IntraPredMode mode = c_idx ? lc->pu.intra_pred_mode_c :
                               lc->tu.cur_intra_pred_mode;
@@ -105,21 +105,21 @@ do {                                  \
     int cand_up          = lc->na.cand_up;
     int cand_up_right    = lc->na.cand_up_right && cur_tb_addr > MIN_TB_ADDR_ZS(x_tb + size_in_tbs, y_tb - 1);
 
-    int bottom_left_size = (FFMIN(y0 + 2 * size_in_luma, s->sps->height) -
+    int bottom_left_size = (FFMIN(y0 + 2 * size_in_luma, s->ps.sps->height) -
                             (y0 + size_in_luma)) >> vshift;
-    int top_right_size   = (FFMIN(x0 + 2 * size_in_luma, s->sps->width) -
+    int top_right_size   = (FFMIN(x0 + 2 * size_in_luma, s->ps.sps->width) -
                             (x0 + size_in_luma)) >> hshift;
 
-    if (s->pps->constrained_intra_pred_flag == 1) {
+    if (s->ps.pps->constrained_intra_pred_flag == 1) {
         int size_in_luma_pu = PU(size_in_luma);
-        int on_pu_edge_x    = !(x0 & ((1 << s->sps->log2_min_pu_size) - 1));
-        int on_pu_edge_y    = !(y0 & ((1 << s->sps->log2_min_pu_size) - 1));
+        int on_pu_edge_x    = !(x0 & ((1 << s->ps.sps->log2_min_pu_size) - 1));
+        int on_pu_edge_y    = !(y0 & ((1 << s->ps.sps->log2_min_pu_size) - 1));
         if (!size_in_luma_pu)
             size_in_luma_pu++;
         if (cand_bottom_left == 1 && on_pu_edge_x) {
             int x_left_pu   = PU(x0 - 1);
             int y_bottom_pu = PU(y0 + size_in_luma);
-            int max = FFMIN(size_in_luma_pu, s->sps->min_pu_height - y_bottom_pu);
+            int max = FFMIN(size_in_luma_pu, s->ps.sps->min_pu_height - y_bottom_pu);
             cand_bottom_left = 0;
             for (i = 0; i < max; i++)
                 cand_bottom_left |= MVF(x_left_pu, y_bottom_pu + i).is_intra;
@@ -127,7 +127,7 @@ do {                                  \
         if (cand_left == 1 && on_pu_edge_x) {
             int x_left_pu   = PU(x0 - 1);
             int y_left_pu   = PU(y0);
-            int max = FFMIN(size_in_luma_pu, s->sps->min_pu_height - y_left_pu);
+            int max = FFMIN(size_in_luma_pu, s->ps.sps->min_pu_height - y_left_pu);
             cand_left = 0;
             for (i = 0; i < max; i++)
                 cand_left |= MVF(x_left_pu, y_left_pu + i).is_intra;
@@ -140,7 +140,7 @@ do {                                  \
         if (cand_up == 1 && on_pu_edge_y) {
             int x_top_pu    = PU(x0);
             int y_top_pu    = PU(y0 - 1);
-            int max = FFMIN(size_in_luma_pu, s->sps->min_pu_width - x_top_pu);
+            int max = FFMIN(size_in_luma_pu, s->ps.sps->min_pu_width - x_top_pu);
             cand_up = 0;
             for (i = 0; i < max; i++)
                 cand_up |= MVF(x_top_pu + i, y_top_pu).is_intra;
@@ -148,7 +148,7 @@ do {                                  \
         if (cand_up_right == 1 && on_pu_edge_y) {
             int y_top_pu    = PU(y0 - 1);
             int x_right_pu  = PU(x0 + size_in_luma);
-            int max = FFMIN(size_in_luma_pu, s->sps->min_pu_width - x_right_pu);
+            int max = FFMIN(size_in_luma_pu, s->ps.sps->min_pu_width - x_right_pu);
             cand_up_right = 0;
             for (i = 0; i < max; i++)
                 cand_up_right |= MVF(x_right_pu + i, y_top_pu).is_intra;
@@ -179,20 +179,20 @@ do {                                  \
                size - top_right_size);
     }
 
-    if (s->pps->constrained_intra_pred_flag == 1) {
+    if (s->ps.pps->constrained_intra_pred_flag == 1) {
         if (cand_bottom_left || cand_left || cand_up_left || cand_up || cand_up_right) {
-            int size_max_x = x0 + ((2 * size) << hshift) < s->sps->width ?
-                                    2 * size : (s->sps->width - x0) >> hshift;
-            int size_max_y = y0 + ((2 * size) << vshift) < s->sps->height ?
-                                    2 * size : (s->sps->height - y0) >> vshift;
+            int size_max_x = x0 + ((2 * size) << hshift) < s->ps.sps->width ?
+                                    2 * size : (s->ps.sps->width - x0) >> hshift;
+            int size_max_y = y0 + ((2 * size) << vshift) < s->ps.sps->height ?
+                                    2 * size : (s->ps.sps->height - y0) >> vshift;
             int j = size + (cand_bottom_left? bottom_left_size: 0) -1;
             if (!cand_up_right) {
-                size_max_x = x0 + ((size) << hshift) < s->sps->width ?
-                                                    size : (s->sps->width - x0) >> hshift;
+                size_max_x = x0 + ((size) << hshift) < s->ps.sps->width ?
+                                                    size : (s->ps.sps->width - x0) >> hshift;
             }
             if (!cand_bottom_left) {
-                size_max_y = y0 + (( size) << vshift) < s->sps->height ?
-                                                     size : (s->sps->height - y0) >> vshift;
+                size_max_y = y0 + (( size) << vshift) < s->ps.sps->height ?
+                                                     size : (s->ps.sps->height - y0) >> vshift;
             }
             if (cand_bottom_left || cand_left || cand_up_left) {
                 while (j > -1 && !IS_INTRA(-1, j))
@@ -284,7 +284,7 @@ do {                                  \
                                       FFABS((int)mode - 10));
         if (min_dist_vert_hor > intra_hor_ver_dist_thresh[log2_size - 3]) {
             int threshold = 1 << (BIT_DEPTH - 5);
-            if (s->sps->sps_strong_intra_smoothing_enable_flag &&
+            if (s->ps.sps->sps_strong_intra_smoothing_enable_flag &&
                 log2_size == 5 &&
                 FFABS(top[-1]  + top[63]  - 2 * top[31])  < threshold &&
                 FFABS(left[-1] + left[63] - 2 * left[31]) < threshold) {