v4l2_codec2: Switch from media::VideoCodecProfile to C2 profiles.

This CL changes all uses of the media::VideoCodecProfile type that was
copied from Chrome to their respective C2 profile counterparts. This
removes the additional conversion between C2 profiles,
VideoCodecProfile and V4L2 profiles. The video_codecs.h/cc files are
removed.

Bug: 155138142
Test: arc.VideoEncodeAccel.h264_192p_i420_vm
Change-Id: I0df03215e51def6379c468a4c189104d5fbde0e9

14 files changed, 155 insertions, 337 deletions

diff --git a/accel/Android.bp b/accel/Android.bp
index 8d49101..c9e6ed3 100644
--- a/accel/Android.bp
+++ b/accel/Android.bp
@@ -14,7 +14,6 @@ cc_library {
     srcs: [
         "color_plane_layout.cc",
         "fourcc.cc",
-        "video_codecs.cc",
         "video_frame.cc",
         "video_frame_layout.cc",
         "video_pixel_format.cc",
diff --git a/accel/video_codecs.cc b/accel/video_codecs.cc
deleted file mode 100644
index 8e4d4a7..0000000
--- a/accel/video_codecs.cc
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-// Note: ported from Chromium commit head: 23236dc929bc
-// Note: only necessary functions are ported.
-
-#include "video_codecs.h"
-
-#include "base/logging.h"
-
-namespace media {
-
-std::string GetProfileName(VideoCodecProfile profile) {
-  switch (profile) {
-    case VIDEO_CODEC_PROFILE_UNKNOWN:
-      return "unknown";
-    case H264PROFILE_BASELINE:
-      return "h264 baseline";
-    case H264PROFILE_MAIN:
-      return "h264 main";
-    case H264PROFILE_EXTENDED:
-      return "h264 extended";
-    case H264PROFILE_HIGH:
-      return "h264 high";
-    case H264PROFILE_HIGH10PROFILE:
-      return "h264 high 10";
-    case H264PROFILE_HIGH422PROFILE:
-      return "h264 high 4:2:2";
-    case H264PROFILE_HIGH444PREDICTIVEPROFILE:
-      return "h264 high 4:4:4 predictive";
-    case H264PROFILE_SCALABLEBASELINE:
-      return "h264 scalable baseline";
-    case H264PROFILE_SCALABLEHIGH:
-      return "h264 scalable high";
-    case H264PROFILE_STEREOHIGH:
-      return "h264 stereo high";
-    case H264PROFILE_MULTIVIEWHIGH:
-      return "h264 multiview high";
-    case HEVCPROFILE_MAIN:
-      return "hevc main";
-    case HEVCPROFILE_MAIN10:
-      return "hevc main 10";
-    case HEVCPROFILE_MAIN_STILL_PICTURE:
-      return "hevc main still-picture";
-    case VP8PROFILE_ANY:
-      return "vp8";
-    case VP9PROFILE_PROFILE0:
-      return "vp9 profile0";
-    case VP9PROFILE_PROFILE1:
-      return "vp9 profile1";
-    case VP9PROFILE_PROFILE2:
-      return "vp9 profile2";
-    case VP9PROFILE_PROFILE3:
-      return "vp9 profile3";
-    case DOLBYVISION_PROFILE0:
-      return "dolby vision profile 0";
-    case DOLBYVISION_PROFILE4:
-      return "dolby vision profile 4";
-    case DOLBYVISION_PROFILE5:
-      return "dolby vision profile 5";
-    case DOLBYVISION_PROFILE7:
-      return "dolby vision profile 7";
-    case DOLBYVISION_PROFILE8:
-      return "dolby vision profile 8";
-    case DOLBYVISION_PROFILE9:
-      return "dolby vision profile 9";
-    case THEORAPROFILE_ANY:
-      return "theora";
-    case AV1PROFILE_PROFILE_MAIN:
-      return "av1 profile main";
-    case AV1PROFILE_PROFILE_HIGH:
-      return "av1 profile high";
-    case AV1PROFILE_PROFILE_PRO:
-      return "av1 profile pro";
-  }
-  NOTREACHED();
-  return "";
-}
-
-}  // namespace media
diff --git a/accel/video_codecs.h b/accel/video_codecs.h
deleted file mode 100644
index 7c5339b..0000000
--- a/accel/video_codecs.h
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-// Note: ported from Chromium commit head: becc5bbb0aa6
-// Note: only necessary functions are ported.
-
-#ifndef VIDEO_CODECS_H_
-#define VIDEO_CODECS_H_
-
-#include <string>
-
-namespace media {
-
-// Video codec profiles. Keep in sync with mojo::VideoCodecProfile (see
-// media/mojo/mojom/media_types.mojom), gpu::VideoCodecProfile (see
-// gpu/config/gpu_info.h), and PP_VideoDecoder_Profile (translation is performed
-// in content/renderer/pepper/ppb_video_decoder_impl.cc).
-// NOTE: These values are histogrammed over time in UMA so the values must never
-// ever change (add new values to tools/metrics/histograms/histograms.xml)
-// GENERATED_JAVA_ENUM_PACKAGE: org.chromium.media
-enum VideoCodecProfile {
-  // Keep the values in this enum unique, as they imply format (h.264 vs. VP8,
-  // for example), and keep the values for a particular format grouped
-  // together for clarity.
-  VIDEO_CODEC_PROFILE_UNKNOWN = -1,
-  VIDEO_CODEC_PROFILE_MIN = VIDEO_CODEC_PROFILE_UNKNOWN,
-  H264PROFILE_MIN = 0,
-  H264PROFILE_BASELINE = H264PROFILE_MIN,
-  H264PROFILE_MAIN = 1,
-  H264PROFILE_EXTENDED = 2,
-  H264PROFILE_HIGH = 3,
-  H264PROFILE_HIGH10PROFILE = 4,
-  H264PROFILE_HIGH422PROFILE = 5,
-  H264PROFILE_HIGH444PREDICTIVEPROFILE = 6,
-  H264PROFILE_SCALABLEBASELINE = 7,
-  H264PROFILE_SCALABLEHIGH = 8,
-  H264PROFILE_STEREOHIGH = 9,
-  H264PROFILE_MULTIVIEWHIGH = 10,
-  H264PROFILE_MAX = H264PROFILE_MULTIVIEWHIGH,
-  VP8PROFILE_MIN = 11,
-  VP8PROFILE_ANY = VP8PROFILE_MIN,
-  VP8PROFILE_MAX = VP8PROFILE_ANY,
-  VP9PROFILE_MIN = 12,
-  VP9PROFILE_PROFILE0 = VP9PROFILE_MIN,
-  VP9PROFILE_PROFILE1 = 13,
-  VP9PROFILE_PROFILE2 = 14,
-  VP9PROFILE_PROFILE3 = 15,
-  VP9PROFILE_MAX = VP9PROFILE_PROFILE3,
-  HEVCPROFILE_MIN = 16,
-  HEVCPROFILE_MAIN = HEVCPROFILE_MIN,
-  HEVCPROFILE_MAIN10 = 17,
-  HEVCPROFILE_MAIN_STILL_PICTURE = 18,
-  HEVCPROFILE_MAX = HEVCPROFILE_MAIN_STILL_PICTURE,
-  DOLBYVISION_PROFILE0 = 19,
-  DOLBYVISION_PROFILE4 = 20,
-  DOLBYVISION_PROFILE5 = 21,
-  DOLBYVISION_PROFILE7 = 22,
-  THEORAPROFILE_MIN = 23,
-  THEORAPROFILE_ANY = THEORAPROFILE_MIN,
-  THEORAPROFILE_MAX = THEORAPROFILE_ANY,
-  AV1PROFILE_MIN = 24,
-  AV1PROFILE_PROFILE_MAIN = AV1PROFILE_MIN,
-  AV1PROFILE_PROFILE_HIGH = 25,
-  AV1PROFILE_PROFILE_PRO = 26,
-  AV1PROFILE_MAX = AV1PROFILE_PROFILE_PRO,
-  DOLBYVISION_PROFILE8 = 27,
-  DOLBYVISION_PROFILE9 = 28,
-  VIDEO_CODEC_PROFILE_MAX = DOLBYVISION_PROFILE9,
-};
-
-std::string GetProfileName(VideoCodecProfile profile);
-
-}  // namespace media
-
-#endif  // VIDEO_CODECS_H_
diff --git a/common/EncodeHelpers.cpp b/common/EncodeHelpers.cpp
index c23b17d..4575197 100644
--- a/common/EncodeHelpers.cpp
+++ b/common/EncodeHelpers.cpp
@@ -18,46 +18,6 @@
 
 namespace android {
 
-media::VideoCodecProfile c2ProfileToVideoCodecProfile(C2Config::profile_t profile) {
-    switch (profile) {
-    case C2Config::PROFILE_AVC_BASELINE:
-        return media::VideoCodecProfile::H264PROFILE_BASELINE;
-    case C2Config::PROFILE_AVC_MAIN:
-        return media::VideoCodecProfile::H264PROFILE_MAIN;
-    case C2Config::PROFILE_AVC_EXTENDED:
-        return media::VideoCodecProfile::H264PROFILE_EXTENDED;
-    case C2Config::PROFILE_AVC_HIGH:
-        return media::VideoCodecProfile::H264PROFILE_HIGH;
-    case C2Config::PROFILE_AVC_HIGH_10:
-        return media::VideoCodecProfile::H264PROFILE_HIGH10PROFILE;
-    case C2Config::PROFILE_AVC_HIGH_422:
-        return media::VideoCodecProfile::H264PROFILE_HIGH422PROFILE;
-    case C2Config::PROFILE_AVC_HIGH_444_PREDICTIVE:
-        return media::VideoCodecProfile::H264PROFILE_HIGH444PREDICTIVEPROFILE;
-    case C2Config::PROFILE_AVC_SCALABLE_BASELINE:
-        return media::VideoCodecProfile::H264PROFILE_SCALABLEBASELINE;
-    case C2Config::PROFILE_AVC_SCALABLE_HIGH:
-        return media::VideoCodecProfile::H264PROFILE_SCALABLEHIGH;
-    case C2Config::PROFILE_AVC_STEREO_HIGH:
-        return media::VideoCodecProfile::H264PROFILE_STEREOHIGH;
-    case C2Config::PROFILE_AVC_MULTIVIEW_HIGH:
-        return media::VideoCodecProfile::H264PROFILE_MULTIVIEWHIGH;
-    case C2Config::PROFILE_VP8_0:
-        return media::VideoCodecProfile::VP8PROFILE_ANY;
-    case C2Config::PROFILE_VP9_0:
-        return media::VideoCodecProfile::VP9PROFILE_PROFILE0;
-    case C2Config::PROFILE_VP9_1:
-        return media::VideoCodecProfile::VP9PROFILE_PROFILE1;
-    case C2Config::PROFILE_VP9_2:
-        return media::VideoCodecProfile::VP9PROFILE_PROFILE2;
-    case C2Config::PROFILE_VP9_3:
-        return media::VideoCodecProfile::VP9PROFILE_PROFILE3;
-    default:
-        ALOGE("Unrecognizable C2 profile (value = 0x%x)...", profile);
-        return media::VideoCodecProfile::VIDEO_CODEC_PROFILE_UNKNOWN;
-    }
-}
-
 uint8_t c2LevelToV4L2Level(C2Config::level_t level) {
     switch (level) {
     case C2Config::LEVEL_AVC_1:
diff --git a/common/V4L2Device.cpp b/common/V4L2Device.cpp
index 2741838..90b5c64 100644
--- a/common/V4L2Device.cpp
+++ b/common/V4L2Device.cpp
@@ -34,6 +34,7 @@
 
 #include <color_plane_layout.h>
 #include <v4l2_codec2/common/Common.h>
+#include <v4l2_codec2/common/VideoTypes.h>
 #include <video_pixel_format.h>
 
 // VP8 parsed frames
@@ -1218,81 +1219,83 @@ std::vector<uint32_t> V4L2Device::preferredInputFormat(Type type) {
 }
 
 // static
-uint32_t V4L2Device::videoCodecProfileToV4L2PixFmt(media::VideoCodecProfile profile,
-                                                   bool sliceBased) {
-    if (profile >= media::H264PROFILE_MIN && profile <= media::H264PROFILE_MAX) {
+uint32_t V4L2Device::C2ProfileToV4L2PixFmt(C2Config::profile_t profile, bool sliceBased) {
+    if (profile >= C2Config::PROFILE_AVC_BASELINE &&
+        profile <= C2Config::PROFILE_AVC_ENHANCED_MULTIVIEW_DEPTH_HIGH) {
         if (sliceBased) {
             return V4L2_PIX_FMT_H264_SLICE;
         } else {
             return V4L2_PIX_FMT_H264;
         }
-    } else if (profile >= media::VP8PROFILE_MIN && profile <= media::VP8PROFILE_MAX) {
+    } else if (profile >= C2Config::PROFILE_VP8_0 && profile <= C2Config::PROFILE_VP8_3) {
         if (sliceBased) {
             return V4L2_PIX_FMT_VP8_FRAME;
         } else {
             return V4L2_PIX_FMT_VP8;
         }
-    } else if (profile >= media::VP9PROFILE_MIN && profile <= media::VP9PROFILE_MAX) {
+    } else if (profile >= C2Config::PROFILE_VP9_0 && profile <= C2Config::PROFILE_VP9_3) {
         if (sliceBased) {
             return V4L2_PIX_FMT_VP9_FRAME;
         } else {
             return V4L2_PIX_FMT_VP9;
         }
     } else {
-        ALOGE("Unknown profile: %s", GetProfileName(profile).c_str());
+        ALOGE("Unknown profile: %s", profileToString(profile));
         return 0;
     }
 }
 
 // static
-media::VideoCodecProfile V4L2Device::v4L2ProfileToVideoCodecProfile(VideoCodec codec,
-                                                                    uint32_t profile) {
+C2Config::profile_t V4L2Device::v4L2ProfileToC2Profile(VideoCodec codec, uint32_t profile) {
     switch (codec) {
     case VideoCodec::H264:
         switch (profile) {
         case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
         case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
-            return media::H264PROFILE_BASELINE;
+            return C2Config::PROFILE_AVC_BASELINE;
         case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
-            return media::H264PROFILE_MAIN;
+            return C2Config::PROFILE_AVC_MAIN;
         case V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED:
-            return media::H264PROFILE_EXTENDED;
+            return C2Config::PROFILE_AVC_EXTENDED;
         case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
-            return media::H264PROFILE_HIGH;
+            return C2Config::PROFILE_AVC_HIGH;
         }
         break;
     case VideoCodec::VP8:
         switch (profile) {
         case V4L2_MPEG_VIDEO_VP8_PROFILE_0:
+            return C2Config::PROFILE_VP8_0;
         case V4L2_MPEG_VIDEO_VP8_PROFILE_1:
+            return C2Config::PROFILE_VP8_1;
         case V4L2_MPEG_VIDEO_VP8_PROFILE_2:
+            return C2Config::PROFILE_VP8_2;
         case V4L2_MPEG_VIDEO_VP8_PROFILE_3:
-            return media::VP8PROFILE_ANY;
+            return C2Config::PROFILE_VP8_3;
         }
         break;
     case VideoCodec::VP9:
         switch (profile) {
         case V4L2_MPEG_VIDEO_VP9_PROFILE_0:
-            return media::VP9PROFILE_PROFILE0;
+            return C2Config::PROFILE_VP9_0;
         case V4L2_MPEG_VIDEO_VP9_PROFILE_1:
-            return media::VP9PROFILE_PROFILE1;
+            return C2Config::PROFILE_VP9_1;
         case V4L2_MPEG_VIDEO_VP9_PROFILE_2:
-            return media::VP9PROFILE_PROFILE2;
+            return C2Config::PROFILE_VP9_2;
         case V4L2_MPEG_VIDEO_VP9_PROFILE_3:
-            return media::VP9PROFILE_PROFILE3;
+            return C2Config::PROFILE_VP9_3;
         }
         break;
     default:
         ALOGE("Unknown codec: %u", codec);
     }
     ALOGE("Unknown profile: %u", profile);
-    return media::VIDEO_CODEC_PROFILE_UNKNOWN;
+    return C2Config::PROFILE_UNUSED;
 }
 
-std::vector<media::VideoCodecProfile> V4L2Device::v4L2PixFmtToVideoCodecProfiles(
-        uint32_t pixFmt, bool /*isEncoder*/) {
+std::vector<C2Config::profile_t> V4L2Device::v4L2PixFmtToC2Profiles(uint32_t pixFmt,
+                                                                    bool /*isEncoder*/) {
     auto getSupportedProfiles = [this](VideoCodec codec,
-                                       std::vector<media::VideoCodecProfile>* profiles) {
+                                       std::vector<C2Config::profile_t>* profiles) {
         uint32_t queryId = 0;
         switch (codec) {
         case VideoCodec::H264:
@@ -1318,15 +1321,15 @@ std::vector<media::VideoCodecProfile> V4L2Device::v4L2PixFmtToVideoCodecProfiles
         for (queryMenu.index = queryCtrl.minimum;
              static_cast<int>(queryMenu.index) <= queryCtrl.maximum; queryMenu.index++) {
             if (ioctl(VIDIOC_QUERYMENU, &queryMenu) == 0) {
-                const media::VideoCodecProfile profile =
-                        V4L2Device::v4L2ProfileToVideoCodecProfile(codec, queryMenu.index);
-                if (profile != media::VIDEO_CODEC_PROFILE_UNKNOWN) profiles->push_back(profile);
+                const C2Config::profile_t profile =
+                        V4L2Device::v4L2ProfileToC2Profile(codec, queryMenu.index);
+                if (profile != C2Config::PROFILE_UNUSED) profiles->push_back(profile);
             }
         }
         return true;
     };
 
-    std::vector<media::VideoCodecProfile> profiles;
+    std::vector<C2Config::profile_t> profiles;
     switch (pixFmt) {
     case V4L2_PIX_FMT_H264:
     case V4L2_PIX_FMT_H264_SLICE:
@@ -1334,22 +1337,24 @@ std::vector<media::VideoCodecProfile> V4L2Device::v4L2PixFmtToVideoCodecProfiles
             ALOGW("Driver doesn't support QUERY H264 profiles, "
                   "use default values, Base, Main, High");
             profiles = {
-                    media::H264PROFILE_BASELINE,
-                    media::H264PROFILE_MAIN,
-                    media::H264PROFILE_HIGH,
+                    C2Config::PROFILE_AVC_BASELINE,
+                    C2Config::PROFILE_AVC_MAIN,
+                    C2Config::PROFILE_AVC_HIGH,
             };
         }
         break;
     case V4L2_PIX_FMT_VP8:
     case V4L2_PIX_FMT_VP8_FRAME:
-        profiles = {media::VP8PROFILE_ANY};
+        if (!getSupportedProfiles(VideoCodec::VP8, &profiles)) {
+            ALOGW("Driver doesn't support QUERY VP8 profiles, use default values, Profile0");
+            profiles = {C2Config::PROFILE_VP8_0};
+        }
         break;
     case V4L2_PIX_FMT_VP9:
     case V4L2_PIX_FMT_VP9_FRAME:
         if (!getSupportedProfiles(VideoCodec::VP9, &profiles)) {
-            ALOGW("Driver doesn't support QUERY VP9 profiles, "
-                  "use default values, Profile0");
-            profiles = {media::VP9PROFILE_PROFILE0};
+            ALOGW("Driver doesn't support QUERY VP9 profiles, use default values, Profile0");
+            profiles = {C2Config::PROFILE_VP9_0};
         }
         break;
     default:
@@ -1364,29 +1369,29 @@ std::vector<media::VideoCodecProfile> V4L2Device::v4L2PixFmtToVideoCodecProfiles
 }
 
 // static
-int32_t V4L2Device::videoCodecProfileToV4L2H264Profile(media::VideoCodecProfile profile) {
+int32_t V4L2Device::c2ProfileToV4L2H264Profile(C2Config::profile_t profile) {
     switch (profile) {
-    case media::H264PROFILE_BASELINE:
+    case C2Config::PROFILE_AVC_BASELINE:
         return V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE;
-    case media::H264PROFILE_MAIN:
+    case C2Config::PROFILE_AVC_MAIN:
         return V4L2_MPEG_VIDEO_H264_PROFILE_MAIN;
-    case media::H264PROFILE_EXTENDED:
+    case C2Config::PROFILE_AVC_EXTENDED:
         return V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED;
-    case media::H264PROFILE_HIGH:
+    case C2Config::PROFILE_AVC_HIGH:
         return V4L2_MPEG_VIDEO_H264_PROFILE_HIGH;
-    case media::H264PROFILE_HIGH10PROFILE:
+    case C2Config::PROFILE_AVC_HIGH_10:
         return V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10;
-    case media::H264PROFILE_HIGH422PROFILE:
+    case C2Config::PROFILE_AVC_HIGH_422:
         return V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422;
-    case media::H264PROFILE_HIGH444PREDICTIVEPROFILE:
+    case C2Config::PROFILE_AVC_HIGH_444_PREDICTIVE:
         return V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_PREDICTIVE;
-    case media::H264PROFILE_SCALABLEBASELINE:
+    case C2Config::PROFILE_AVC_SCALABLE_BASELINE:
         return V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_BASELINE;
-    case media::H264PROFILE_SCALABLEHIGH:
+    case C2Config::PROFILE_AVC_SCALABLE_HIGH:
         return V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH;
-    case media::H264PROFILE_STEREOHIGH:
+    case C2Config::PROFILE_AVC_STEREO_HIGH:
         return V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH;
-    case media::H264PROFILE_MULTIVIEWHIGH:
+    case C2Config::PROFILE_AVC_MULTIVIEW_HIGH:
         return V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH;
     default:
         ALOGE("Add more cases as needed");
@@ -1814,14 +1819,14 @@ V4L2Device::SupportedDecodeProfiles V4L2Device::enumerateSupportedDecodeProfiles
         SupportedDecodeProfile profile;
         getSupportedResolution(pixelFormat, &profile.min_resolution, &profile.max_resolution);
 
-        const auto videoCodecProfiles = v4L2PixFmtToVideoCodecProfiles(pixelFormat, false);
+        const auto videoCodecProfiles = v4L2PixFmtToC2Profiles(pixelFormat, false);
 
         for (const auto& videoCodecProfile : videoCodecProfiles) {
             profile.profile = videoCodecProfile;
             profiles.push_back(profile);
 
-            ALOGV("Found decoder profile %s, resolutions: %s %s",
-                  GetProfileName(profile.profile).c_str(), toString(profile.min_resolution).c_str(),
+            ALOGV("Found decoder profile %s, resolutions: %s %s", profileToString(profile.profile),
+                  toString(profile.min_resolution).c_str(),
                   toString(profile.max_resolution).c_str());
         }
     }
@@ -1842,14 +1847,13 @@ V4L2Device::SupportedEncodeProfiles V4L2Device::enumerateSupportedEncodeProfiles
         ui::Size minResolution;
         getSupportedResolution(pixelformat, &minResolution, &profile.max_resolution);
 
-        const auto videoCodecProfiles = v4L2PixFmtToVideoCodecProfiles(pixelformat, true);
+        const auto videoCodecProfiles = v4L2PixFmtToC2Profiles(pixelformat, true);
 
         for (const auto& videoCodecProfile : videoCodecProfiles) {
             profile.profile = videoCodecProfile;
             profiles.push_back(profile);
 
-            ALOGV("Found encoder profile %s, max resolution: %s",
-                  GetProfileName(profile.profile).c_str(),
+            ALOGV("Found encoder profile %s, max resolution: %s", profileToString(profile.profile),
                   toString(profile.max_resolution).c_str());
         }
     }
diff --git a/common/VideoTypes.cpp b/common/VideoTypes.cpp
index 1ecceca..c123ad1 100644
--- a/common/VideoTypes.cpp
+++ b/common/VideoTypes.cpp
@@ -22,6 +22,65 @@ const char* VideoCodecToString(VideoCodec codec) {
     }
 }
 
+const char* profileToString(C2Config::profile_t profile) {
+    switch (profile) {
+    case C2Config::PROFILE_UNUSED:
+        return "unused";
+    case C2Config::PROFILE_AVC_BASELINE:
+        return "h264 baseline";
+    case C2Config::PROFILE_AVC_MAIN:
+        return "h264 main";
+    case C2Config::PROFILE_AVC_EXTENDED:
+        return "h264 extended";
+    case C2Config::PROFILE_AVC_HIGH:
+        return "h264 high";
+    case C2Config::PROFILE_AVC_HIGH_10:
+        return "h264 high 10";
+    case C2Config::PROFILE_AVC_HIGH_422:
+        return "h264 high 4:2:2";
+    case C2Config::PROFILE_AVC_HIGH_444_PREDICTIVE:
+        return "h264 high 4:4:4 predictive";
+    case C2Config::PROFILE_AVC_SCALABLE_BASELINE:
+        return "h264 scalable baseline";
+    case C2Config::PROFILE_AVC_SCALABLE_HIGH:
+        return "h264 scalable high";
+    case C2Config::PROFILE_AVC_STEREO_HIGH:
+        return "h264 stereo high";
+    case C2Config::PROFILE_AVC_MULTIVIEW_HIGH:
+        return "h264 multiview high";
+    case C2Config::PROFILE_HEVC_MAIN:
+        return "hevc main";
+    case C2Config::PROFILE_HEVC_MAIN_10:
+        return "hevc main 10";
+    case C2Config::PROFILE_HEVC_MAIN_STILL:
+        return "hevc main still-picture";
+    case C2Config::PROFILE_VP8_0:
+        return "vp8 profile0";
+    case C2Config::PROFILE_VP8_1:
+        return "vp8 profile1";
+    case C2Config::PROFILE_VP8_2:
+        return "vp8 profile2";
+    case C2Config::PROFILE_VP8_3:
+        return "vp8 profile3";
+    case C2Config::PROFILE_VP9_0:
+        return "vp9 profile0";
+    case C2Config::PROFILE_VP9_1:
+        return "vp9 profile1";
+    case C2Config::PROFILE_VP9_2:
+        return "vp9 profile2";
+    case C2Config::PROFILE_VP9_3:
+        return "vp9 profile3";
+    case C2Config::PROFILE_AV1_0:
+        return "av1 profile 0";
+    case C2Config::PROFILE_AV1_1:
+        return "av1 profile 1";
+    case C2Config::PROFILE_AV1_2:
+        return "av1 profile 2";
+    default:
+        return "unknown";
+    }
+}
+
 const char* HalPixelFormatToString(HalPixelFormat format) {
     switch (format) {
     case HalPixelFormat::UNKNOWN:
diff --git a/common/include/v4l2_codec2/common/EncodeHelpers.h b/common/include/v4l2_codec2/common/EncodeHelpers.h
index bd55094..0771088 100644
--- a/common/include/v4l2_codec2/common/EncodeHelpers.h
+++ b/common/include/v4l2_codec2/common/EncodeHelpers.h
@@ -9,7 +9,6 @@
 #include <system/graphics.h>
 #include <ui/Size.h>
 
-#include <video_codecs.h>
 #include <video_pixel_format.h>
 
 namespace android {
@@ -30,16 +29,13 @@ struct VideoEncoderAcceleratorConfig {
 
     media::VideoPixelFormat mInputFormat;
     ui::Size mInputVisibleSize;
-    media::VideoCodecProfile mOutputProfile;
+    C2Config::profile_t mOutputProfile;
     uint32_t mInitialBitrate;
     uint32_t mInitialFramerate;
     uint8_t mH264OutputLevel;
     VideoFrameStorageType mStorageType;
 };
 
-// Convert the specified C2Config profile to a media::VideoCodecProfile.
-media::VideoCodecProfile c2ProfileToVideoCodecProfile(C2Config::profile_t profile);
-
 // Convert the specified C2Config level to a V4L2 level.
 uint8_t c2LevelToV4L2Level(C2Config::level_t level);
 
diff --git a/common/include/v4l2_codec2/common/V4L2Device.h b/common/include/v4l2_codec2/common/V4L2Device.h
index fd06983..3e23ca3 100644
--- a/common/include/v4l2_codec2/common/V4L2Device.h
+++ b/common/include/v4l2_codec2/common/V4L2Device.h
@@ -16,6 +16,7 @@
 #include <optional>
 #include <vector>
 
+#include <C2Config.h>
 #include <base/containers/flat_map.h>
 #include <base/files/scoped_file.h>
 #include <base/memory/ref_counted.h>
@@ -24,7 +25,6 @@
 #include <ui/Size.h>
 #include <v4l2_codec2/common/V4L2DevicePoller.h>
 #include <v4l2_codec2/common/VideoTypes.h>
-#include <video_codecs.h>
 #include <video_frame.h>
 #include <video_frame_layout.h>
 #include <video_pixel_format.h>
@@ -323,7 +323,7 @@ class V4L2Device : public base::RefCountedThreadSafe<V4L2Device> {
 public:
     // Specification of an encoding profile supported by an encoder.
     struct SupportedEncodeProfile {
-        media::VideoCodecProfile profile = media::VIDEO_CODEC_PROFILE_UNKNOWN;
+        C2Config::profile_t profile = C2Config::PROFILE_UNUSED;
         ui::Size min_resolution;
         ui::Size max_resolution;
         uint32_t max_framerate_numerator = 0;
@@ -334,7 +334,7 @@ public:
     // Specification of a decoding profile supported by an decoder.
     // |max_resolution| and |min_resolution| are inclusive.
     struct SupportedDecodeProfile {
-        media::VideoCodecProfile profile = media::VIDEO_CODEC_PROFILE_UNKNOWN;
+        C2Config::profile_t profile = C2Config::PROFILE_UNUSED;
         ui::Size max_resolution;
         ui::Size min_resolution;
         bool encrypted_only = false;
@@ -343,17 +343,14 @@ public:
 
     // Utility format conversion functions
     // If there is no corresponding single- or multi-planar format, returns 0.
-    static uint32_t videoCodecProfileToV4L2PixFmt(media::VideoCodecProfile profile,
-                                                  bool sliceBased);
-    static media::VideoCodecProfile v4L2ProfileToVideoCodecProfile(VideoCodec codec,
-                                                                   uint32_t profile);
-    std::vector<media::VideoCodecProfile> v4L2PixFmtToVideoCodecProfiles(uint32_t pixFmt,
-                                                                         bool isEncoder);
+    static uint32_t C2ProfileToV4L2PixFmt(C2Config::profile_t profile, bool sliceBased);
+    static C2Config::profile_t v4L2ProfileToC2Profile(VideoCodec codec, uint32_t profile);
+    std::vector<C2Config::profile_t> v4L2PixFmtToC2Profiles(uint32_t pixFmt, bool isEncoder);
     // Calculates the largest plane's allocation size requested by a V4L2 device.
     static ui::Size allocatedSizeFromV4L2Format(const struct v4l2_format& format);
 
     // Convert required H264 profile and level to V4L2 enums.
-    static int32_t videoCodecProfileToV4L2H264Profile(media::VideoCodecProfile profile);
+    static int32_t c2ProfileToV4L2H264Profile(C2Config::profile_t profile);
     static int32_t h264LevelIdcToV4L2H264Level(uint8_t levelIdc);
 
     // Converts v4l2_memory to a string.
diff --git a/common/include/v4l2_codec2/common/VideoTypes.h b/common/include/v4l2_codec2/common/VideoTypes.h
index 4736b13..076f096 100644
--- a/common/include/v4l2_codec2/common/VideoTypes.h
+++ b/common/include/v4l2_codec2/common/VideoTypes.h
@@ -8,6 +8,7 @@
 #include <optional>
 #include <string>
 
+#include <C2Config.h>
 #include <android/hardware/graphics/common/1.0/types.h>
 
 namespace android {
@@ -18,11 +19,13 @@ enum class VideoCodec {
     VP8,
     VP9,
 };
-const char* VideoCodecToString(VideoCodec codec);
 
 constexpr std::initializer_list<VideoCodec> kAllCodecs = {VideoCodec::H264, VideoCodec::VP8,
                                                           VideoCodec::VP9};
 
+const char* VideoCodecToString(VideoCodec codec);
+const char* profileToString(C2Config::profile_t profile);
+
 // Enumeration of supported pixel format. The value should be the same as
 // ::android::hardware::graphics::common::V1_0::PixelFormat.
 using HPixelFormat = ::android::hardware::graphics::common::V1_0::PixelFormat;
diff --git a/components/V4L2EncodeComponent.cpp b/components/V4L2EncodeComponent.cpp
index 7a85a06..f9b8adc 100644
--- a/components/V4L2EncodeComponent.cpp
+++ b/components/V4L2EncodeComponent.cpp
@@ -620,11 +620,11 @@ bool V4L2EncodeComponent::initializeEncoder() {
     mCSDSubmitted = false;
 
     // Get the requested profile and level.
-    media::VideoCodecProfile outputProfile =
-            c2ProfileToVideoCodecProfile(mInterface->getOutputProfile());
+    C2Config::profile_t outputProfile = mInterface->getOutputProfile();
 
     std::optional<uint8_t> h264Level;
-    if (outputProfile >= media::H264PROFILE_MIN && outputProfile <= media::H264PROFILE_MAX) {
+    if (outputProfile >= C2Config::PROFILE_AVC_BASELINE &&
+        outputProfile <= C2Config::PROFILE_AVC_ENHANCED_MULTIVIEW_DEPTH_HIGH) {
         h264Level = c2LevelToV4L2Level(mInterface->getOutputLevel());
     }
 
@@ -648,7 +648,7 @@ bool V4L2EncodeComponent::initializeEncoder() {
             ::base::BindRepeating(&V4L2EncodeComponent::reportError, mWeakThis, C2_CORRUPTED),
             mEncoderTaskRunner);
     if (!mEncoder) {
-        ALOGE("Failed to create V4L2Encoder (profile: %s)", GetProfileName(outputProfile).c_str());
+        ALOGE("Failed to create V4L2Encoder (profile: %s)", profileToString(outputProfile));
         return false;
     }
 
diff --git a/components/V4L2EncodeInterface.cpp b/components/V4L2EncodeInterface.cpp
index 4e5ae7a..7f0fb39 100644
--- a/components/V4L2EncodeInterface.cpp
+++ b/components/V4L2EncodeInterface.cpp
@@ -19,7 +19,6 @@
 #include <v4l2_codec2/common/V4L2ComponentCommon.h>
 #include <v4l2_codec2/common/V4L2Device.h>
 #include <v4l2_codec2/common/VideoTypes.h>
-#include <video_codecs.h>
 
 using android::hardware::graphics::common::V1_0::BufferUsage;
 
@@ -43,46 +42,6 @@ constexpr uint32_t kDefaultBitrate = 64000;
 // TODO: increase this in the future for supporting higher level/resolution encoding.
 constexpr uint32_t kMaxBitrate = 50000000;
 
-C2Config::profile_t videoCodecProfileToC2Profile(media::VideoCodecProfile profile) {
-    switch (profile) {
-    case media::VideoCodecProfile::H264PROFILE_BASELINE:
-        return C2Config::PROFILE_AVC_BASELINE;
-    case media::VideoCodecProfile::H264PROFILE_MAIN:
-        return C2Config::PROFILE_AVC_MAIN;
-    case media::VideoCodecProfile::H264PROFILE_EXTENDED:
-        return C2Config::PROFILE_AVC_EXTENDED;
-    case media::VideoCodecProfile::H264PROFILE_HIGH:
-        return C2Config::PROFILE_AVC_HIGH;
-    case media::VideoCodecProfile::H264PROFILE_HIGH10PROFILE:
-        return C2Config::PROFILE_AVC_HIGH_10;
-    case media::VideoCodecProfile::H264PROFILE_HIGH422PROFILE:
-        return C2Config::PROFILE_AVC_HIGH_422;
-    case media::VideoCodecProfile::H264PROFILE_HIGH444PREDICTIVEPROFILE:
-        return C2Config::PROFILE_AVC_HIGH_444_PREDICTIVE;
-    case media::VideoCodecProfile::H264PROFILE_SCALABLEBASELINE:
-        return C2Config::PROFILE_AVC_SCALABLE_BASELINE;
-    case media::VideoCodecProfile::H264PROFILE_SCALABLEHIGH:
-        return C2Config::PROFILE_AVC_SCALABLE_HIGH;
-    case media::VideoCodecProfile::H264PROFILE_STEREOHIGH:
-        return C2Config::PROFILE_AVC_STEREO_HIGH;
-    case media::VideoCodecProfile::H264PROFILE_MULTIVIEWHIGH:
-        return C2Config::PROFILE_AVC_MULTIVIEW_HIGH;
-    case media::VideoCodecProfile::VP8PROFILE_ANY:
-        return C2Config::PROFILE_VP8_0;
-    case media::VideoCodecProfile::VP9PROFILE_PROFILE0:
-        return C2Config::PROFILE_VP9_0;
-    case media::VideoCodecProfile::VP9PROFILE_PROFILE1:
-        return C2Config::PROFILE_VP9_1;
-    case media::VideoCodecProfile::VP9PROFILE_PROFILE2:
-        return C2Config::PROFILE_VP9_2;
-    case media::VideoCodecProfile::VP9PROFILE_PROFILE3:
-        return C2Config::PROFILE_VP9_3;
-    default:
-        ALOGE("Unrecognizable profile (value = %d)...", profile);
-        return C2Config::PROFILE_UNUSED;
-    }
-}
-
 std::optional<VideoCodec> getCodecFromComponentName(const std::string& name) {
     if (name == V4L2ComponentName::kH264Encoder) return VideoCodec::H264;
     if (name == V4L2ComponentName::kVP8Encoder) return VideoCodec::VP8;
@@ -305,13 +264,12 @@ void V4L2EncodeInterface::Initialize(const C2String& name) {
     std::vector<unsigned int> profiles;
     ui::Size maxSize;
     for (const auto& supportedProfile : supported_profiles) {
-        C2Config::profile_t profile = videoCodecProfileToC2Profile(supportedProfile.profile);
-        if (!IsValidProfileForCodec(codec.value(), profile)) {
+        if (!IsValidProfileForCodec(codec.value(), supportedProfile.profile)) {
             continue;  // Ignore unrecognizable or unsupported profiles.
         }
-        ALOGV("Queried c2_profile = 0x%x : max_size = %d x %d", profile,
+        ALOGV("Queried c2_profile = 0x%x : max_size = %d x %d", supportedProfile.profile,
               supportedProfile.max_resolution.width, supportedProfile.max_resolution.height);
-        profiles.push_back(static_cast<unsigned int>(profile));
+        profiles.push_back(static_cast<unsigned int>(supportedProfile.profile));
         maxSize.setWidth(std::max(maxSize.width, supportedProfile.max_resolution.width));
         maxSize.setHeight(std::max(maxSize.height, supportedProfile.max_resolution.height));
     }
diff --git a/components/V4L2Encoder.cpp b/components/V4L2Encoder.cpp
index 1e7c31d..db3fa63 100644
--- a/components/V4L2Encoder.cpp
+++ b/components/V4L2Encoder.cpp
@@ -51,7 +51,7 @@ size_t GetMaxOutputBufferSize(const ui::Size& size) {
 
 // static
 std::unique_ptr<VideoEncoder> V4L2Encoder::create(
-        media::VideoCodecProfile outputProfile, std::optional<uint8_t> level,
+        C2Config::profile_t outputProfile, std::optional<uint8_t> level,
         const ui::Size& visibleSize, uint32_t stride, uint32_t keyFramePeriod,
         FetchOutputBufferCB fetchOutputBufferCb, InputBufferDoneCB inputBufferDoneCb,
         OutputBufferDoneCB outputBufferDoneCb, DrainDoneCB drainDoneCb, ErrorCB errorCb,
@@ -188,7 +188,7 @@ media::VideoPixelFormat V4L2Encoder::inputFormat() const {
                         : media::VideoPixelFormat::PIXEL_FORMAT_UNKNOWN;
 }
 
-bool V4L2Encoder::initialize(media::VideoCodecProfile outputProfile, std::optional<uint8_t> level,
+bool V4L2Encoder::initialize(C2Config::profile_t outputProfile, std::optional<uint8_t> level,
                              const ui::Size& visibleSize, uint32_t stride,
                              uint32_t keyFramePeriod) {
     ALOGV("%s()", __func__);
@@ -201,9 +201,9 @@ bool V4L2Encoder::initialize(media::VideoCodecProfile outputProfile, std::option
 
     // Open the V4L2 device for encoding to the requested output format.
     // TODO(dstaessens): Avoid conversion to VideoCodecProfile and use C2Config::profile_t directly.
-    uint32_t outputPixelFormat = V4L2Device::videoCodecProfileToV4L2PixFmt(outputProfile, false);
+    uint32_t outputPixelFormat = V4L2Device::C2ProfileToV4L2PixFmt(outputProfile, false);
     if (!outputPixelFormat) {
-        ALOGE("Invalid output profile %s", media::GetProfileName(outputProfile).c_str());
+        ALOGE("Invalid output profile %s", profileToString(outputProfile));
         return false;
     }
 
@@ -214,8 +214,7 @@ bool V4L2Encoder::initialize(media::VideoCodecProfile outputProfile, std::option
     }
 
     if (!mDevice->open(V4L2Device::Type::kEncoder, outputPixelFormat)) {
-        ALOGE("Failed to open device for profile %s (%s)",
-              media::GetProfileName(outputProfile).c_str(),
+        ALOGE("Failed to open device for profile %s (%s)", profileToString(outputProfile),
               media::FourccToString(outputPixelFormat).c_str());
         return false;
     }
@@ -543,30 +542,29 @@ bool V4L2Encoder::configureInputFormat(media::VideoPixelFormat inputFormat, uint
     return true;
 }
 
-bool V4L2Encoder::configureOutputFormat(media::VideoCodecProfile outputProfile) {
+bool V4L2Encoder::configureOutputFormat(C2Config::profile_t outputProfile) {
     ALOGV("%s()", __func__);
     ALOG_ASSERT(mTaskRunner->RunsTasksInCurrentSequence());
     ALOG_ASSERT(mState == State::UNINITIALIZED);
     ALOG_ASSERT(!mOutputQueue->isStreaming());
     ALOG_ASSERT(!isEmpty(mVisibleSize));
 
-    auto format =
-            mOutputQueue->setFormat(V4L2Device::videoCodecProfileToV4L2PixFmt(outputProfile, false),
-                                    mVisibleSize, GetMaxOutputBufferSize(mVisibleSize));
+    auto format = mOutputQueue->setFormat(V4L2Device::C2ProfileToV4L2PixFmt(outputProfile, false),
+                                          mVisibleSize, GetMaxOutputBufferSize(mVisibleSize));
     if (!format) {
-        ALOGE("Failed to set output format to %s", media::GetProfileName(outputProfile).c_str());
+        ALOGE("Failed to set output format to %s", profileToString(outputProfile));
         return false;
     }
 
     // The device might adjust the requested output buffer size to match hardware requirements.
     mOutputBufferSize = format->fmt.pix_mp.plane_fmt[0].sizeimage;
 
-    ALOGV("Output format set to %s (buffer size: %u)", media::GetProfileName(outputProfile).c_str(),
+    ALOGV("Output format set to %s (buffer size: %u)", profileToString(outputProfile),
           mOutputBufferSize);
     return true;
 }
 
-bool V4L2Encoder::configureDevice(media::VideoCodecProfile outputProfile,
+bool V4L2Encoder::configureDevice(C2Config::profile_t outputProfile,
                                   std::optional<const uint8_t> outputH264Level) {
     ALOGV("%s()", __func__);
     ALOG_ASSERT(mTaskRunner->RunsTasksInCurrentSequence());
@@ -586,14 +584,15 @@ bool V4L2Encoder::configureDevice(media::VideoCodecProfile outputProfile,
                                                 V4L2ExtCtrl(V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0)});
 
     // All controls below are H.264-specific, so we can return here if the profile is not H.264.
-    if (outputProfile >= media::H264PROFILE_MIN || outputProfile <= media::H264PROFILE_MAX) {
+    if (outputProfile >= C2Config::PROFILE_AVC_BASELINE ||
+        outputProfile <= C2Config::PROFILE_AVC_ENHANCED_MULTIVIEW_DEPTH_HIGH) {
         return configureH264(outputProfile, outputH264Level);
     }
 
     return true;
 }
 
-bool V4L2Encoder::configureH264(media::VideoCodecProfile outputProfile,
+bool V4L2Encoder::configureH264(C2Config::profile_t outputProfile,
                                 std::optional<const uint8_t> outputH264Level) {
     // When encoding H.264 we want to prepend SPS and PPS to each IDR for resilience. Some
     // devices support this through the V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR control.
@@ -618,7 +617,7 @@ bool V4L2Encoder::configureH264(media::VideoCodecProfile outputProfile,
     h264Ctrls.emplace_back(V4L2_CID_MPEG_VIDEO_H264_MAX_QP, 51);
 
     // Set H.264 profile.
-    int32_t profile = V4L2Device::videoCodecProfileToV4L2H264Profile(outputProfile);
+    int32_t profile = V4L2Device::c2ProfileToV4L2H264Profile(outputProfile);
     if (profile < 0) {
         ALOGE("Trying to set invalid H.264 profile");
         return false;
diff --git a/components/include/v4l2_codec2/components/V4L2EncodeInterface.h b/components/include/v4l2_codec2/components/V4L2EncodeInterface.h
index 2774d15..2efbfcc 100644
--- a/components/include/v4l2_codec2/components/V4L2EncodeInterface.h
+++ b/components/include/v4l2_codec2/components/V4L2EncodeInterface.h
@@ -15,7 +15,6 @@
 #include <util/C2InterfaceHelper.h>
 
 #include <v4l2_codec2/common/EncodeHelpers.h>
-#include <video_codecs.h>
 
 namespace media {
 class V4L2Device;
diff --git a/components/include/v4l2_codec2/components/V4L2Encoder.h b/components/include/v4l2_codec2/components/V4L2Encoder.h
index f76c0a9..1198af8 100644
--- a/components/include/v4l2_codec2/components/V4L2Encoder.h
+++ b/components/include/v4l2_codec2/components/V4L2Encoder.h
@@ -16,7 +16,6 @@
 #include <ui/Size.h>
 
 #include <v4l2_codec2/components/VideoEncoder.h>
-#include <video_codecs.h>
 #include <video_frame_layout.h>
 
 namespace android {
@@ -33,10 +32,10 @@ public:
     static constexpr size_t kOutputBufferCount = 2;
 
     static std::unique_ptr<VideoEncoder> create(
-            media::VideoCodecProfile profile, std::optional<uint8_t> level,
-            const ui::Size& visibleSize, uint32_t stride, uint32_t keyFramePeriod,
-            FetchOutputBufferCB fetchOutputBufferCb, InputBufferDoneCB inputBufferDoneCb,
-            OutputBufferDoneCB outputBufferDoneCb, DrainDoneCB drainDoneCb, ErrorCB errorCb,
+            C2Config::profile_t profile, std::optional<uint8_t> level, const ui::Size& visibleSize,
+            uint32_t stride, uint32_t keyFramePeriod, FetchOutputBufferCB fetchOutputBufferCb,
+            InputBufferDoneCB inputBufferDoneCb, OutputBufferDoneCB outputBufferDoneCb,
+            DrainDoneCB drainDoneCb, ErrorCB errorCb,
             scoped_refptr<::base::SequencedTaskRunner> taskRunner);
     ~V4L2Encoder() override;
 
@@ -80,7 +79,7 @@ private:
                 OutputBufferDoneCB mOutputBufferDoneCb, DrainDoneCB drainDoneCb, ErrorCB errorCb);
 
     // Initialize the V4L2 encoder for specified parameters.
-    bool initialize(media::VideoCodecProfile outputProfile, std::optional<uint8_t> level,
+    bool initialize(C2Config::profile_t outputProfile, std::optional<uint8_t> level,
                     const ui::Size& visibleSize, uint32_t stride, uint32_t keyFramePeriod);
 
     // Handle the next encode request on the queue.
@@ -95,12 +94,12 @@ private:
     // Configure input format on the V4L2 device.
     bool configureInputFormat(media::VideoPixelFormat inputFormat, uint32_t stride);
     // Configure output format on the V4L2 device.
-    bool configureOutputFormat(media::VideoCodecProfile outputProfile);
+    bool configureOutputFormat(C2Config::profile_t outputProfile);
     // Configure required and optional controls on the V4L2 device.
-    bool configureDevice(media::VideoCodecProfile outputProfile,
+    bool configureDevice(C2Config::profile_t outputProfile,
                          std::optional<const uint8_t> outputH264Level);
     // Configure required and optional H.264 controls on the V4L2 device.
-    bool configureH264(media::VideoCodecProfile outputProfile,
+    bool configureH264(C2Config::profile_t outputProfile,
                        std::optional<const uint8_t> outputH264Level);
 
     // Attempt to start the V4L2 device poller.