diff --git a/media/libmediatranscoding/transcoder/benchmark/MediaTrackTranscoderBenchmark.cpp b/media/libmediatranscoding/transcoder/benchmark/MediaTrackTranscoderBenchmark.cpp
index e15186c..94bdcb3 100644
--- a/media/libmediatranscoding/transcoder/benchmark/MediaTrackTranscoderBenchmark.cpp
+++ b/media/libmediatranscoding/transcoder/benchmark/MediaTrackTranscoderBenchmark.cpp
@@ -216,7 +216,8 @@
 };
 
 static std::shared_ptr<AMediaFormat> GetDefaultTrackFormat(MediaType mediaType,
-                                                           AMediaFormat* sourceFormat) {
+                                                           AMediaFormat* sourceFormat,
+                                                           bool maxOperatingRate) {
     // Default video config.
     static constexpr int32_t kVideoBitRate = 20 * 1000 * 1000;  // 20 mbps
     static constexpr float kVideoFrameRate = 30.0f;             // 30 fps
@@ -229,6 +230,11 @@
         AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, AMEDIA_MIMETYPE_VIDEO_AVC);
         AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_BIT_RATE, kVideoBitRate);
         AMediaFormat_setFloat(format, AMEDIAFORMAT_KEY_FRAME_RATE, kVideoFrameRate);
+
+        if (maxOperatingRate) {
+            AMediaFormat_setFloat(format, AMEDIAFORMAT_KEY_OPERATING_RATE, INT32_MAX);
+            AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_PRIORITY, 1);
+        }
     }
     // nothing for audio.
 
@@ -282,7 +288,7 @@
  */
 static bool ConfigureSampleReader(const std::shared_ptr<MediaTrackTranscoder>& transcoder,
                                   const std::shared_ptr<MediaSampleReader>& sampleReader,
-                                  MediaType mediaType) {
+                                  MediaType mediaType, bool maxOperatingRate) {
     int srcTrackIndex = -1;
     std::shared_ptr<AMediaFormat> srcTrackFormat = nullptr;
 
@@ -312,7 +318,8 @@
         return false;
     }
 
-    auto destinationFormat = GetDefaultTrackFormat(mediaType, srcTrackFormat.get());
+    auto destinationFormat =
+            GetDefaultTrackFormat(mediaType, srcTrackFormat.get(), maxOperatingRate);
     status = transcoder->configure(sampleReader, srcTrackIndex, destinationFormat);
     if (status != AMEDIA_OK) {
         LOG(ERROR) << "transcoder configure returned " << status;
@@ -323,7 +330,7 @@
 }
 
 static void BenchmarkTranscoder(benchmark::State& state, const std::string& srcFileName,
-                                bool mockReader, MediaType mediaType) {
+                                bool mockReader, MediaType mediaType, bool maxOperatingRate) {
     for (auto _ : state) {
         std::shared_ptr<TrackTranscoderCallbacks> callbacks =
                 std::make_shared<TrackTranscoderCallbacks>();
@@ -341,7 +348,7 @@
             return;
         }
 
-        if (!ConfigureSampleReader(transcoder, sampleReader, mediaType)) {
+        if (!ConfigureSampleReader(transcoder, sampleReader, mediaType, maxOperatingRate)) {
             state.SkipWithError("Unable to configure the transcoder");
             return;
         }
@@ -367,33 +374,72 @@
     }
 }
 
-// Benchmark registration wrapper for transcoding.
-#define TRANSCODER_BENCHMARK(func) \
-    BENCHMARK(func)->UseRealTime()->MeasureProcessCPUTime()->Unit(benchmark::kMillisecond)
+//-------------------------------- AVC to AVC Benchmarks -------------------------------------------
 
 static void BM_VideoTranscode_AVC2AVC_NoMuxer(benchmark::State& state) {
     const char* srcFile = "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4";
-    BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo);
+    BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo,
+                        false /* maxOperatingRate */);
 }
 
 static void BM_VideoTranscode_AVC2AVC_NoMuxer_NoExtractor(benchmark::State& state) {
     const char* srcFile = "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4";
-    BenchmarkTranscoder(state, srcFile, true /* mockReader */, kVideo);
+    BenchmarkTranscoder(state, srcFile, true /* mockReader */, kVideo,
+                        false /* maxOperatingRate */);
 }
 
