Support encrypted audio stream in demuxer.

media/webm/webm_cluster_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/webm/webm_cluster_parser.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/sys_byteorder.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/webm/webm_constants.h"
 
 namespace media {
 
 // Generates a 16 byte CTR counter block. The CTR counter block format is a
 // CTR IV appended with a CTR block counter. |iv| is an 8 byte CTR IV.
 // Returns a string of kDecryptionKeySize bytes.
 static std::string GenerateCounterBlock(uint64 iv) {
   std::string counter_block(reinterpret_cast<char*>(&iv), sizeof(iv));
   counter_block.append(DecryptConfig::kDecryptionKeySize - sizeof(iv), 0);
   return counter_block;
 }
 
 WebMClusterParser::WebMClusterParser(int64 timecode_scale,
                                      int audio_track_num,
                                      int video_track_num,
+                                     const std::string& audio_encryption_key_id,
                                      const std::string& video_encryption_key_id)
     : timecode_multiplier_(timecode_scale / 1000.0),
+      audio_encryption_key_id_(audio_encryption_key_id),
       video_encryption_key_id_(video_encryption_key_id),
       parser_(kWebMIdCluster, this),
       last_block_timecode_(-1),
       block_data_size_(-1),
       block_duration_(-1),
       cluster_timecode_(-1),
       cluster_start_time_(kNoTimestamp()),
       cluster_ended_(false),
       audio_(audio_track_num),
       video_(video_track_num) {
@@ skipping 150 matching lines @@
   if (timecode < 0) {
     DVLOG(1) << "Got a block with negative timecode offset " << timecode;
     return false;
   }
 
   if (last_block_timecode_ != -1 && timecode < last_block_timecode_) {
     DVLOG(1) << "Got a block with a timecode before the previous block.";
     return false;
   }
 
+  Track* track = NULL;
+  std::string encryption_key_id;

[ddorwin, 2012/10/10 07:14:52]

const ref?

[xhwang, 2012/10/11 00:49:41]

Ref has to be initialized upon declaration. If we want to avoid this copy (of
16/32 bytes), I can do at line 215:

const std::string& encryption_key_id = track_num == audio_.track_num() ?
audio_encryption_key_id_ : video_encryption_key_id_;

which I feel isn't as clean as the current code. WDYT?

[ddorwin, 2012/10/11 05:18:22]

Oh, duh. Nevermind.

+  if (track_num == audio_.track_num()) {
+    track = &audio_;
+    encryption_key_id = audio_encryption_key_id_;
+  } else if (track_num == video_.track_num()) {
+    track = &video_;
+    encryption_key_id = video_encryption_key_id_;
+  } else {
+    DVLOG(1) << "Unexpected track number " << track_num;

[ddorwin, 2012/10/10 07:14:52]

I know this was copied from below, but it seems like it should be a
DLOG(WARNING). It would be nice to see we are processing bad content.

[acolwell GONE FROM CHROMIUM, 2012/10/10 16:00:06]

I don't think this condition is any more important than the other DVLOG()
messages that report errors so I'd rather keep this consistent with the other
log messages. 

If there is a desire to have a wholesale change on this front then I think that
should be a different CL.

+    return false;
+  }
+
   last_block_timecode_ = timecode;
 
   base::TimeDelta timestamp = base::TimeDelta::FromMicroseconds(
       (cluster_timecode_ + timecode) * timecode_multiplier_);
 
-  // Every encrypted Block has a signal byte and IV prepended to it. Current
-  // encrypted WebM request for comments specification is here
-  // http://wiki.webmproject.org/encryption/webm-encryption-rfc
-  bool is_track_encrypted =
-      track_num == video_.track_num() && !video_encryption_key_id_.empty();
-
   // The first bit of the flags is set when the block contains only keyframes.
   // http://www.matroska.org/technical/specs/index.html
   bool is_keyframe = (flags & 0x80) != 0;
   scoped_refptr<StreamParserBuffer> buffer =
       StreamParserBuffer::CopyFrom(data, size, is_keyframe);
 
-  if (is_track_encrypted) {
+  // Every encrypted Block has a signal byte and IV prepended to it. Current
+  // encrypted WebM request for comments specification is here
+  // http://wiki.webmproject.org/encryption/webm-encryption-rfc
+  if (!encryption_key_id.empty()) {
     uint8 signal_byte = data[0];
     int data_offset = sizeof(signal_byte);
 
     // Setting the DecryptConfig object of the buffer while leaving the
     // initialization vector empty will tell the decryptor that the frame is
     // unencrypted.
     std::string counter_block;
 
     if (signal_byte & kWebMFlagEncryptedFrame) {
       uint64 network_iv;
       memcpy(&network_iv, data + data_offset, sizeof(network_iv));
       const uint64 iv = base::NetToHost64(network_iv);
       counter_block = GenerateCounterBlock(iv);
       data_offset += sizeof(iv);

[acolwell GONE FROM CHROMIUM, 2012/10/10 16:00:06]

nit:s/sizeof(iv)/sizeof(network_iv) since network_iv is really the one you are
extracting from the data buffer. It would also be nice to have this right under
the memcpy(). 

Also once you do this, you don't really need the iv variable anymore.

[xhwang, 2012/10/11 00:49:41]

Done.

     }
 
     // TODO(fgalligan): Revisit if DecryptConfig needs to be set on unencrypted
     // frames after the CDM API is finalized.
     // Unencrypted frames of potentially encrypted streams currently set
     // DecryptConfig.
     buffer->SetDecryptConfig(scoped_ptr<DecryptConfig>(new DecryptConfig(
         video_encryption_key_id_,

[acolwell GONE FROM CHROMIUM, 2012/10/10 16:00:06]

s/video_encryption_key_id_/encryption_key_id ?

[xhwang, 2012/10/11 00:49:41]

good catch. thanks!

         counter_block,
         data_offset,
         std::vector<SubsampleEntry>())));
   }
 
   buffer->SetTimestamp(timestamp);
   if (cluster_start_time_ == kNoTimestamp())
     cluster_start_time_ = timestamp;
 
   if (block_duration >= 0) {
     buffer->SetDuration(base::TimeDelta::FromMicroseconds(
         block_duration * timecode_multiplier_));
   }
 
-  if (track_num == audio_.track_num()) {
-    return audio_.AddBuffer(buffer);
-  } else if (track_num == video_.track_num()) {
-    return video_.AddBuffer(buffer);
-  }
-
-  DVLOG(1) << "Unexpected track number " << track_num;
-  return false;
+  return track->AddBuffer(buffer);
 }
 
 WebMClusterParser::Track::Track(int track_num)
     : track_num_(track_num) {
 }
 
 WebMClusterParser::Track::~Track() {}
 
 bool WebMClusterParser::Track::AddBuffer(
     const scoped_refptr<StreamParserBuffer>& buffer) {
   DVLOG(2) << "AddBuffer() : " << track_num_
            << " ts " << buffer->GetTimestamp().InSecondsF()
            << " dur " << buffer->GetDuration().InSecondsF()
            << " kf " << buffer->IsKeyframe()
            << " size " << buffer->GetDataSize();
 
   buffers_.push_back(buffer);
   return true;
 }
 
 void WebMClusterParser::Track::Reset() {
   buffers_.clear();
 }
 
 }  // namespace media