media config: expand is_encrypted to a struct.

media/formats/mp2t/es_parser_h264.cc

 // Copyright 2014 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/formats/mp2t/es_parser_h264.h"
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
+#include "media/base/encryption_scheme.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/filters/h264_parser.h"
 #include "media/formats/common/offset_byte_queue.h"
 #include "media/formats/mp2t/mp2t_common.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace media {
@@ skipping 203 matching lines @@
     // does not necessarily start with an SPS/PPS/IDR.
     // In this case, the initial frames are conveyed to the upper layer with
     // an invalid VideoDecoderConfig and it's up to the upper layer
     // to process this kind of frame accordingly.
     if (last_video_decoder_config_.IsValidConfig())
       return false;
   } else {
     const H264SPS* sps = h264_parser_->GetSPS(pps->seq_parameter_set_id);
     if (!sps)
       return false;
-    RCHECK(UpdateVideoDecoderConfig(sps));
+    EncryptionScheme scheme(false);
+    RCHECK(UpdateVideoDecoderConfig(sps, scheme));

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

ditto

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

The second CL shows why it's like this.

   }
 
   // Emit a frame.
   DVLOG(LOG_LEVEL_ES) << "Emit frame: stream_pos=" << current_access_unit_pos_
                       << " size=" << access_unit_size;
   int es_size;
   const uint8* es;
   es_queue_->PeekAt(current_access_unit_pos_, &es, &es_size);
   CHECK_GE(es_size, access_unit_size);
 
   // TODO(wolenetz/acolwell): Validate and use a common cross-parser TrackId
   // type and allow multiple video tracks. See https://crbug.com/341581.
   scoped_refptr<StreamParserBuffer> stream_parser_buffer =
       StreamParserBuffer::CopyFrom(
           es,
           access_unit_size,
           is_key_frame,
           DemuxerStream::VIDEO,
           0);
   stream_parser_buffer->SetDecodeTimestamp(current_timing_desc.dts);
   stream_parser_buffer->set_timestamp(current_timing_desc.pts);
+#ifdef ENABLE_HLS_SAMPLE_AES

[yucliu1, 2015/12/10 00:12:19]

Remove this block in this CL?

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

Agreed.

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

Yes, this was an oversight when I split my work into two CLs.

+  if (use_hls_sample_aes_) {
+    // TODO(dougsteed): temporary place-holders.
+    const std::string key_id = "XXXXXXXXXXXXXXXX";
+    const std::string iv = "IVIVIVIVIVIVIVIV";
+    scoped_ptr<DecryptConfig> decrypt_config(
+        new DecryptConfig(key_id, iv, subsamples));
+    stream_parser_buffer->set_decrypt_config(decrypt_config.Pass());
+  }
+#endif
   return es_adapter_.OnNewBuffer(stream_parser_buffer);
 }
 
-bool EsParserH264::UpdateVideoDecoderConfig(const H264SPS* sps) {
+bool EsParserH264::UpdateVideoDecoderConfig(const H264SPS* sps,
+                                            const EncryptionScheme& scheme) {
   // Set the SAR to 1 when not specified in the H264 stream.
   int sar_width = (sps->sar_width == 0) ? 1 : sps->sar_width;
   int sar_height = (sps->sar_height == 0) ? 1 : sps->sar_height;
 
   // TODO(damienv): a MAP unit can be either 16 or 32 pixels.
   // although it's 16 pixels for progressive non MBAFF frames.
   gfx::Size coded_size((sps->pic_width_in_mbs_minus1 + 1) * 16,
                        (sps->pic_height_in_map_units_minus1 + 1) * 16);
   gfx::Rect visible_rect(
       sps->frame_crop_left_offset,
       sps->frame_crop_top_offset,
       (coded_size.width() - sps->frame_crop_right_offset) -
       sps->frame_crop_left_offset,
       (coded_size.height() - sps->frame_crop_bottom_offset) -
       sps->frame_crop_top_offset);
   if (visible_rect.width() <= 0 || visible_rect.height() <= 0)
     return false;
   gfx::Size natural_size(
       (visible_rect.width() * sar_width) / sar_height,
       visible_rect.height());
   if (natural_size.width() == 0)
     return false;
 
   VideoDecoderConfig video_decoder_config(
       kCodecH264, VIDEO_CODEC_PROFILE_UNKNOWN, PIXEL_FORMAT_YV12,
       COLOR_SPACE_HD_REC709, coded_size, visible_rect, natural_size,
-      std::vector<uint8_t>(), false);
+      std::vector<uint8_t>(), scheme);
 
   if (!video_decoder_config.Matches(last_video_decoder_config_)) {
     DVLOG(1) << "Profile IDC: " << sps->profile_idc;
     DVLOG(1) << "Level IDC: " << sps->level_idc;
     DVLOG(1) << "Pic width: " << coded_size.width();
     DVLOG(1) << "Pic height: " << coded_size.height();
     DVLOG(1) << "log2_max_frame_num_minus4: "
              << sps->log2_max_frame_num_minus4;
     DVLOG(1) << "SAR: width=" << sps->sar_width
              << " height=" << sps->sar_height;
     last_video_decoder_config_ = video_decoder_config;
     es_adapter_.OnConfigChanged(video_decoder_config);
   }
 
   return true;
 }
 
 }  // namespace mp2t
 }  // namespace media