media config: expand is_encrypted to a struct.

Provide more complete encryption metadata, rather than
just a bool. EncryptionScheme also allows specification
of the mode and the pattern, as will be allowed by
CENC (ISO's Common Encryption standard), 3rd Edition.

BUG=568326

Committed: https://crrev.com/c9d2206c62f65e29b141e08df2b2dcb88f54162f
Cr-Commit-Position: refs/heads/master@{#380710}

Review URL: https://codereview.chromium.org/1490613005

Cr-Commit-Position: refs/heads/master@{#380791}

chromecast/common/media/cma_param_traits.cc

@@ -12,6 +12,7 @@
 #include "content/public/common/common_param_traits.h"
 #include "ipc/ipc_message_macros.h"
 #include "media/base/audio_decoder_config.h"
+#include "media/base/encryption_scheme.h"
 #include "media/base/video_decoder_config.h"
 #include "ui/gfx/ipc/gfx_param_traits.h"
 
@@ -29,14 +30,24 @@ IPC_ENUM_TRAITS_MAX_VALUE(media::VideoPixelFormat, media::PIXEL_FORMAT_MAX)
 
 namespace IPC {
 
+template <>
+struct ParamTraits<media::EncryptionScheme::Pattern> {
+  typedef media::EncryptionScheme::Pattern param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m, base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
+
 void ParamTraits<media::AudioDecoderConfig>::Write(
     base::Pickle* m,
     const media::AudioDecoderConfig& p) {
   WriteParam(m, p.codec());
   WriteParam(m, p.sample_format());
   WriteParam(m, p.channel_layout());
   WriteParam(m, p.samples_per_second());
-  WriteParam(m, p.is_encrypted());
+  WriteParam(m, p.encryption_scheme());
   WriteParam(m, p.extra_data());
 }
 
@@ -48,15 +59,17 @@ bool ParamTraits<media::AudioDecoderConfig>::Read(
   media::SampleFormat sample_format;
   media::ChannelLayout channel_layout;
   int samples_per_second;
-  bool is_encrypted;
+  media::EncryptionScheme encryption_scheme;
   std::vector<uint8_t> extra_data;
   if (!ReadParam(m, iter, &codec) || !ReadParam(m, iter, &sample_format) ||
       !ReadParam(m, iter, &channel_layout) ||
       !ReadParam(m, iter, &samples_per_second) ||
-      !ReadParam(m, iter, &is_encrypted) || !ReadParam(m, iter, &extra_data))
+      !ReadParam(m, iter, &encryption_scheme) ||
+      !ReadParam(m, iter, &extra_data))
     return false;
   *r = media::AudioDecoderConfig(codec, sample_format, channel_layout,
-                                 samples_per_second, extra_data, is_encrypted);
+                                 samples_per_second, extra_data,
+                                 encryption_scheme);
   return true;
 }
 
@@ -75,7 +88,7 @@ void ParamTraits<media::VideoDecoderConfig>::Write(
   WriteParam(m, p.coded_size());
   WriteParam(m, p.visible_rect());
   WriteParam(m, p.natural_size());
-  WriteParam(m, p.is_encrypted());
+  WriteParam(m, p.encryption_scheme());
   WriteParam(m, p.extra_data());
 }
 
@@ -90,17 +103,18 @@ bool ParamTraits<media::VideoDecoderConfig>::Read(
   gfx::Size coded_size;
   gfx::Rect visible_rect;
   gfx::Size natural_size;
-  bool is_encrypted;
+  media::EncryptionScheme encryption_scheme;
   std::vector<uint8_t> extra_data;
   if (!ReadParam(m, iter, &codec) || !ReadParam(m, iter, &profile) ||
       !ReadParam(m, iter, &format) || !ReadParam(m, iter, &color_space) ||
       !ReadParam(m, iter, &coded_size) || !ReadParam(m, iter, &visible_rect) ||
       !ReadParam(m, iter, &natural_size) ||
-      !ReadParam(m, iter, &is_encrypted) || !ReadParam(m, iter, &extra_data))
+      !ReadParam(m, iter, &encryption_scheme) ||
+      !ReadParam(m, iter, &extra_data))
     return false;
   *r = media::VideoDecoderConfig(codec, profile, format, color_space,
                                  coded_size, visible_rect, natural_size,
-                                 extra_data, is_encrypted);
+                                 extra_data, encryption_scheme);
   return true;
 }
 
@@ -109,4 +123,45 @@ void ParamTraits<media::VideoDecoderConfig>::Log(
   l->append(base::StringPrintf("<VideoDecoderConfig>"));
 }
 
+void ParamTraits<media::EncryptionScheme>::Write(
+    base::Pickle* m, const param_type& p) {
+  WriteParam(m, p.mode());
+  WriteParam(m, p.pattern());
+}
+
+bool ParamTraits<media::EncryptionScheme>::Read(
+    const base::Pickle* m, base::PickleIterator* iter, param_type* r) {
+  media::EncryptionScheme::CipherMode mode;
+  media::EncryptionScheme::Pattern pattern;
+  if (!ReadParam(m, iter, &mode) || !ReadParam(m, iter, &pattern))
+    return false;
+  *r = media::EncryptionScheme(mode, pattern);
+  return true;
+}
+
+void ParamTraits<media::EncryptionScheme>::Log(
+    const param_type& p, std::string* l) {
+  l->append(base::StringPrintf("<EncryptionScheme>"));
+}
+
+void ParamTraits<media::EncryptionScheme::Pattern>::Write(
+    base::Pickle* m, const param_type& p) {
+  WriteParam(m, p.encrypt_blocks());
+  WriteParam(m, p.skip_blocks());
+}
+
+bool ParamTraits<media::EncryptionScheme::Pattern>::Read(
+    const base::Pickle* m, base::PickleIterator* iter, param_type* r) {
+  uint32_t encrypt_blocks, skip_blocks;
+  if (!ReadParam(m, iter, &encrypt_blocks) || !ReadParam(m, iter, &skip_blocks))
+    return false;
+  *r = media::EncryptionScheme::Pattern(encrypt_blocks, skip_blocks);
+  return true;
+}
+
+void ParamTraits<media::EncryptionScheme::Pattern>::Log(
+    const param_type& p, std::string* l) {
+  l->append(base::StringPrintf("<Pattern>"));
+}
+
 }  // namespace IPC

