media config: expand is_encrypted to a struct.

chromecast/media/cma/base/decoder_config_adapter.cc

 // 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/base/decoder_config_adapter.h"
 
 #include "base/logging.h"
 #include "media/base/channel_layout.h"
 
 namespace chromecast {
@@ skipping 67 matching lines @@
     case ::media::kCodecHEVC:
       return kCodecHEVC;
     default:
       LOG(ERROR) << "Unsupported video codec " << video_codec;
   }
   return kVideoCodecUnknown;
 }
 
 // Converts ::media::VideoCodecProfile to chromecast::media::VideoProfile.
 VideoProfile ToVideoProfile(const ::media::VideoCodecProfile codec_profile) {
-  switch(codec_profile) {
+  switch (codec_profile) {
     case ::media::H264PROFILE_BASELINE:
       return kH264Baseline;
     case ::media::H264PROFILE_MAIN:
       return kH264Main;
     case ::media::H264PROFILE_EXTENDED:
       return kH264Extended;
     case ::media::H264PROFILE_HIGH:
       return kH264High;
     case ::media::H264PROFILE_HIGH10PROFILE:
       return kH264High10;
@@ skipping 77 matching lines @@
       return ::media::kCodecFLAC;
     case kCodecEAC3:
       return ::media::kCodecEAC3;
     case kCodecAC3:
       return ::media::kCodecAC3;
     default:
       return ::media::kUnknownAudioCodec;
   }
 }
 
+::media::EncryptionScheme::CipherMode ToMediaCipherMode(
+    EncryptionScheme::CipherMode mode) {
+  switch (mode) {
+    case EncryptionScheme::kCipherModeUnencrypted:
+      return ::media::EncryptionScheme::kCipherModeUnencrypted;
+    case EncryptionScheme::kCipherModeAesCtr:
+      return ::media::EncryptionScheme::kCipherModeAesCtr;
+    case EncryptionScheme::kCipherModeAesCbc:
+      return ::media::EncryptionScheme::kCipherModeAesCbc;
+    default:
+      NOTREACHED();
+      return ::media::EncryptionScheme::kCipherModeUnencrypted;
+  }
+}
+
+EncryptionScheme::CipherMode ToCipherMode(
+    ::media::EncryptionScheme::CipherMode mode) {
+  switch (mode) {
+    case ::media::EncryptionScheme::kCipherModeUnencrypted:
+      return EncryptionScheme::kCipherModeUnencrypted;
+    case ::media::EncryptionScheme::kCipherModeAesCtr:
+      return EncryptionScheme::kCipherModeAesCtr;
+    case ::media::EncryptionScheme::kCipherModeAesCbc:
+      return EncryptionScheme::kCipherModeAesCbc;
+    default:
+      NOTREACHED();
+      return EncryptionScheme::kCipherModeUnencrypted;
+  }
+}
+
+EncryptionScheme::PatternSpec ToPatternSpec(
+    const ::media::EncryptionScheme::PatternSpec& pattern) {
+  return EncryptionScheme::PatternSpec(
+      pattern.encrypt_blocks(), pattern.skip_blocks());
+}
+
+::media::EncryptionScheme::PatternSpec ToMediaPatternSpec(
+    const EncryptionScheme::PatternSpec& pattern) {
+  return ::media::EncryptionScheme::PatternSpec(
+      pattern.encrypt_blocks, pattern.skip_blocks);
+}
+
+EncryptionScheme ToEncryptionScheme(
+    const ::media::EncryptionScheme& scheme) {
+  return EncryptionScheme(
+    ToCipherMode(scheme.mode()),
+    ToPatternSpec(scheme.pattern()));
+}
+
+::media::EncryptionScheme ToMediaEncryptionScheme(
+    const EncryptionScheme& scheme) {
+  return ::media::EncryptionScheme(
+    ToMediaCipherMode(scheme.mode),
+    ToMediaPatternSpec(scheme.pattern));
+}
+
 }  // namespace
 
 // static
 AudioConfig DecoderConfigAdapter::ToCastAudioConfig(
     StreamId id,
     const ::media::AudioDecoderConfig& config) {
   AudioConfig audio_config;
   if (!config.IsValidConfig())
     return audio_config;
 
   audio_config.id = id;
   audio_config.codec = ToAudioCodec(config.codec());
   audio_config.sample_format = ToSampleFormat(config.sample_format());
   audio_config.bytes_per_channel = config.bytes_per_channel();
   audio_config.channel_number =
       ::media::ChannelLayoutToChannelCount(config.channel_layout()),
   audio_config.samples_per_second = config.samples_per_second();
   audio_config.extra_data = config.extra_data();
-  audio_config.is_encrypted = config.is_encrypted();
+  audio_config.encryption_scheme = ToEncryptionScheme(
+      config.encryption_scheme());
   return audio_config;
 }
 
 // static
 ::media::AudioDecoderConfig DecoderConfigAdapter::ToMediaAudioDecoderConfig(
     const AudioConfig& config) {
   return ::media::AudioDecoderConfig(
       ToMediaAudioCodec(config.codec),
       ToMediaSampleFormat(config.sample_format),
       ToMediaChannelLayout(config.channel_number), config.samples_per_second,
-      config.extra_data, config.is_encrypted);
+      config.extra_data,
+      ToMediaEncryptionScheme(config.encryption_scheme));
 }
 
 // static
 VideoConfig DecoderConfigAdapter::ToCastVideoConfig(
     StreamId id,
     const ::media::VideoDecoderConfig& config) {
   VideoConfig video_config;
   if (!config.IsValidConfig()) {
     return video_config;
   }
 
   video_config.id = id;
   video_config.codec = ToVideoCodec(config.codec());
   video_config.profile = ToVideoProfile(config.profile());
   video_config.extra_data = config.extra_data();
-  video_config.is_encrypted = config.is_encrypted();
+  video_config.encryption_scheme = ToEncryptionScheme(
+      config.encryption_scheme());
   return video_config;
 }
 
 }  // namespace media
 }  // namespace chromecast