lavc/hevcdec: drop redundant HEVCContext.threads_{type,number}

They are useless duplicates of corresponding AVCodecContext fields.

Anton Khirnov committed 2 years ago

Commit e4e9e1d1 parent b0c29a45 files · +19 −32Browse files

Unified · Split

5 files

libavcodec/hevc/filter.c +3 −3
libavcodec/hevc/hevcdec.c +13 −23
libavcodec/hevc/hevcdec.h +0 −3
libavcodec/hevc/mvs.c +2 −2
libavcodec/hevc/refs.c +1 −1

@@ -892,15 +892,15 @@ void ff_hevc_hls_filter(HEVCLocalContext lc, const HEVCPPS pps, · 891 unmodified lines
892	sao_filter_CTB(lc, s, pps, sps, x - ctb_size, y);	892	sao_filter_CTB(lc, s, pps, sps, x - ctb_size, y);
893	if (y && x_end) {	893	if (y && x_end) {
894	sao_filter_CTB(lc, s, pps, sps, x, y - ctb_size);	894	sao_filter_CTB(lc, s, pps, sps, x, y - ctb_size);
895	if (s->threads_type & FF_THREAD_FRAME )	895	if (s->avctx->active_thread_type & FF_THREAD_FRAME )
896	ff_progress_frame_report(&s->cur_frame->tf, y);	896	ff_progress_frame_report(&s->cur_frame->tf, y);
897	}	897	}
898	if (x_end && y_end) {	898	if (x_end && y_end) {
899	sao_filter_CTB(lc, s, pps, sps, x , y);	899	sao_filter_CTB(lc, s, pps, sps, x , y);
900	if (s->threads_type & FF_THREAD_FRAME )	900	if (s->avctx->active_thread_type & FF_THREAD_FRAME )
901	ff_progress_frame_report(&s->cur_frame->tf, y + ctb_size);	901	ff_progress_frame_report(&s->cur_frame->tf, y + ctb_size);
902	}	902	}
903	} else if (s->threads_type & FF_THREAD_FRAME && x_end)	903	} else if (s->avctx->active_thread_type & FF_THREAD_FRAME && x_end)
904	ff_progress_frame_report(&s->cur_frame->tf, y + ctb_size - 4);	904	ff_progress_frame_report(&s->cur_frame->tf, y + ctb_size - 4);
905	}	905	}
906		906

libavcodec/hevc/hevcdec.c+13−23

                 unsigned val = get_bits_long(gb, offset_len);
                 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
             }
