Support of the new profile rext_tiles

Author: AlexandreSanchez

libavcodec/hevc.c

@@ -1006,7 +1006,7 @@ else
         sh->num_entry_point_offsets = get_ue_golomb_long(gb);
         print_cabac("num_entry_point_offsets", sh->num_entry_point_offsets);
         if(s->pps->entropy_coding_sync_enabled_flag) {
-            if(sh->num_entry_point_offsets > s->sps->ctb_height || sh->num_entry_point_offsets < 0) {
+            if(sh->num_entry_point_offsets < 0) {
                 av_log(s->avctx, AV_LOG_ERROR,
                    "The number of entries %d is higher than the number of CTB rows %d \n",
                    sh->num_entry_point_offsets,
@@ -2650,6 +2650,7 @@ static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
         }
 
         ctb_addr_ts++;
+        s->HEVClc->ctb_tile_rs++;
         ff_hevc_save_states(s, ctb_addr_ts);
         ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
     }
@@ -2939,7 +2940,9 @@ static int hls_slice_data(HEVCContext *s, const uint8_t *nal, int length)
         ff_reset_entries(s->avctx);
     }
     s->data = nal;
+    s->HEVClc->ctb_tile_rs = 0;
     for (i = 1; i < s->threads_number; i++) {
+        s->sList[i]->HEVClc->ctb_tile_rs = 0;
         s->sList[i]->HEVClc->first_qp_group = 1;
         s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
         memcpy(s->sList[i], s, sizeof(HEVCContext));

libavcodec/hevc.h

@@ -837,6 +837,7 @@ typedef struct HEVCPPS {
     int *ctb_addr_rs_to_ts; ///< CtbAddrRSToTS
     int *ctb_addr_ts_to_rs; ///< CtbAddrTSToRS
     int *tile_id;           ///< TileId
+    int *tile_width;           ///< TileWidth
     int *tile_pos_rs;       ///< TilePosRS
     int *min_tb_addr_zs;    ///< MinTbAddrZS
     int *min_tb_addr_zs_tab;///< MinTbAddrZS
@@ -1093,6 +1094,7 @@ typedef struct HEVCLocalContext {
     uint8_t slice_or_tiles_left_boundary;
     uint8_t slice_or_tiles_up_boundary;
 
+    int ctb_tile_rs;
 
 } HEVCLocalContext;
 

libavcodec/hevc_cabac.c

@@ -500,9 +500,9 @@ static const uint8_t diag_scan8x8_inv[8][8] = {
 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
 {
     if (s->pps->entropy_coding_sync_enabled_flag &&
-        (ctb_addr_ts % s->sps->ctb_width == 2 ||
-         (s->sps->ctb_width == 2 &&
-          ctb_addr_ts % s->sps->ctb_width == 0))) {
+        (s->HEVClc->ctb_tile_rs % s->pps->tile_width[ctb_addr_ts-1] == 2 ||
+         (s->pps->tile_width[ctb_addr_ts-1] == 2 &&
+          s->HEVClc->ctb_tile_rs % s->pps->tile_width[ctb_addr_ts-1] == 0))) {
         memcpy(s->cabac_state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
     }
 }
@@ -562,8 +562,8 @@ void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
 
         if (!s->sh.first_slice_in_pic_flag &&
             s->pps->entropy_coding_sync_enabled_flag) {
-            if (ctb_addr_ts % s->sps->ctb_width == 0) {
-                if (s->sps->ctb_width == 1)
+             if (s->HEVClc->ctb_tile_rs % s->pps->tile_width[ctb_addr_ts] == 0) {
+                if (s->pps->tile_width[ctb_addr_ts] == 1)
                     cabac_init_state(s);
                 else if (s->sh.dependent_slice_segment_flag == 1)
                     load_states(s);
@@ -572,24 +572,31 @@ void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
     } else {
         if (s->pps->tiles_enabled_flag &&
             s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
+
+            s->HEVClc->ctb_tile_rs = 0;
             if (s->threads_number == 1)
                 cabac_reinit(s->HEVClc);
             else
                 cabac_init_decoder(s);
             cabac_init_state(s);
         }
         if (s->pps->entropy_coding_sync_enabled_flag) {
-            if (ctb_addr_ts % s->sps->ctb_width == 0) {
-                get_cabac_terminate(&s->HEVClc->cc);
-                if (s->threads_number == 1)
-                    cabac_reinit(s->HEVClc);
-                else
-                    cabac_init_decoder(s);
+            if (s->HEVClc->ctb_tile_rs % s->pps->tile_width[ctb_addr_ts] == 0) {
+                if (!s->pps->tiles_enabled_flag ||
+                    (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[ctb_addr_ts - 1])) {
+                    get_cabac_terminate(&s->HEVClc->cc);
 
-                if (s->sps->ctb_width == 1)
-                    cabac_init_state(s);
-                else
-                    load_states(s);
+                    if (s->threads_number == 1)
+                        cabac_reinit(s->HEVClc);
+                    else
+                        cabac_init_decoder(s);
+
+
+                    if (s->pps->tile_width[ctb_addr_ts] == 1)
+                        cabac_init_state(s);
+                    else
+                        load_states(s);
+                }
             }
         }
     }

libavcodec/hevc_ps.c

@@ -2069,6 +2069,7 @@ static void hevc_pps_free(void *opaque, uint8_t *data)
     av_freep(&pps->ctb_addr_ts_to_rs);
     av_freep(&pps->tile_pos_rs);
     av_freep(&pps->tile_id);
+    av_freep(&pps->tile_width);
     av_freep(&pps->min_tb_addr_zs_tab);
 
     av_freep(&pps);
@@ -2472,8 +2473,9 @@ int ff_hevc_decode_nal_pps(HEVCContext *s)
     pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs,    sizeof(*pps->ctb_addr_ts_to_rs));
     pps->tile_id           = av_malloc_array(pic_area_in_ctbs,    sizeof(*pps->tile_id));
     pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
+    pps->tile_width        = av_malloc_array(pic_area_in_ctbs,    sizeof(*pps->tile_width));
     if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
-        !pps->tile_id || !pps->min_tb_addr_zs_tab) {
+        !pps->tile_id || !pps->min_tb_addr_zs_tab || !pps->tile_width) {
         ret = AVERROR(ENOMEM);
         goto err;
     }
@@ -2514,8 +2516,10 @@ int ff_hevc_decode_nal_pps(HEVCContext *s)
     for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
         for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
             for (y = row_bd[j]; y < row_bd[j + 1]; y++)
-                for (x = col_bd[i]; x < col_bd[i + 1]; x++)
+                for (x = col_bd[i]; x < col_bd[i + 1]; x++) {
                     pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
+                    pps->tile_width[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = pps->column_width[tile_id % pps->num_tile_columns];
+                }
 
     pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
     if (!pps->tile_pos_rs) {