+static void BM_VideoTranscode_AVC2AVC_NoMuxer_MaxOperatingRate(benchmark::State& state) {
+    const char* srcFile = "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4";
+    BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo,
+                        true /* maxOperatingRate */);
+}
+
+static void BM_VideoTranscode_AVC2AVC_NoMuxer_NoExtractor_MaxOperatingRate(
+        benchmark::State& state) {
+    const char* srcFile = "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4";
+    BenchmarkTranscoder(state, srcFile, true /* mockReader */, kVideo, true /* maxOperatingRate */);
+}
+
+//-------------------------------- HEVC to AVC Benchmarks ------------------------------------------
+
 static void BM_VideoTranscode_HEVC2AVC_NoMuxer(benchmark::State& state) {
     const char* srcFile = "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4";
-    BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo);
+    BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo,
+                        false /* maxOperatingRate */);
 }
 
 static void BM_VideoTranscode_HEVC2AVC_NoMuxer_NoExtractor(benchmark::State& state) {
     const char* srcFile = "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4";
-    BenchmarkTranscoder(state, srcFile, true /* mockReader */, kVideo);
+    BenchmarkTranscoder(state, srcFile, true /* mockReader */, kVideo,
+                        false /* maxOperatingRate */);
 }
 
+static void BM_VideoTranscode_HEVC2AVC_NoMuxer_MaxOperatingRate(benchmark::State& state) {
+    const char* srcFile = "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4";
+    BenchmarkTranscoder(state, srcFile, false /* mockReader */, kVideo,
+                        true /* maxOperatingRate */);
+}
+
+static void BM_VideoTranscode_HEVC2AVC_NoMuxer_NoExtractor_MaxOperatingRate(
+        benchmark::State& state) {
+    const char* srcFile = "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4";
+    BenchmarkTranscoder(state, srcFile, true /* mockReader */, kVideo, true /* maxOperatingRate */);
+}
+
+//-------------------------------- Benchmark Registration ------------------------------------------
+
+// Benchmark registration wrapper for transcoding.
+#define TRANSCODER_BENCHMARK(func) \
+    BENCHMARK(func)->UseRealTime()->MeasureProcessCPUTime()->Unit(benchmark::kMillisecond)
+
 TRANSCODER_BENCHMARK(BM_VideoTranscode_AVC2AVC_NoMuxer);
 TRANSCODER_BENCHMARK(BM_VideoTranscode_AVC2AVC_NoMuxer_NoExtractor);
+TRANSCODER_BENCHMARK(BM_VideoTranscode_AVC2AVC_NoMuxer_MaxOperatingRate);
+TRANSCODER_BENCHMARK(BM_VideoTranscode_AVC2AVC_NoMuxer_NoExtractor_MaxOperatingRate);
+
 TRANSCODER_BENCHMARK(BM_VideoTranscode_HEVC2AVC_NoMuxer);
 TRANSCODER_BENCHMARK(BM_VideoTranscode_HEVC2AVC_NoMuxer_NoExtractor);
+TRANSCODER_BENCHMARK(BM_VideoTranscode_HEVC2AVC_NoMuxer_MaxOperatingRate);
+TRANSCODER_BENCHMARK(BM_VideoTranscode_HEVC2AVC_NoMuxer_NoExtractor_MaxOperatingRate);
 
 BENCHMARK_MAIN();
diff --git a/media/libmediatranscoding/transcoder/benchmark/MediaTranscoderBenchmark.cpp b/media/libmediatranscoding/transcoder/benchmark/MediaTranscoderBenchmark.cpp
index f190453..f985a28 100644
--- a/media/libmediatranscoding/transcoder/benchmark/MediaTranscoderBenchmark.cpp
+++ b/media/libmediatranscoding/transcoder/benchmark/MediaTranscoderBenchmark.cpp
@@ -191,14 +191,24 @@
     if (dstFd > 0) close(dstFd);
 }
 