chromecast/common/media/cma_param_traits.h

@@ -10,6 +10,7 @@
 namespace media {
 class AudioDecoderConfig;
 class VideoDecoderConfig;
+class EncryptionScheme;
 }
 
 namespace IPC {
@@ -34,6 +35,15 @@ struct ParamTraits<media::VideoDecoderConfig> {
   static void Log(const param_type& p, std::string* l);
 };
 
+template <>
+struct ParamTraits<media::EncryptionScheme> {
+  typedef media::EncryptionScheme param_type;
+  static void Write(base::Pickle* m, const param_type& p);
+  static bool Read(const base::Pickle* m, base::PickleIterator* iter,
+                   param_type* r);
+  static void Log(const param_type& p, std::string* l);
+};
+
 }  // namespace IPC
 
 #endif  // CHROMECAST_COMMON_MEDIA_CMA_PARAM_TRAITS_H_

chromecast/common/media/cma_param_traits_macros.h

@@ -44,6 +44,8 @@ IPC_ENUM_TRAITS_MIN_MAX_VALUE(media::VideoCodec,
                               media::VideoCodec::kUnknownVideoCodec,
                               media::VideoCodec::kVideoCodecMax)
 IPC_ENUM_TRAITS_MAX_VALUE(media::ColorSpace, media::COLOR_SPACE_MAX)
+IPC_ENUM_TRAITS_MAX_VALUE(media::EncryptionScheme::CipherMode,
+                          media::EncryptionScheme::CIPHER_MODE_MAX);
 
 IPC_STRUCT_TRAITS_BEGIN(media::PipelineStatistics)
   IPC_STRUCT_TRAITS_MEMBER(audio_bytes_decoded)

chromecast/media/audio/cast_audio_output_stream.cc

