media config: expand is_encrypted to a struct.

media/ffmpeg/ffmpeg_common.cc

 // Copyright (c) 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.
 
 #include "media/ffmpeg/ffmpeg_common.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
+#include "media/base/encryption_scheme.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_util.h"
 #include "media/media_features.h"
 
 namespace media {
 
+namespace {
+
+EncryptionScheme GetEncryptionScheme(const AVStream* stream) {
+  AVDictionaryEntry* key =
+      av_dict_get(stream->metadata, "enc_key_id", nullptr, 0);
+  return EncryptionScheme(key ? EncryptionScheme::kCipherModeAesCtr
+                              : EncryptionScheme::kCipherModeUnencrypted);
+}
+
+}  // namespace
+
 // Why FF_INPUT_BUFFER_PADDING_SIZE? FFmpeg assumes all input buffers are
 // padded. Check here to ensure FFmpeg only receives data padded to its
 // specifications.
 static_assert(DecoderBuffer::kPaddingSize >= FF_INPUT_BUFFER_PADDING_SIZE,
               "DecoderBuffer padding size does not fit ffmpeg requirement");
 
 // Alignment requirement by FFmpeg for input and output buffers. This need to
 // be updated to match FFmpeg when it changes.
 #if defined(ARCH_CPU_ARM_FAMILY)
 static const int kFFmpegBufferAddressAlignment = 16;
@@ skipping 264 matching lines @@
     case kSampleFormatPlanarS16:
       return AV_SAMPLE_FMT_S16P;
     case kSampleFormatPlanarF32:
       return AV_SAMPLE_FMT_FLTP;
     default:
       DVLOG(1) << "Unknown SampleFormat: " << sample_format;
   }
   return AV_SAMPLE_FMT_NONE;
 }
 
-bool AVCodecContextToAudioDecoderConfig(const AVCodecContext* codec_context,
-                                        bool is_encrypted,
-                                        AudioDecoderConfig* config) {
+bool AVCodecContextToAudioDecoderConfig(
+    const AVCodecContext* codec_context,
+    const EncryptionScheme& encryption_scheme,
+    AudioDecoderConfig* config) {
   DCHECK_EQ(codec_context->codec_type, AVMEDIA_TYPE_AUDIO);
 
   AudioCodec codec = CodecIDToAudioCodec(codec_context->codec_id);
 
   SampleFormat sample_format = AVSampleFormatToSampleFormat(
       codec_context->sample_fmt, codec_context->codec_id);
 
   ChannelLayout channel_layout = ChannelLayoutToChromeChannelLayout(
       codec_context->channel_layout, codec_context->channels);
 
@@ skipping 45 matching lines @@
                << " extra data cannot have size of "
                << codec_context->extradata_size << ".";
     return false;
   }
 
   std::vector<uint8_t> extra_data;
   if (codec_context->extradata_size > 0) {
     extra_data.assign(codec_context->extradata,
                       codec_context->extradata + codec_context->extradata_size);
   }
-  config->Initialize(codec,
-                     sample_format,
-                     channel_layout,
-                     sample_rate,
-                     extra_data,
-                     is_encrypted,
-                     seek_preroll,
+
+  config->Initialize(codec, sample_format, channel_layout, sample_rate,
+                     extra_data, encryption_scheme, seek_preroll,
                      codec_context->delay);
 
   // Verify that AudioConfig.bits_per_channel was calculated correctly for
   // codecs that have |sample_fmt| set by FFmpeg.
   switch (codec) {
     case kCodecOpus:
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
     case kCodecAC3:
     case kCodecEAC3:
 #endif
       break;
     default:
       DCHECK_EQ(av_get_bytes_per_sample(codec_context->sample_fmt) * 8,
                 config->bits_per_channel());
       break;
   }
 
   return true;
 }
 
 bool AVStreamToAudioDecoderConfig(const AVStream* stream,
                                   AudioDecoderConfig* config) {
-  bool is_encrypted = false;
-  AVDictionaryEntry* key =
-      av_dict_get(stream->metadata, "enc_key_id", nullptr, 0);
-  if (key)
-    is_encrypted = true;
-  return AVCodecContextToAudioDecoderConfig(stream->codec, is_encrypted,
-                                            config);
+  return AVCodecContextToAudioDecoderConfig(
+      stream->codec, GetEncryptionScheme(stream), config);
 }
 
 void AudioDecoderConfigToAVCodecContext(const AudioDecoderConfig& config,
                                         AVCodecContext* codec_context) {
   codec_context->codec_type = AVMEDIA_TYPE_AUDIO;
   codec_context->codec_id = AudioCodecToCodecID(config.codec(),
                                                 config.sample_format());
   codec_context->sample_fmt = SampleFormatToAVSampleFormat(
       config.sample_format());
 
@@ skipping 70 matching lines @@
     coded_size = visible_rect.size();
   }
 
   // Pad out |coded_size| for subsampled YUV formats.
   if (format != PIXEL_FORMAT_YV24) {
     coded_size.set_width((coded_size.width() + 1) / 2 * 2);
     if (format != PIXEL_FORMAT_YV16)
       coded_size.set_height((coded_size.height() + 1) / 2 * 2);
   }
 
-  bool is_encrypted = false;
-  AVDictionaryEntry* key =
-      av_dict_get(stream->metadata, "enc_key_id", nullptr, 0);
-  if (key)
-    is_encrypted = true;
-
   AVDictionaryEntry* webm_alpha =
       av_dict_get(stream->metadata, "alpha_mode", nullptr, 0);
   if (webm_alpha && !strcmp(webm_alpha->value, "1")) {
     format = PIXEL_FORMAT_YV12A;
   }
 
   // Prefer the color space found by libavcodec if available.
   ColorSpace color_space = AVColorSpaceToColorSpace(stream->codec->colorspace,
                                                     stream->codec->color_range);
   if (color_space == COLOR_SPACE_UNSPECIFIED) {
@@ skipping 12 matching lines @@
                << stream->codec->extradata_size << ".";
     return false;
   }
 
   std::vector<uint8_t> extra_data;
   if (stream->codec->extradata_size > 0) {
     extra_data.assign(stream->codec->extradata,
                       stream->codec->extradata + stream->codec->extradata_size);
   }
   config->Initialize(codec, profile, format, color_space, coded_size,
-                     visible_rect, natural_size, extra_data, is_encrypted);
+                     visible_rect, natural_size, extra_data,
+                     GetEncryptionScheme(stream));
   return true;
 }
 
 void VideoDecoderConfigToAVCodecContext(
     const VideoDecoderConfig& config,
     AVCodecContext* codec_context) {
   codec_context->codec_type = AVMEDIA_TYPE_VIDEO;
   codec_context->codec_id = VideoCodecToCodecID(config.codec());
   codec_context->profile = VideoCodecProfileToProfileID(config.profile());
   codec_context->coded_width = config.coded_size().width();
@@ skipping 211 matching lines @@
 }
 
 int32_t HashCodecName(const char* codec_name) {
   // Use the first 32-bits from the SHA1 hash as the identifier.
   int32_t hash;
   memcpy(&hash, base::SHA1HashString(codec_name).substr(0, 4).c_str(), 4);
   return hash;
 }
 
 }  // namespace media