-            if (s->threads_number > 1 && (pps->num_tile_rows > 1 || pps->num_tile_columns > 1))
-                s->threads_number = 1;
         }
     }
 static void hevc_await_progress(const HEVCContext *s, const HEVCFrame *ref,
                                 const Mv *mv, int y0, int height)
 {
-    if (s->threads_type == FF_THREAD_FRAME ) {
+    if (s->avctx->active_thread_type == FF_THREAD_FRAME ) {
         int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
         ff_progress_frame_await(&ref->tf, y);
     return ctb_addr_ts;
 }
-static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *hevc_lclist,
+static int hls_decode_entry_wpp(AVCodecContext *avctx, void *hevc_lclist,
                                 int job, int self_id)
 {
     HEVCLocalContext *lc = &((HEVCLocalContext*)hevc_lclist)[self_id];
     int ctb_row = job;
     int ctb_addr_rs = s->sh.slice_ctb_addr_rs + ctb_row * ((sps->width + ctb_size - 1) >> sps->log2_ctb_size);
     int ctb_addr_ts = pps->ctb_addr_rs_to_ts[ctb_addr_rs];
-    int thread = ctb_row % s->threads_number;
+    int thread = ctb_row % avctx->thread_count;
     const uint8_t *data      = s->data + s->sh.offset[ctb_row];
     const size_t   data_size = s->sh.size[ctb_row];
         return AVERROR_INVALIDDATA;
     }
-    if (s->threads_number > s->nb_local_ctx) {
+    if (s->avctx->thread_count > s->nb_local_ctx) {
-        HEVCLocalContext *tmp = av_malloc_array(s->threads_number, sizeof(*s->local_ctx));
+        HEVCLocalContext *tmp = av_malloc_array(s->avctx->thread_count, sizeof(*s->local_ctx));
         if (!tmp)
             return AVERROR(ENOMEM);
         av_free(s->local_ctx);
         s->local_ctx = tmp;
-        for (unsigned i = s->nb_local_ctx; i < s->threads_number; i++) {
+        for (unsigned i = s->nb_local_ctx; i < s->avctx->thread_count; i++) {
             tmp = &s->local_ctx[i];
             memset(tmp, 0, sizeof(*tmp));
             tmp->common_cabac_state = &s->cabac;
         }
-        s->nb_local_ctx = s->threads_number;
+        s->nb_local_ctx = s->avctx->thread_count;
     }
     offset = s->sh.data_offset;
     s->data = data;
-    for (i = 1; i < s->threads_number; i++) {
+    for (i = 1; i < s->nb_local_ctx; i++) {
         s->local_ctx[i].first_qp_group = 1;
         s->local_ctx[i].qp_y = s->local_ctx[0].qp_y;
     }
                 goto fail;
             }
-            if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
+            if (s->avctx->active_thread_type == FF_THREAD_SLICE  &&
+                s->sh.num_entry_point_offsets > 0                &&
+                s->pps->num_tile_rows == 1 && s->pps->num_tile_columns == 1)
                 ctb_addr_ts = hls_slice_data_wpp(s, nal);
             else
                 ctb_addr_ts = hls_decode_entry(s, &gb);
     }
 fail:
-    if (s->cur_frame && s->threads_type == FF_THREAD_FRAME)
+    if (s->cur_frame && s->avctx->active_thread_type == FF_THREAD_FRAME)
         ff_progress_frame_report(&s->cur_frame->tf, INT_MAX);
     return ret;
     s->is_nalff        = s0->is_nalff;
     s->nal_length_size = s0->nal_length_size;
-    s->threads_number      = s0->threads_number;
-    s->threads_type        = s0->threads_type;
     s->film_grain_warning_shown = s0->film_grain_warning_shown;
     if (s0->eos) {
     int ret;
     if (avctx->active_thread_type & FF_THREAD_SLICE) {
-        s->threads_number = avctx->thread_count;
         ret = ff_slice_thread_init_progress(avctx);
         if (ret < 0)
             return ret;
-    } else
+    }
-        s->threads_number = 1;
-    if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
-        s->threads_type = FF_THREAD_FRAME;
-    else
-        s->threads_type = FF_THREAD_SLICE;
     ret = hevc_init_context(avctx);
     if (ret < 0)

libavcodec/hevc/hevcdec.h+0−3

@@ -453,9 +453,6 @@ typedef struct HEVCContext { · 452 unmodified lines
453	HEVCLocalContext *local_ctx;	453	HEVCLocalContext *local_ctx;
454	unsigned nb_local_ctx;	454	unsigned nb_local_ctx;
455		455
456	uint8_t threads_type;
457	uint8_t threads_number;
458
459	/** 1 if the independent slice segment header was successfully parsed */	456	/** 1 if the independent slice segment header was successfully parsed */
460	uint8_t slice_initialized;	457	uint8_t slice_initialized;
461		458

libavcodec/hevc/mvs.c+2−2

@@ -248,7 +248,7 @@ static int temporal_luma_motion_vector(const HEVCContext s, const HEVCSPS sps, · 247 unmodified lines
248	x < sps->width) {	248	x < sps->width) {
249	x &= ~15;	249	x &= ~15;
250	y &= ~15;	250	y &= ~15;
251	if (s->threads_type == FF_THREAD_FRAME)	251	if (s->avctx->active_thread_type == FF_THREAD_FRAME)
252	ff_progress_frame_await(&ref->tf, y);	252	ff_progress_frame_await(&ref->tf, y);
253	x_pu = x >> sps->log2_min_pu_size;	253	x_pu = x >> sps->log2_min_pu_size;
254	y_pu = y >> sps->log2_min_pu_size;	254	y_pu = y >> sps->log2_min_pu_size;
@@ -262,7 +262,7 @@ static int temporal_luma_motion_vector(const HEVCContext s, const HEVCSPS sps, · 7 unmodified lines
262	y = y0 + (nPbH >> 1);	262	y = y0 + (nPbH >> 1);
263	x &= ~15;	263	x &= ~15;
264	y &= ~15;	264	y &= ~15;
265	if (s->threads_type == FF_THREAD_FRAME)	265	if (s->avctx->active_thread_type == FF_THREAD_FRAME)
266	ff_progress_frame_await(&ref->tf, y);	266	ff_progress_frame_await(&ref->tf, y);
267	x_pu = x >> sps->log2_min_pu_size;	267	x_pu = x >> sps->log2_min_pu_size;
268	y_pu = y >> sps->log2_min_pu_size;	268	y_pu = y >> sps->log2_min_pu_size;

libavcodec/hevc/refs.c+1−1

@@ -435,7 +435,7 @@ static HEVCFrame generate_missing_ref(HEVCContext s, int poc) · 434 unmodified lines
435	frame->sequence = HEVC_SEQUENCE_COUNTER_INVALID;	435	frame->sequence = HEVC_SEQUENCE_COUNTER_INVALID;
436	frame->flags = 0;	436	frame->flags = 0;
437		437
438	if (s->threads_type == FF_THREAD_FRAME)	438	if (s->avctx->active_thread_type == FF_THREAD_FRAME)
439	ff_progress_frame_report(&frame->tf, INT_MAX);	439	ff_progress_frame_report(&frame->tf, INT_MAX);
440		440
441	return frame;	441	return frame;

lavc/hevcdec: drop redundant HEVCContext.threads_{type,number}

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code