@@ -47,7 +47,6 @@ MediaPipelineBackend::AudioDecoder* InitializeBackend(
   audio_config.bytes_per_channel = audio_params.bits_per_sample() / 8;
   audio_config.channel_number = audio_params.channels();
   audio_config.samples_per_second = audio_params.sample_rate();
-  audio_config.is_encrypted = false;
 
   if (!decoder->SetConfig(audio_config))
     return nullptr;

chromecast/media/audio/cast_audio_output_stream_unittest.cc

@@ -385,7 +385,7 @@ TEST_F(CastAudioOutputStreamTest, Format) {
     const AudioConfig& audio_config = audio_decoder->config();
     EXPECT_EQ(kCodecPCM, audio_config.codec);
     EXPECT_EQ(kSampleFormatS16, audio_config.sample_format);
-    EXPECT_FALSE(audio_config.is_encrypted);
+    EXPECT_FALSE(audio_config.encryption_scheme.is_encrypted());
 
     CloseStream(stream);
   }

chromecast/media/cma/backend/audio_video_pipeline_device_unittest.cc

@@ -35,6 +35,7 @@
 #include "media/base/audio_decoder_config.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/decoder_buffer.h"
+#include "media/base/encryption_scheme.h"
 #include "media/base/video_decoder_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -68,7 +69,7 @@ VideoConfig DefaultVideoConfig() {
   default_config.codec = kCodecH264;
   default_config.profile = kH264Main;
   default_config.additional_config = nullptr;
-  default_config.is_encrypted = false;
+  default_config.encryption_scheme = Unencrypted();
   return default_config;
 }
 
