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 {
 
 // 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,
@@ skipping 338 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,
+
+  EncryptionScheme encryption_scheme(

[ddorwin, 2016/03/02 23:24:05]

It's weird that the audio path has an extra function call. I'll look into that.
For now, though, it seems better for the code to be consistent (creating a
scheme rather than bool), and we should put this information as close to where
we processed the media data as possible. Thus, I suggest passing in a const
EncryptionScheme&.

Going further, we could abstract this to GetEncryptionScheme(const AVStream*
stream) so we don't even need to duplicate the metadata processing.

[dougsteed, 2016/03/03 04:45:00]

Done. The extra audio function AVCodecContextToAudioDecoderConfig is labelled
MEDIA_EXPORT.
OK to change the signature? (Although it only seems to be used in unit tests).

[ddorwin, 2016/03/03 18:38:04]

Yes. No interfaces are guaranteed not to change except things like PPAPI.

I found that the audio wrapper was added in
https://chromiumcodereview.appspot.com/10829470/diff/120001/media/ffmpeg/ffmp...
to make it match the video case. I think we can eliminate the internal function.
I'll look into it.

+      is_encrypted ? EncryptionScheme::kCipherModeAesCtr
+                   : EncryptionScheme::kCipherModeUnencrypted);
+  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
@@ skipping 99 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;
+  EncryptionScheme encryption_scheme(
+      key ? EncryptionScheme::kCipherModeAesCtr
+          : EncryptionScheme::kCipherModeUnencrypted);
 
   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);
@@ skipping 13 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, encryption_scheme);
   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