+/**
+ * Callback to edit track format for transcoding.
+ * @param dstFormat The default track format for the track type.
+ */
+using TrackFormatEditCallback = std::function<void(AMediaFormat* dstFormat)>;
+
 static void TranscodeMediaFile(benchmark::State& state, const std::string& srcFileName,
                                const std::string& dstFileName, bool includeAudio,
-                               bool transcodeVideo) {
+                               bool transcodeVideo,
+                               const TrackFormatEditCallback& videoFormatEditor = nullptr) {
     TranscodeMediaFile(state, srcFileName, dstFileName,
                        [=](const char* mime, AMediaFormat** dstFormatOut) -> bool {
                            *dstFormatOut = nullptr;
                            if (strncmp(mime, "video/", 6) == 0 && transcodeVideo) {
                                *dstFormatOut = CreateDefaultVideoFormat();
+                               if (videoFormatEditor != nullptr) {
+                                   videoFormatEditor(*dstFormatOut);
+                               }
                            } else if (strncmp(mime, "audio/", 6) == 0 && !includeAudio) {
                                return false;
                            }
@@ -206,9 +216,12 @@
                        });
 }
 
-// Benchmark registration wrapper for transcoding.
-#define TRANSCODER_BENCHMARK(func) \
-    BENCHMARK(func)->UseRealTime()->MeasureProcessCPUTime()->Unit(benchmark::kMillisecond)
+static void SetMaxOperatingRate(AMediaFormat* format) {
+    AMediaFormat_setFloat(format, AMEDIAFORMAT_KEY_OPERATING_RATE, INT32_MAX);
+    AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_PRIORITY, 1);
+}
+
+//-------------------------------- AVC to AVC Benchmarks -------------------------------------------
 
 static void BM_TranscodeAvc2AvcAudioVideo2AudioVideo(benchmark::State& state) {
     TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4",
@@ -216,12 +229,6 @@
                        true /* includeAudio */, true /* transcodeVideo */);
 }
 
-static void BM_TranscodeAvc2AvcAudioVideo2Video(benchmark::State& state) {
-    TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4",
-                       "video_1920x1080_3648frame_h264_22Mbps_30fps_aac_transcoded_V.mp4",
-                       false /* includeAudio */, true /* transcodeVideo */);
-}
-
 static void BM_TranscodeAvc2AvcVideo2Video(benchmark::State& state) {
     TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps.mp4",
                        "video_1920x1080_3648frame_h264_22Mbps_30fps_transcoded_V.mp4",
@@ -231,35 +238,43 @@
 static void BM_TranscodeAvc2AvcAV2AVMaxOperatingRate(benchmark::State& state) {
     TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4",
                        "video_1920x1080_3648frame_h264_22Mbps_30fps_aac_transcoded_AV.mp4",
-                       [](const char* mime, AMediaFormat** dstFormatOut) -> bool {
-                           AMediaFormat* dstFormat = nullptr;
-                           if (strncmp(mime, "video/", 6) == 0) {
-                               dstFormat = CreateDefaultVideoFormat();
-                               AMediaFormat_setFloat(dstFormat, AMEDIAFORMAT_KEY_OPERATING_RATE,
-                                                     INT32_MAX);
-                               AMediaFormat_setInt32(dstFormat, AMEDIAFORMAT_KEY_PRIORITY, 1);
-                           }
-                           *dstFormatOut = dstFormat;
-                           return true;
-                       });
+                       true /* includeAudio */, true /* transcodeVideo */, SetMaxOperatingRate);
 }
 
 static void BM_TranscodeAvc2AvcV2VMaxOperatingRate(benchmark::State& state) {
     TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps.mp4",
                        "video_1920x1080_3648frame_h264_22Mbps_30fps_transcoded_V.mp4",
-                       [](const char* mime, AMediaFormat** dstFormatOut) -> bool {
-                           if (strncmp(mime, "video/", 6) == 0) {
-                               AMediaFormat* dstFormat = CreateDefaultVideoFormat();
-                               AMediaFormat_setFloat(dstFormat, AMEDIAFORMAT_KEY_OPERATING_RATE,
-                                                     INT32_MAX);
-                               AMediaFormat_setInt32(dstFormat, AMEDIAFORMAT_KEY_PRIORITY, 1);
-                               *dstFormatOut = dstFormat;
-                               return true;
-                           }
-                           return false;
-                       });
+                       false /* includeAudio */, true /* transcodeVideo */, SetMaxOperatingRate);
 }
 