@@ -564,7 +565,7 @@ scoped_ptr<BufferFeeder> BufferFeeder::LoadVideo(MediaPipelineBackend* backend,
     video_config.codec = kCodecH264;
     video_config.profile = kH264Main;
     video_config.additional_config = nullptr;
-    video_config.is_encrypted = false;
+    video_config.encryption_scheme = Unencrypted();
   } else {
     base::FilePath file_path = GetTestDataFilePath(filename);
     DemuxResult demux_result = FFmpegDemuxForTest(file_path, false /* audio */);

chromecast/media/cma/base/decoder_config_adapter.cc

@@ -85,7 +85,7 @@ VideoCodec ToVideoCodec(const ::media::VideoCodec video_codec) {
 
 // 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:
@@ -183,6 +183,62 @@ ::media::AudioCodec ToMediaAudioCodec(
   }
 }
 
+::media::EncryptionScheme::CipherMode ToMediaCipherMode(
+    EncryptionScheme::CipherMode mode) {
+  switch (mode) {
+    case EncryptionScheme::CIPHER_MODE_UNENCRYPTED:
+      return ::media::EncryptionScheme::CIPHER_MODE_UNENCRYPTED;
+    case EncryptionScheme::CIPHER_MODE_AES_CTR:
+      return ::media::EncryptionScheme::CIPHER_MODE_AES_CTR;
+    case EncryptionScheme::CIPHER_MODE_AES_CBC:
+      return ::media::EncryptionScheme::CIPHER_MODE_AES_CBC;
+    default:
+      NOTREACHED();
+      return ::media::EncryptionScheme::CIPHER_MODE_UNENCRYPTED;
+  }
+}
+
+EncryptionScheme::CipherMode ToCipherMode(
+    ::media::EncryptionScheme::CipherMode mode) {
+  switch (mode) {
+    case ::media::EncryptionScheme::CIPHER_MODE_UNENCRYPTED:
+      return EncryptionScheme::CIPHER_MODE_UNENCRYPTED;
+    case ::media::EncryptionScheme::CIPHER_MODE_AES_CTR:
+      return EncryptionScheme::CIPHER_MODE_AES_CTR;
+    case ::media::EncryptionScheme::CIPHER_MODE_AES_CBC:
+      return EncryptionScheme::CIPHER_MODE_AES_CBC;
+    default:
+      NOTREACHED();
+      return EncryptionScheme::CIPHER_MODE_UNENCRYPTED;
+  }
+}
+
+EncryptionScheme::Pattern ToPatternSpec(
+    const ::media::EncryptionScheme::Pattern& pattern) {
+  return EncryptionScheme::Pattern(
+      pattern.encrypt_blocks(), pattern.skip_blocks());
+}
+
+::media::EncryptionScheme::Pattern ToMediaPatternSpec(
+    const EncryptionScheme::Pattern& pattern) {
+  return ::media::EncryptionScheme::Pattern(
+      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
@@ -201,7 +257,8 @@ AudioConfig DecoderConfigAdapter::ToCastAudioConfig(
       ::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;
 }
 
@@ -212,7 +269,8 @@ ::media::AudioDecoderConfig DecoderConfigAdapter::ToMediaAudioDecoderConfig(
       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
@@ -228,7 +286,8 @@ VideoConfig DecoderConfigAdapter::ToCastVideoConfig(
   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;
 }
 

chromecast/media/cma/base/demuxer_stream_for_test.cc

@@ -63,7 +63,7 @@ ::media::VideoDecoderConfig DemuxerStreamForTest::video_decoder_config() {
                                      visible_rect,
                                      natural_size,
                                      ::media::EmptyExtraData(),
-                                     false);
+                                     ::media::Unencrypted());
 }
 
 ::media::DemuxerStream::Type DemuxerStreamForTest::type() const {

chromecast/media/cma/ipc_streamer/BUILD.gn

@@ -14,6 +14,8 @@ source_set("ipc_streamer") {
     "decoder_buffer_base_marshaller.h",
     "decrypt_config_marshaller.cc",
     "decrypt_config_marshaller.h",
+    "encryption_scheme_marshaller.cc",
+    "encryption_scheme_marshaller.h",
     "video_decoder_config_marshaller.cc",
     "video_decoder_config_marshaller.h",
   ]

chromecast/media/cma/ipc_streamer/audio_decoder_config_marshaller.cc

@@ -11,6 +11,7 @@
 
 #include "base/logging.h"
 #include "chromecast/media/cma/ipc/media_message.h"
+#include "chromecast/media/cma/ipc_streamer/encryption_scheme_marshaller.h"
 #include "media/base/audio_decoder_config.h"
 
 namespace chromecast {
@@ -27,7 +28,7 @@ void AudioDecoderConfigMarshaller::Write(
   CHECK(msg->WritePod(config.channel_layout()));
   CHECK(msg->WritePod(config.samples_per_second()));
   CHECK(msg->WritePod(config.sample_format()));
-  CHECK(msg->WritePod(config.is_encrypted()));
+  EncryptionSchemeMarshaller::Write(config.encryption_scheme(), msg);
   CHECK(msg->WritePod(config.extra_data().size()));
   if (!config.extra_data().empty())
     CHECK(msg->WriteBuffer(&config.extra_data()[0],
@@ -41,15 +42,15 @@ ::media::AudioDecoderConfig AudioDecoderConfigMarshaller::Read(
   ::media::SampleFormat sample_format;
   ::media::ChannelLayout channel_layout;
   int samples_per_second;
-  bool is_encrypted;
   size_t extra_data_size;
   std::vector<uint8_t> extra_data;
+  ::media::EncryptionScheme encryption_scheme;
 
   CHECK(msg->ReadPod(&codec));
   CHECK(msg->ReadPod(&channel_layout));
   CHECK(msg->ReadPod(&samples_per_second));
   CHECK(msg->ReadPod(&sample_format));
-  CHECK(msg->ReadPod(&is_encrypted));
+  encryption_scheme = EncryptionSchemeMarshaller::Read(msg);
   CHECK(msg->ReadPod(&extra_data_size));
 
   CHECK_GE(codec, ::media::kUnknownAudioCodec);
@@ -67,7 +68,7 @@ ::media::AudioDecoderConfig AudioDecoderConfigMarshaller::Read(
   return ::media::AudioDecoderConfig(
       codec, sample_format,
       channel_layout, samples_per_second,
-      extra_data, is_encrypted);
+      extra_data, encryption_scheme);
 }
 
 }  // namespace media