diff --git a/media/libaudiohal/impl/StreamHalAidl.cpp b/media/libaudiohal/impl/StreamHalAidl.cpp
index 3048580..2c37349 100644
--- a/media/libaudiohal/impl/StreamHalAidl.cpp
+++ b/media/libaudiohal/impl/StreamHalAidl.cpp
@@ -478,19 +478,6 @@
     return OK;
 }
 
-status_t StreamHalAidl::getHalPid(pid_t *pid __unused) {
-    ALOGD("%p %s::%s", this, getClassName().c_str(), __func__);
-    TIME_CHECK();
-    if (!mStream) return NO_INIT;
-    ALOGE("%s not implemented yet", __func__);
-    return OK;
-}
-
-bool StreamHalAidl::requestHalThreadPriority(pid_t threadPid __unused, pid_t threadId __unused) {
-    // Obsolete, must be done by the HAL module.
-    return true;
-}
-
 status_t StreamHalAidl::legacyCreateAudioPatch(const struct audio_port_config& port __unused,
                                                std::optional<audio_source_t> source __unused,
                                                audio_devices_t type __unused) {
diff --git a/media/libaudiohal/impl/StreamHalAidl.h b/media/libaudiohal/impl/StreamHalAidl.h
index 147c131..75a1dd9 100644
--- a/media/libaudiohal/impl/StreamHalAidl.h
+++ b/media/libaudiohal/impl/StreamHalAidl.h
@@ -199,10 +199,6 @@
 
     ~StreamHalAidl() override;
 
-    status_t getHalPid(pid_t *pid);
-
-    bool requestHalThreadPriority(pid_t threadPid, pid_t threadId);
-
     status_t getLatency(uint32_t *latency);
 
     status_t getObservablePosition(int64_t *frames, int64_t *timestamp);
diff --git a/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.cpp b/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.cpp
index f1619a8..1fed9a5 100644
--- a/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.cpp
+++ b/media/libeffects/dynamicsproc/aidl/DynamicsProcessing.cpp
@@ -67,7 +67,7 @@
                 DynamicsProcessing::engineArchitecture>(DynamicsProcessing::EngineArchitecture(
                 {.resolutionPreference =
                          DynamicsProcessing::ResolutionPreference::FAVOR_FREQUENCY_RESOLUTION,
-                 .preferredProcessingDurationMs = 0,
+                 .preferredProcessingDurationMs = 1.0f,
                  .preEqStage = {.inUse = false, .bandCount = 0},
                  .postEqStage = {.inUse = false, .bandCount = 0},
                  .mbcStage = {.inUse = false, .bandCount = 0},
@@ -75,11 +75,11 @@
         .max = DynamicsProcessing::make<
                 DynamicsProcessing::engineArchitecture>(DynamicsProcessing::EngineArchitecture(
                 {.resolutionPreference =
-                         DynamicsProcessing::ResolutionPreference::FAVOR_FREQUENCY_RESOLUTION,
-                 .preferredProcessingDurationMs = std::numeric_limits<float>::max(),
-                 .preEqStage = {.inUse = true, .bandCount = std::numeric_limits<int>::max()},
-                 .postEqStage = {.inUse = true, .bandCount = std::numeric_limits<int>::max()},
-                 .mbcStage = {.inUse = true, .bandCount = std::numeric_limits<int>::max()},
+                         DynamicsProcessing::ResolutionPreference::FAVOR_TIME_RESOLUTION,
+                 .preferredProcessingDurationMs = 1000.0f,
+                 .preEqStage = {.inUse = true, .bandCount = 128},
+                 .postEqStage = {.inUse = true, .bandCount = 128},
+                 .mbcStage = {.inUse = true, .bandCount = 128},
                  .limiterInUse = true}))};
 
 static const DynamicsProcessing::ChannelConfig kChannelConfigMin =
@@ -105,15 +105,15 @@
         DynamicsProcessing::EqBandConfig({.channel = 0,
                                           .band = 0,
                                           .enable = false,
-                                          .cutoffFrequencyHz = 220,
-                                          .gainDb = std::numeric_limits<float>::lowest()});
+                                          .cutoffFrequencyHz = 20,
+                                          .gainDb = -200});
 
 static const DynamicsProcessing::EqBandConfig kEqBandConfigMax =
         DynamicsProcessing::EqBandConfig({.channel = std::numeric_limits<int>::max(),
                                           .band = std::numeric_limits<int>::max(),
                                           .enable = true,
                                           .cutoffFrequencyHz = 20000,
-                                          .gainDb = std::numeric_limits<float>::max()});
+                                          .gainDb = 200});
 
 static const Range::DynamicsProcessingRange kPreEqBandConfigRange = {
         .min = DynamicsProcessing::make<DynamicsProcessing::preEqBand>({kEqBandConfigMin}),
@@ -129,39 +129,39 @@
                         {.channel = 0,
                          .band = 0,
                          .enable = false,
-                         .cutoffFrequencyHz = 220,
+                         .cutoffFrequencyHz = 20,
                          .attackTimeMs = 0,
                          .releaseTimeMs = 0,
-                         .ratio = 0,
-                         .thresholdDb = std::numeric_limits<float>::lowest(),
+                         .ratio = 1,
+                         .thresholdDb = -200,
                          .kneeWidthDb = 0,
-                         .noiseGateThresholdDb = std::numeric_limits<float>::lowest(),
-                         .expanderRatio = 0,
-                         .preGainDb = std::numeric_limits<float>::lowest(),
-                         .postGainDb = std::numeric_limits<float>::lowest()})}),
+                         .noiseGateThresholdDb = -200,
+                         .expanderRatio = 1,
+                         .preGainDb = -200,
+                         .postGainDb = -200})}),
         .max = DynamicsProcessing::make<DynamicsProcessing::mbcBand>(
                 {DynamicsProcessing::MbcBandConfig(
                         {.channel = std::numeric_limits<int>::max(),
                          .band = std::numeric_limits<int>::max(),
                          .enable = true,
                          .cutoffFrequencyHz = 20000,
-                         .attackTimeMs = std::numeric_limits<float>::max(),
-                         .releaseTimeMs = std::numeric_limits<float>::max(),
-                         .ratio = std::numeric_limits<float>::max(),
-                         .thresholdDb = 0,
-                         .kneeWidthDb = std::numeric_limits<float>::max(),
-                         .noiseGateThresholdDb = 0,
-                         .expanderRatio = std::numeric_limits<float>::max(),
-                         .preGainDb = std::numeric_limits<float>::max(),
-                         .postGainDb = std::numeric_limits<float>::max()})})};
+                         .attackTimeMs = 60000,
+                         .releaseTimeMs = 60000,
+                         .ratio = 50,
+                         .thresholdDb = 200,
+                         .kneeWidthDb = 100,
+                         .noiseGateThresholdDb = 200,
+                         .expanderRatio = 50,
+                         .preGainDb = 200,
+                         .postGainDb = 200})})};
 
 static const Range::DynamicsProcessingRange kInputGainRange = {
         .min = DynamicsProcessing::make<DynamicsProcessing::inputGain>(
                 {DynamicsProcessing::InputGain(
-                        {.channel = 0, .gainDb = std::numeric_limits<float>::lowest()})}),
+                        {.channel = 0, .gainDb = -200.0f})}),
         .max = DynamicsProcessing::make<DynamicsProcessing::inputGain>(
                 {DynamicsProcessing::InputGain({.channel = std::numeric_limits<int>::max(),
-                                                .gainDb = std::numeric_limits<float>::max()})})};
+                                                .gainDb = 200.0f})})};
 
 static const Range::DynamicsProcessingRange kLimiterRange = {
         .min = DynamicsProcessing::make<DynamicsProcessing::limiter>(
@@ -171,19 +171,19 @@
                          .linkGroup = std::numeric_limits<int>::min(),
                          .attackTimeMs = 0,
                          .releaseTimeMs = 0,
-                         .ratio = 0,
-                         .thresholdDb = std::numeric_limits<float>::min(),
-                         .postGainDb = std::numeric_limits<float>::min()})}),
+                         .ratio = 1,
+                         .thresholdDb = -200,
+                         .postGainDb = -200})}),
         .max = DynamicsProcessing::make<DynamicsProcessing::limiter>(
                 {DynamicsProcessing::LimiterConfig(
                         {.channel = std::numeric_limits<int>::max(),
                          .enable = true,
                          .linkGroup = std::numeric_limits<int>::max(),
-                         .attackTimeMs = std::numeric_limits<float>::max(),
-                         .releaseTimeMs = std::numeric_limits<float>::max(),
-                         .ratio = std::numeric_limits<float>::max(),
-                         .thresholdDb = 0,
-                         .postGainDb = std::numeric_limits<float>::max()})})};
+                         .attackTimeMs = 60000,
+                         .releaseTimeMs = 60000,
+                         .ratio = 50,
+                         .thresholdDb = 200,
+                         .postGainDb = 200})})};
 
 const std::vector<Range::DynamicsProcessingRange> kRanges = {
         kEngineConfigRange,     kPreEqChannelConfigRange, kPostEqChannelConfigRange,
diff --git a/services/camera/libcameraservice/common/CameraProviderManager.cpp b/services/camera/libcameraservice/common/CameraProviderManager.cpp
index f7e02a8..2ebb98a 100644
--- a/services/camera/libcameraservice/common/CameraProviderManager.cpp
+++ b/services/camera/libcameraservice/common/CameraProviderManager.cpp
@@ -1172,10 +1172,8 @@
             static_cast<android_pixel_format_t>(HAL_PIXEL_FORMAT_YCBCR_P010), &supportedP010Sizes);
     auto it = supportedP010Sizes.begin();
     while (it != supportedP010Sizes.end()) {
-        // Resolutions that don't align on 32 pixels are not supported by Jpeg/R.
-        // This can be removed as soon as the encoder restriction is lifted.
-        if ((std::find(supportedBlobSizes.begin(), supportedBlobSizes.end(), *it) ==
-                supportedBlobSizes.end()) || ((std::get<0>(*it) % 32) != 0)) {
+        if (std::find(supportedBlobSizes.begin(), supportedBlobSizes.end(), *it) ==
+                supportedBlobSizes.end()) {
             it = supportedP010Sizes.erase(it);
         } else {
             it++;
diff --git a/services/tuner/mediatuner.rc b/services/tuner/mediatuner.rc
index 90a0090..8e5d100 100644
--- a/services/tuner/mediatuner.rc
+++ b/services/tuner/mediatuner.rc
@@ -4,6 +4,7 @@
 service media.tuner /system/bin/mediatuner
     class main
     group media
+    user root
     ioprio rt 4
     task_profiles ProcessCapacityHigh HighPerformance
     interface aidl media.tuner