Introduce VideoConfig/AudioConfig class for CMA backend

chromecast/media/cma/public/video_config.cc

Index: chromecast/media/cma/public/video_config.cc
diff --git a/chromecast/media/cma/public/video_config.cc b/chromecast/media/cma/public/video_config.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0cfb004b8e5737402244fec0e72b63c957b5bfcc
--- /dev/null
+++ b/chromecast/media/cma/public/video_config.cc
@@ -0,0 +1,126 @@
+// 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.
+
+#include "chromecast/media/cma/public/video_config.h"
+
+#include "media/base/video_decoder_config.h"
+
+// Make sure the enum values of media::VideoCodec and
+// chromecast::media::VideoConfig::Codec are matched.
+#define STATIC_ASSERT_ENUM_MATCH_CODEC(name)                \
+  static_assert(                                            \
+      ::media::name == static_cast< ::media::VideoCodec>(   \
+        chromecast::media::VideoConfig::name),              \
+      #name " value must match in media and chromecast::media::VideoConfig.")
+
+// Make sure the enum values of media::VideoCodecProfile and
+// chromecast::media::VideoConfig::CodecProfile are matched.
+#define STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(name)             \
+  static_assert(                                                 \
+      ::media::name == static_cast< ::media::VideoCodecProfile>( \
+        chromecast::media::VideoConfig::name),                   \
+      #name " value must match in media and chromecast::media::VideoConfig.")
+
+namespace chromecast {
+namespace media {
+
+STATIC_ASSERT_ENUM_MATCH_CODEC(kUnknownVideoCodec);
+STATIC_ASSERT_ENUM_MATCH_CODEC(kCodecH264);
+STATIC_ASSERT_ENUM_MATCH_CODEC(kCodecVC1);
+STATIC_ASSERT_ENUM_MATCH_CODEC(kCodecMPEG2);
+STATIC_ASSERT_ENUM_MATCH_CODEC(kCodecMPEG4);
+STATIC_ASSERT_ENUM_MATCH_CODEC(kCodecTheora);
+STATIC_ASSERT_ENUM_MATCH_CODEC(kCodecVP8);
+STATIC_ASSERT_ENUM_MATCH_CODEC(kCodecVP9);
+
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(VIDEO_CODEC_PROFILE_UNKNOWN);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(VIDEO_CODEC_PROFILE_MIN);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_BASELINE);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_MAIN);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_EXTENDED);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_HIGH);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_HIGH10PROFILE);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_HIGH422PROFILE);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_HIGH444PREDICTIVEPROFILE);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_SCALABLEBASELINE);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_SCALABLEHIGH);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_STEREOHIGH);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(H264PROFILE_MULTIVIEWHIGH);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(VP8PROFILE_ANY);
+STATIC_ASSERT_ENUM_MATCH_CODEC_PROFILE(VP9PROFILE_ANY);
+
+VideoConfig::VideoConfig()
+    : codec_(kUnknownVideoCodec),
+      profile_(VIDEO_CODEC_PROFILE_UNKNOWN),
+      is_encrypted_(false) {
+}
+
+VideoConfig::VideoConfig(Codec codec,
+                         CodecProfile profile,
+                         const uint8* extra_data,
+                         size_t extra_data_size,
+                         bool is_encrypted) {
+  Initialize(codec, profile, extra_data, extra_data_size, is_encrypted);
+}
+
+VideoConfig::~VideoConfig() {}
+
+void VideoConfig::Initialize(Codec codec,
+                             CodecProfile profile,
+                             const uint8* extra_data,
+                             size_t extra_data_size,
+                             bool is_encrypted) {
+  codec_ = codec;
+  profile_ = profile;
+  is_encrypted_ = is_encrypted;
+  extra_data_.assign(extra_data, extra_data + extra_data_size);
+}
+
+bool VideoConfig::IsValidConfig() const {
+  return (codec_ != kUnknownVideoCodec);
+}
+
+bool VideoConfig::Matches(const VideoConfig& config) const {
+  return ((codec() == config.codec()) &&
+          (profile() == config.profile()) &&
+          (extra_data_size() == config.extra_data_size()) &&
+          (!extra_data() || !memcmp(extra_data(), config.extra_data(),
+                                    extra_data_size())) &&
+          (is_encrypted() == config.is_encrypted()));
+}
+
+std::string VideoConfig::AsHumanReadableString() const {
+  std::ostringstream s;
+  s << "codec: " << GetHumanReadableCodecName()
+    << " profile: " << profile()
+    << " has extra data? " << (extra_data() ? "true" : "false")
+    << " encrypted? " << (is_encrypted() ? "true" : "false");
+  return s.str();
+}
+
+std::string VideoConfig::GetHumanReadableCodecName() const {
+  switch (codec()) {
+    case kUnknownVideoCodec:
+      return "unknown";
+    case kCodecH264:
+      return "h264";
+    case kCodecVC1:
+      return "vc1";
+    case kCodecMPEG2:
+      return "mpeg2video";
+    case kCodecMPEG4:
+      return "mpeg4";
+    case kCodecTheora:
+      return "theora";
+    case kCodecVP8:
+      return "vp8";
+    case kCodecVP9:
+      return "vp9";
+  }
+  NOTREACHED();
+  return "";
+}
+
+}  // namespace media
+}  // namespace chromecast