+//-------------------------------- HEVC to AVC Benchmarks ------------------------------------------
+
+static void BM_TranscodeHevc2AvcAudioVideo2AudioVideo(benchmark::State& state) {
+    TranscodeMediaFile(state, "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4",
+                       "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac_transcoded_AV.mp4",
+                       true /* includeAudio */, true /* transcodeVideo */);
+}
+
+static void BM_TranscodeHevc2AvcVideo2Video(benchmark::State& state) {
+    TranscodeMediaFile(state, "video_1920x1080_3863frame_hevc_4Mbps_30fps.mp4",
+                       "video_1920x1080_3863frame_hevc_4Mbps_30fps_transcoded_V.mp4",
+                       false /* includeAudio */, true /* transcodeVideo */);
+}
+
+static void BM_TranscodeHevc2AvcAV2AVMaxOperatingRate(benchmark::State& state) {
+    TranscodeMediaFile(state, "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac.mp4",
+                       "video_1920x1080_3863frame_hevc_4Mbps_30fps_aac_transcoded_AV.mp4",
+                       true /* includeAudio */, true /* transcodeVideo */, SetMaxOperatingRate);
+}
+
+static void BM_TranscodeHevc2AvcV2VMaxOperatingRate(benchmark::State& state) {
+    TranscodeMediaFile(state, "video_1920x1080_3863frame_hevc_4Mbps_30fps.mp4",
+                       "video_1920x1080_3863frame_hevc_4Mbps_30fps_transcoded_V.mp4",
+                       false /* includeAudio */, true /* transcodeVideo */, SetMaxOperatingRate);
+}
+
+//-------------------------------- Passthrough Benchmarks ------------------------------------------
+
 static void BM_TranscodeAudioVideoPassthrough(benchmark::State& state) {
     TranscodeMediaFile(state, "video_1920x1080_3648frame_h264_22Mbps_30fps_aac.mp4",
                        "video_1920x1080_3648frame_h264_22Mbps_30fps_aac_passthrough_AV.mp4",
@@ -271,11 +286,22 @@
                        false /* includeAudio */, false /* transcodeVideo */);
 }
 
+//-------------------------------- Benchmark Registration ------------------------------------------
+
+// Benchmark registration wrapper for transcoding.
+#define TRANSCODER_BENCHMARK(func) \
+    BENCHMARK(func)->UseRealTime()->MeasureProcessCPUTime()->Unit(benchmark::kMillisecond)
+
 TRANSCODER_BENCHMARK(BM_TranscodeAvc2AvcAudioVideo2AudioVideo);
-TRANSCODER_BENCHMARK(BM_TranscodeAvc2AvcAudioVideo2Video);
 TRANSCODER_BENCHMARK(BM_TranscodeAvc2AvcVideo2Video);
 TRANSCODER_BENCHMARK(BM_TranscodeAvc2AvcAV2AVMaxOperatingRate);
 TRANSCODER_BENCHMARK(BM_TranscodeAvc2AvcV2VMaxOperatingRate);
+
+TRANSCODER_BENCHMARK(BM_TranscodeHevc2AvcAudioVideo2AudioVideo);
+TRANSCODER_BENCHMARK(BM_TranscodeHevc2AvcVideo2Video);
+TRANSCODER_BENCHMARK(BM_TranscodeHevc2AvcAV2AVMaxOperatingRate);
+TRANSCODER_BENCHMARK(BM_TranscodeHevc2AvcV2VMaxOperatingRate);
+
 TRANSCODER_BENCHMARK(BM_TranscodeAudioVideoPassthrough);
 TRANSCODER_BENCHMARK(BM_TranscodeVideoPassthrough);