Add is_encrypted() in VideoDecoderConfig.

media/mp4/mp4_stream_parser.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/mp4/mp4_stream_parser.h"
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/time.h"
@@ skipping 136 matching lines @@
 bool MP4StreamParser::ParseMoov(BoxReader* reader) {
   moov_.reset(new Movie);
   RCHECK(moov_->Parse(reader));
   runs_.reset(new TrackRunIterator(moov_.get()));
 
   has_audio_ = false;
   has_video_ = false;
 
   AudioDecoderConfig audio_config;
   VideoDecoderConfig video_config;
+  bool is_audio_encrypted = false;
+  bool is_video_encrypted = false;
 
   for (std::vector<Track>::const_iterator track = moov_->tracks.begin();
        track != moov_->tracks.end(); ++track) {
     // TODO(strobe): Only the first audio and video track present in a file are
     // used. (Track selection is better accomplished via Source IDs, though, so
     // adding support for track selection within a stream is low-priority.)
     const SampleDescription& samp_descr =
         track->media.information.sample_table.description;
 
     // TODO(strobe): When codec reconfigurations are supported, detect and send
@@ skipping 24 matching lines @@
             (entry.format == FOURCC_ENCA &&
              entry.sinf.format.format == FOURCC_MP4A))) {
         LOG(ERROR) << "Unsupported audio format.";
         return false;
       }
       // Check if it is MPEG4 AAC defined in ISO 14496 Part 3.
       if (entry.esds.object_type != kISO_14496_3) {
         LOG(ERROR) << "Unsupported audio object type.";
         return false;
       }
+
+      is_audio_encrypted = entry.sinf.info.track_encryption.is_encrypted;
       RCHECK(EmitKeyNeeded(entry.sinf.info.track_encryption));
 
       audio_config.Initialize(kCodecAAC, entry.samplesize,
                               aac.channel_layout(),
                               aac.GetOutputSamplesPerSecond(has_sbr_),
                               NULL, 0, false);
       has_audio_ = true;
       audio_track_id_ = track->header.track_id;
     }
     if (track->media.handler.type == kVideo && !video_config.IsValidConfig()) {
       RCHECK(!samp_descr.video_entries.empty());
       if (desc_idx >= samp_descr.video_entries.size())
         desc_idx = 0;
       const VideoSampleEntry& entry = samp_descr.video_entries[desc_idx];
 
       if (!(entry.format == FOURCC_AVC1 ||
             (entry.format == FOURCC_ENCV &&
              entry.sinf.format.format == FOURCC_AVC1))) {
         LOG(ERROR) << "Unsupported video format.";
         return false;
       }
+
+      is_video_encrypted = entry.sinf.info.track_encryption.is_encrypted;
       RCHECK(EmitKeyNeeded(entry.sinf.info.track_encryption));
 
       // TODO(strobe): Recover correct crop box
       gfx::Size coded_size(entry.width, entry.height);
       gfx::Rect visible_rect(coded_size);
       gfx::Size natural_size = GetNaturalSize(visible_rect.size(),
                                               entry.pixel_aspect.h_spacing,
                                               entry.pixel_aspect.v_spacing);
       video_config.Initialize(kCodecH264, H264PROFILE_MAIN,  VideoFrame::YV12,
                               coded_size, visible_rect, natural_size,
                               // No decoder-specific buffer needed for AVC;
                               // SPS/PPS are embedded in the video stream
                               NULL, 0, true);
       has_video_ = true;
       video_track_id_ = track->header.track_id;
     }
   }
 
-  RCHECK(config_cb_.Run(audio_config, video_config));
+  RCHECK(config_cb_.Run(audio_config, video_config,
+                        is_audio_encrypted, is_video_encrypted));
 
   base::TimeDelta duration;
   if (moov_->extends.header.fragment_duration > 0) {
     duration = TimeDeltaFromRational(moov_->extends.header.fragment_duration,
                                      moov_->header.timescale);
   } else if (moov_->header.duration > 0) {
     duration = TimeDeltaFromRational(moov_->header.duration,
                                      moov_->header.timescale);
   } else {
     duration = kInfiniteDuration();
@@ skipping 232 matching lines @@
   return !err;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 }  // namespace mp4
 }  // namespace media