From b4f66dad3b5357968963a73559c4033a702f2814 Mon Sep 17 00:00:00 2001
From: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
Date: Wed, 30 Apr 2025 03:23:01 +0200
Subject: [PATCH 34/44] avcodec/mpegvideo_enc: Simplify allocating non-slice
buffers
Allocate them before the slice contexts, so that they are automatically
copied to the slice contexts. This avoids having to set them in a loop.
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
libavcodec/mpegvideo_enc.c | 142 ++++++++++++++++++-------------------
1 file changed, 70 insertions(+), 72 deletions(-)
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 031647fa53..f1de7f6ff6 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -443,41 +443,22 @@ static av_cold int init_matrices(MPVMainEncContext *const m, AVCodecContext *avc
return 0;
}
-static av_cold int init_buffers(MPVMainEncContext *const m, AVCodecContext *avctx)
+static av_cold int init_buffers(MPVMainEncContext *const m)
{
MPVEncContext *const s = &m->s;
- // Align the following per-thread buffers to avoid false sharing.
- enum {
-#ifndef _MSC_VER
- /// The number is supposed to match/exceed the cache-line size.
- ALIGN = FFMAX(128, _Alignof(max_align_t)),
-#else
- ALIGN = 128,
-#endif
- DCT_ERROR_SIZE = FFALIGN(2 * sizeof(*s->dct_error_sum), ALIGN),
- };
- static_assert(DCT_ERROR_SIZE * MAX_THREADS + ALIGN - 1 <= SIZE_MAX,
- "Need checks for potential overflow.");
- unsigned nb_slices = s->c.slice_context_count, mv_table_size, mb_array_size;
- char *dct_error = NULL;
+ unsigned mv_table_size, mb_array_size;
int has_b_frames = !!m->max_b_frames, nb_mv_tables = 1 + 5 * has_b_frames;
int16_t (*mv_table)[2];
- if (m->noise_reduction) {
- if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_offset, 2))
- return AVERROR(ENOMEM);
- dct_error = av_mallocz(ALIGN - 1 + nb_slices * DCT_ERROR_SIZE);
- if (!dct_error)
- return AVERROR(ENOMEM);
- m->dct_error_sum_base = dct_error;
- dct_error += FFALIGN((uintptr_t)dct_error, ALIGN) - (uintptr_t)dct_error;
- }
-
/* Allocate MB type table */
mb_array_size = s->c.mb_stride * s->c.mb_height;
s->mb_type = av_calloc(mb_array_size, 3 * sizeof(*s->mb_type) + sizeof(*s->mb_mean));
if (!s->mb_type)
return AVERROR(ENOMEM);
+ s->mc_mb_var = s->mb_type + mb_array_size;
+ s->mb_var = s->mc_mb_var + mb_array_size;
+ s->mb_mean = (uint8_t*)(s->mb_var + mb_array_size);
+
if (!FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size))
return AVERROR(ENOMEM);
@@ -485,8 +466,10 @@ static av_cold int init_buffers(MPVMainEncContext *const m, AVCodecContext *avct
if (s->c.codec_id == AV_CODEC_ID_MPEG4 ||
(s->c.avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
nb_mv_tables += 8 * has_b_frames;
- if (!ALLOCZ_ARRAYS(s->p_field_select_table[0], 2 * (2 + 4 * has_b_frames), mv_table_size))
+ s->p_field_select_table[0] = av_calloc(mv_table_size, 2 * (2 + 4 * has_b_frames));
+ if (!s->p_field_select_table[0])
return AVERROR(ENOMEM);
+ s->p_field_select_table[1] = s->p_field_select_table[0] + 2 * mv_table_size;
}
mv_table = av_calloc(mv_table_size, nb_mv_tables * sizeof(*mv_table));
@@ -495,43 +478,21 @@ static av_cold int init_buffers(MPVMainEncContext *const m, AVCodecContext *avct
m->mv_table_base = mv_table;
mv_table += s->c.mb_stride + 1;
- for (unsigned i = 0; i < nb_slices; ++i) {
- MPVEncContext *const s2 = s->c.enc_contexts[i];
- int16_t (*tmp_mv_table)[2] = mv_table;
-
- if (dct_error) {
- s2->dct_offset = s->dct_offset;
- s2->dct_error_sum = (void*)dct_error;
- dct_error += DCT_ERROR_SIZE;
- }
-
- s2->mb_type = s->mb_type;
- s2->mc_mb_var = s2->mb_type + mb_array_size;
- s2->mb_var = s2->mc_mb_var + mb_array_size;
- s2->mb_mean = (uint8_t*)(s2->mb_var + mb_array_size);
- s2->lambda_table = s->lambda_table;
-
- s2->p_mv_table = tmp_mv_table;
- if (has_b_frames) {
- s2->b_forw_mv_table = tmp_mv_table += mv_table_size;
- s2->b_back_mv_table = tmp_mv_table += mv_table_size;
- s2->b_bidir_forw_mv_table = tmp_mv_table += mv_table_size;
- s2->b_bidir_back_mv_table = tmp_mv_table += mv_table_size;
- s2->b_direct_mv_table = tmp_mv_table += mv_table_size;
- }
-
- if (s->p_field_select_table[0]) { // MPEG-4 or INTERLACED_ME above
- uint8_t *field_select = s->p_field_select_table[0];
- s2->p_field_select_table[0] = field_select;
- s2->p_field_select_table[1] = field_select += 2 * mv_table_size;
-
- if (has_b_frames) {
- for (int j = 0; j < 2; j++) {
- for (int k = 0; k < 2; k++) {
- for (int l = 0; l < 2; l++)
- s2->b_field_mv_table[j][k][l] = tmp_mv_table += mv_table_size;
- s2->b_field_select_table[j][k] = field_select += 2 * mv_table_size;
- }
+ s->p_mv_table = mv_table;
+ if (has_b_frames) {
+ s->b_forw_mv_table = mv_table += mv_table_size;
+ s->b_back_mv_table = mv_table += mv_table_size;
+ s->b_bidir_forw_mv_table = mv_table += mv_table_size;
+ s->b_bidir_back_mv_table = mv_table += mv_table_size;
+ s->b_direct_mv_table = mv_table += mv_table_size;
+
+ if (s->p_field_select_table[1]) { // MPEG-4 or INTERLACED_ME above
+ uint8_t *field_select = s->p_field_select_table[1];
+ for (int j = 0; j < 2; j++) {
+ for (int k = 0; k < 2; k++) {
+ for (int l = 0; l < 2; l++)
+ s->b_field_mv_table[j][k][l] = mv_table += mv_table_size;
+ s->b_field_select_table[j][k] = field_select += 2 * mv_table_size;
}
}
}
@@ -540,6 +501,44 @@ static av_cold int init_buffers(MPVMainEncContext *const m, AVCodecContext *avct
return 0;
}
+static av_cold int init_slice_buffers(MPVMainEncContext *const m)
+{
+ MPVEncContext *const s = &m->s;
+ // Align the following per-thread buffers to avoid false sharing.
+ enum {
+#ifndef _MSC_VER
+ /// The number is supposed to match/exceed the cache-line size.
+ ALIGN = FFMAX(128, _Alignof(max_align_t)),
+#else
+ ALIGN = 128,
+#endif
+ DCT_ERROR_SIZE = FFALIGN(2 * sizeof(*s->dct_error_sum), ALIGN),
+ };
+ static_assert(DCT_ERROR_SIZE * MAX_THREADS + ALIGN - 1 <= SIZE_MAX,
+ "Need checks for potential overflow.");
+ unsigned nb_slices = s->c.slice_context_count;
+
+ if (!m->noise_reduction)
+ return 0;
+
+ if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_offset, 2))
+ return AVERROR(ENOMEM);
+ char *dct_error = av_mallocz(ALIGN - 1 + nb_slices * DCT_ERROR_SIZE);
+ if (!dct_error)
+ return AVERROR(ENOMEM);
+ m->dct_error_sum_base = dct_error;
+ dct_error += FFALIGN((uintptr_t)dct_error, ALIGN) - (uintptr_t)dct_error;
+
+ for (unsigned i = 0; i < nb_slices; ++i) {
+ MPVEncContext *const s2 = s->c.enc_contexts[i];
+
+ s2->dct_offset = s->dct_offset;
+ s2->dct_error_sum = (void*)dct_error;
+ dct_error += DCT_ERROR_SIZE;
+ }
+ return 0;
+}
+
/* init video encoder */
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
{
@@ -1056,20 +1055,19 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
ret = ff_mpv_common_init(&s->c);
if (ret < 0)
return ret;
- ret = ff_mpv_init_duplicate_contexts(&s->c);
+ ret = init_buffers(m);
if (ret < 0)
return ret;
-
if (s->c.slice_context_count > 1) {
- for (int i = 0; i < s->c.slice_context_count; ++i) {
- s->c.enc_contexts[i]->rtp_mode = 1;
-
- if (avctx->codec_id == AV_CODEC_ID_H263P)
- s->c.enc_contexts[i]->c.h263_slice_structured = 1;
- }
+ s->rtp_mode = 1;
+ if (avctx->codec_id == AV_CODEC_ID_H263P)
+ s->c.h263_slice_structured = 1;
}
+ ret = ff_mpv_init_duplicate_contexts(&s->c);
+ if (ret < 0)
+ return ret;
- ret = init_buffers(m, avctx);
+ ret = init_slice_buffers(m);
if (ret < 0)
return ret;
--
2.45.2