Commit 8e4223ed94 for aom

commit 8e4223ed940b91e51074078b84e8736610eddecc
Author: Philipp Hancke <philipp.hancke@googlemail.com>
Date:   Fri Nov 13 21:09:53 2026 +0100

    svc: Scale a 1:4 spatial layer in two 1:2 steps

    This applies to SVC (L) and simulcast (S) modes with three spatial layers.

    A direct 4:1 scaling with phase 8 is off by one source pixel and aliases.
    Scaling with two 1:2 steps like VP9 (svc_twostage_scale() in libvpx)
    avoids that. The next spatial layer reuses the 1:2 intermediate.

    last_source is scaled the same way to keep source SAD comparable.
    datarate test is adjusted for cleaner base layer undershooting.

    Bug: 585429706
    Change-Id: I5ee077b693ec4d6667580cf52695557b0612560b

diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 786c899bd9..6f8b9f5901 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -2993,6 +2993,87 @@ static void update_motion_stat(AV1_COMP *const cpi) {
   }
 }

+static int is_quarter_scale(const AV1_COMP *cpi,
+                            const YV12_BUFFER_CONFIG *unscaled) {
+  const AV1_COMMON *const cm = &cpi->common;
+  const SVC *const svc = &cpi->svc;
+  return cpi->ppi->use_svc && !cm->seq_params->use_highbitdepth &&
+         svc->spatial_layer_id + 1 < svc->number_spatial_layers &&
+         unscaled->y_crop_width == cm->width << 2 &&
+         unscaled->y_crop_height == cm->height << 2;
+}
+
+static YV12_BUFFER_CONFIG *scale_twostage(AV1_COMP *cpi,
+                                          YV12_BUFFER_CONFIG *unscaled,
+                                          YV12_BUFFER_CONFIG *scaled,
+                                          YV12_BUFFER_CONFIG *half,
+                                          InterpFilter filter, int phase) {
+  AV1_COMMON *const cm = &cpi->common;
+  const SVC *const svc = &cpi->svc;
+  const SequenceHeader *const seq_params = cm->seq_params;
+  if (aom_realloc_frame_buffer(
+          half, cm->width << 1, cm->height << 1, seq_params->subsampling_x,
+          seq_params->subsampling_y, 0, cpi->oxcf.border_in_pixels,
+          cm->features.byte_alignment, NULL, NULL, NULL, cpi->alloc_pyramid,
+          0)) {
+    aom_internal_error(cm->error, AOM_CODEC_MEM_ERROR,
+                       "Failed to allocate two-stage scaling buffer");
+  }
+  av1_resize_and_extend_frame(
+      unscaled, half, svc->downsample_filter_type[svc->spatial_layer_id + 1],
+      svc->downsample_filter_phase[svc->spatial_layer_id + 1],
+      av1_num_planes(cm));
+  aom_remove_metadata_from_frame_buffer(half);
+  if (unscaled->metadata &&
+      aom_copy_metadata_to_frame_buffer(half, unscaled->metadata)) {
+    aom_internal_error(cm->error, AOM_CODEC_MEM_ERROR,
+                       "Failed to copy source metadata to scaled frame");
+  }
+  return av1_realloc_and_scale_if_required(
+      cm, half, scaled, filter, phase, true, false, cpi->oxcf.border_in_pixels,
+      cpi->alloc_pyramid);
+}
+
+static YV12_BUFFER_CONFIG *scale_source(AV1_COMP *cpi,
+                                        YV12_BUFFER_CONFIG *unscaled,
+                                        InterpFilter filter, int phase) {
+  AV1_COMMON *const cm = &cpi->common;
+  SVC *const svc = &cpi->svc;
+  if (is_quarter_scale(cpi, unscaled)) {
+    svc->source_half_valid = 1;
+    svc->source_half_superframe = svc->current_superframe;
+    svc->source_half_filter =
+        svc->downsample_filter_type[svc->spatial_layer_id + 1];
+    svc->source_half_phase =
+        svc->downsample_filter_phase[svc->spatial_layer_id + 1];
+    return scale_twostage(cpi, unscaled, &cpi->scaled_source, &svc->source_half,
+                          filter, phase);
+  }
+  if (svc->source_half_valid &&
+      svc->source_half_superframe == svc->current_superframe &&
+      unscaled->y_crop_width == cm->width << 1 &&
+      unscaled->y_crop_height == cm->height << 1 &&
+      svc->source_half.y_crop_width == cm->width &&
+      svc->source_half.y_crop_height == cm->height &&
+      svc->source_half_filter == filter && svc->source_half_phase == phase) {
+    int keep_source_half = cpi->ppi->b_freeze_internal_state;
+#if CONFIG_AV1_TEMPORAL_DENOISING
+    if (cpi->oxcf.noise_sensitivity > 0) keep_source_half = 0;
+#endif
+    if (!keep_source_half) svc->source_half_valid = 0;
+    aom_remove_metadata_from_frame_buffer(&svc->source_half);
+    if (unscaled->metadata && aom_copy_metadata_to_frame_buffer(
+                                  &svc->source_half, unscaled->metadata)) {
+      aom_internal_error(cm->error, AOM_CODEC_MEM_ERROR,
+                         "Failed to copy source metadata to scaled frame");
+    }
+    return &svc->source_half;
+  }
+  return av1_realloc_and_scale_if_required(
+      cm, unscaled, &cpi->scaled_source, filter, phase, true, false,
+      cpi->oxcf.border_in_pixels, cpi->alloc_pyramid);
+}
+
 /*!\brief Encode a frame without the recode loop, usually used in one-pass
  * encoding and realtime coding.
  *
@@ -3087,9 +3168,7 @@ static int encode_without_recode(AV1_COMP *cpi) {
   }
 #endif

-  cpi->source = av1_realloc_and_scale_if_required(
-      cm, unscaled, &cpi->scaled_source, filter_scaler, phase_scaler, true,
-      false, cpi->oxcf.border_in_pixels, cpi->alloc_pyramid);
+  cpi->source = scale_source(cpi, unscaled, filter_scaler, phase_scaler);
   if (cpi->oxcf.mode != ALLINTRA &&
       (frame_is_intra_only(cm) || resize_pending != 0 ||
        cpi->consec_zero_mv == NULL)) {
@@ -3111,10 +3190,15 @@ static int encode_without_recode(AV1_COMP *cpi) {
     cpi->last_source = &cpi->scaled_last_source;
     cpi->scaled_last_source_available = 0;
   } else if (cpi->unscaled_last_source != NULL) {
-    cpi->last_source = av1_realloc_and_scale_if_required(
-        cm, cpi->unscaled_last_source, &cpi->scaled_last_source, filter_scaler,
-        phase_scaler, true, false, cpi->oxcf.border_in_pixels,
-        cpi->alloc_pyramid);
+    cpi->last_source =
+        is_quarter_scale(cpi, cpi->unscaled_last_source)
+            ? scale_twostage(cpi, cpi->unscaled_last_source,
+                             &cpi->scaled_last_source, &svc->last_source_half,
+                             filter_scaler, phase_scaler)
+            : av1_realloc_and_scale_if_required(
+                  cm, cpi->unscaled_last_source, &cpi->scaled_last_source,
+                  filter_scaler, phase_scaler, true, false,
+                  cpi->oxcf.border_in_pixels, cpi->alloc_pyramid);
   }

   if (cpi->sf.rt_sf.use_temporal_noise_estimate) {
diff --git a/av1/encoder/encoder_alloc.h b/av1/encoder/encoder_alloc.h
index 687237b398..5d14e5d279 100644
--- a/av1/encoder/encoder_alloc.h
+++ b/av1/encoder/encoder_alloc.h
@@ -429,6 +429,8 @@ static inline void dealloc_compressor_data(AV1_COMP *cpi) {
   aom_free_frame_buffer(&cpi->scaled_last_source);
   aom_free_frame_buffer(&cpi->orig_source);
   aom_free_frame_buffer(&cpi->svc.source_last_TL0);
+  aom_free_frame_buffer(&cpi->svc.source_half);
+  aom_free_frame_buffer(&cpi->svc.last_source_half);

   free_token_info(token_info);

diff --git a/av1/encoder/svc_layercontext.c b/av1/encoder/svc_layercontext.c
index 1420f47edc..88d07e31c8 100644
--- a/av1/encoder/svc_layercontext.c
+++ b/av1/encoder/svc_layercontext.c
@@ -31,6 +31,7 @@ void av1_init_layer_context(AV1_COMP *const cpi) {
   int mi_cols = cpi->common.mi_params.mi_cols;
   svc->base_framerate = 30.0;
   svc->current_superframe = 0;
+  svc->source_half_valid = 0;
   svc->force_zero_mode_spatial_ref = 1;
   svc->num_encoded_top_layer = 0;
   svc->use_flexible_mode = 0;
@@ -463,8 +464,16 @@ void av1_one_pass_cbr_svc_start_layer(AV1_COMP *const cpi) {
                            cpi->oxcf.frm_dim_cfg.height, lc->scaling_factor_num,
                            lc->scaling_factor_den, &width, &height);
   // Use Eightap_smooth for low resolutions.
-  if (width * height <= 320 * 240)
-    svc->downsample_filter_type[svc->spatial_layer_id] = EIGHTTAP_SMOOTH;
+  for (int sl = 0; sl < svc->number_spatial_layers; ++sl) {
+    const LAYER_CONTEXT *const lc_sl =
+        &svc->layer_context[sl * svc->number_temporal_layers +
+                            svc->temporal_layer_id];
+    int w = 0, h = 0;
+    av1_get_layer_resolution(
+        cpi->oxcf.frm_dim_cfg.width, cpi->oxcf.frm_dim_cfg.height,
+        lc_sl->scaling_factor_num, lc_sl->scaling_factor_den, &w, &h);
+    if (w * h <= 320 * 240) svc->downsample_filter_type[sl] = EIGHTTAP_SMOOTH;
+  }

   cm->width = width;
   cm->height = height;
diff --git a/av1/encoder/svc_layercontext.h b/av1/encoder/svc_layercontext.h
index ff052f25e7..4425e76a56 100644
--- a/av1/encoder/svc_layercontext.h
+++ b/av1/encoder/svc_layercontext.h
@@ -109,6 +109,12 @@ typedef struct SVC {
   int num_encoded_top_layer;
   int first_layer_denoise;
   YV12_BUFFER_CONFIG source_last_TL0;
+  YV12_BUFFER_CONFIG source_half;
+  YV12_BUFFER_CONFIG last_source_half;
+  unsigned int source_half_superframe;
+  int source_half_valid;
+  InterpFilter source_half_filter;
+  int source_half_phase;
   /*!\endcond */

   /*!
diff --git a/test/encode_api_test.cc b/test/encode_api_test.cc
index b134d46491..0a390a97f7 100644
--- a/test/encode_api_test.cc
+++ b/test/encode_api_test.cc
@@ -2622,18 +2622,21 @@ TEST(EncodeAPI, FreezeInternalStateSVC) {
   ASSERT_EQ(aom_codec_control(&enc, AOME_SET_CPUUSED, 7), AOM_CODEC_OK);

   aom_svc_params_t svc_params = {};
-  svc_params.number_spatial_layers = 2;
+  svc_params.number_spatial_layers = 3;
   svc_params.number_temporal_layers = 1;
-  svc_params.max_quantizers[0] = 56;
-  svc_params.min_quantizers[0] = 10;
-  svc_params.max_quantizers[1] = 56;
-  svc_params.min_quantizers[1] = 10;
+  for (int i = 0; i < 3; ++i) {
+    svc_params.max_quantizers[i] = 56;
+    svc_params.min_quantizers[i] = 10;
+  }
   svc_params.scaling_factor_num[0] = 1;
-  svc_params.scaling_factor_den[0] = 2;
+  svc_params.scaling_factor_den[0] = 4;
   svc_params.scaling_factor_num[1] = 1;
-  svc_params.scaling_factor_den[1] = 1;
-  svc_params.layer_target_bitrate[0] = cfg.rc_target_bitrate * 2 / 3;
-  svc_params.layer_target_bitrate[1] = cfg.rc_target_bitrate;
+  svc_params.scaling_factor_den[1] = 2;
+  svc_params.scaling_factor_num[2] = 1;
+  svc_params.scaling_factor_den[2] = 1;
+  svc_params.layer_target_bitrate[0] = cfg.rc_target_bitrate / 4;
+  svc_params.layer_target_bitrate[1] = cfg.rc_target_bitrate / 2;
+  svc_params.layer_target_bitrate[2] = cfg.rc_target_bitrate;
   svc_params.framerate_factor[0] = 1;
   ASSERT_EQ(aom_codec_control(&enc, AV1E_SET_SVC_PARAMS, &svc_params),
             AOM_CODEC_OK);
diff --git a/test/metadata_test.cc b/test/metadata_test.cc
index c34f4da514..3d42081502 100644
--- a/test/metadata_test.cc
+++ b/test/metadata_test.cc
@@ -11,6 +11,7 @@

 #include "gtest/gtest.h"

+#include <array>
 #include <cstring>
 #include <string>

@@ -266,11 +267,11 @@ class MetadataMultilayerEncodeTest
                                    AOM_MIF_ANY_FRAME),
               0);

-    ASSERT_EQ(
-        aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_ITUT_T35,
-                             kMetadataPayloadT35Two, kMetadataPayloadSizeT35Two,
-                             AOM_MIF_ANY_FRAME_LAYER_SPECIFIC),
-        0);
+    const auto layer_payload = LayerSpecificPayload(spatial_layer_id);
+    ASSERT_EQ(aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_ITUT_T35,
+                                   layer_payload.data(), layer_payload.size(),
+                                   AOM_MIF_ANY_FRAME_LAYER_SPECIFIC),
+              0);

     ASSERT_EQ(aom_img_add_metadata(current_frame, OBU_METADATA_TYPE_HDR_MDCV,
                                    kMetadataPayloadMdcv,
@@ -312,6 +313,7 @@ class MetadataMultilayerEncodeTest
   void DecompressedFrameHook(const aom_image_t &img,
                              aom_codec_pts_t /*pts*/) override {
     const bool is_key_frame = (num_decompressed_frames_ == 0);
+    const int spatial_layer_id = num_decompressed_frames_ % kNumSpatialLayers;

     ++num_decompressed_frames_;

@@ -331,7 +333,8 @@ class MetadataMultilayerEncodeTest
     ASSERT_EQ(metadata->type, OBU_METADATA_TYPE_ITUT_T35);
     ASSERT_EQ(metadata->insert_flag, AOM_MIF_ANY_FRAME_LAYER_SPECIFIC);
     ASSERT_EQ(metadata->sz, kMetadataPayloadSizeT35Two);
-    EXPECT_EQ(memcmp(kMetadataPayloadT35Two, metadata->payload,
+    const auto layer_payload = LayerSpecificPayload(spatial_layer_id);
+    EXPECT_EQ(memcmp(layer_payload.data(), metadata->payload,
                      kMetadataPayloadSizeT35Two),
               0);

@@ -355,6 +358,14 @@ class MetadataMultilayerEncodeTest
   }

  private:
+  static std::array<uint8_t, kMetadataPayloadSizeT35Two> LayerSpecificPayload(
+      int spatial_layer_id) {
+    std::array<uint8_t, kMetadataPayloadSizeT35Two> payload;
+    memcpy(payload.data(), kMetadataPayloadT35Two, payload.size());
+    payload.back() = spatial_layer_id;
+    return payload;
+  }
+
   aom_svc_params_t GetSvcParams() {
     aom_svc_params_t svc_params = {};
     svc_params.number_spatial_layers = kNumSpatialLayers;
diff --git a/test/svc_datarate_test.cc b/test/svc_datarate_test.cc
index 891ca6869d..f646bb50ce 100644
--- a/test/svc_datarate_test.cc
+++ b/test/svc_datarate_test.cc
@@ -1696,7 +1696,7 @@ class DatarateTestSVC
     ResetModel();
     SetTargetBitratesFor3SL1TL();
     ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
-    CheckDatarate(0.80, 1.38);
+    CheckDatarate(0.79, 1.38);
   }

   virtual void BasicRateTargetingSVC1TL3SLLastIsScaledTest() {
@@ -1711,7 +1711,7 @@ class DatarateTestSVC
     use_last_as_scaled_ = true;
     SetTargetBitratesFor3SL1TL();
     ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
-    CheckDatarate(0.80, 1.38);
+    CheckDatarate(0.75, 1.38);
   }

   virtual void BasicRateTargetingSVC1TL3SLLastIsScaledSingleRefTest() {
@@ -1727,7 +1727,7 @@ class DatarateTestSVC
     use_last_as_scaled_single_ref_ = true;
     SetTargetBitratesFor3SL1TL();
     ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
-    CheckDatarate(0.80, 1.38);
+    CheckDatarate(0.79, 1.38);
   }

   virtual void BasicRateTargetingSVC1TL3SLMultiRefTest() {
@@ -1742,7 +1742,7 @@ class DatarateTestSVC
     multi_ref_ = 1;
     SetTargetBitratesFor3SL1TL();
     ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
-    CheckDatarate(0.80, 1.38);
+    CheckDatarate(0.79, 1.38);
   }

   virtual void BasicRateTargetingSVC3TL3SLTest() {