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/basictypes.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 "media/base/decoder_buffer.h"
+#include "media/base/encryption_scheme.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_util.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,
               "DecoderBuffer padding size does not fit ffmpeg requirement");
@@ skipping 312 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, EncryptionScheme(is_encrypted), seek_preroll,
                      codec_context->delay);
 
   if (codec != kCodecOpus) {
     DCHECK_EQ(av_get_bytes_per_sample(codec_context->sample_fmt) * 8,
               config->bits_per_channel());
   }
 
   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,

[ddorwin, 2015/12/10 18:36:01]

We could create the correct object here.

[dougsteed, 2015/12/14 21:19:02]

Would it be beneficial to push EncryptionScheme further into ffmpeg? I really
don't know. My change has the benefit of not making more of ffmpeg aware of
EncryptionScheme than is necessary, and it can continue to treat it as a kind of
augmented boolean.

                                             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 109 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,
+                     EncryptionScheme(is_encrypted));
   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 178 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