Chromecast: Add stream id interface in DecoderBufferBase class

chromecast/media/cma/ipc_streamer/decoder_buffer_base_marshaller.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 "chromecast/media/cma/ipc_streamer/decoder_buffer_base_marshaller.h"
 
 #include "base/logging.h"
 #include "chromecast/media/cma/base/decoder_buffer_base.h"
 #include "chromecast/media/cma/ipc/media_message.h"
 #include "chromecast/media/cma/ipc/media_message_type.h"
 #include "chromecast/media/cma/ipc_streamer/decrypt_config_marshaller.h"
 #include "media/base/decrypt_config.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 const size_t kMaxFrameSize = 4 * 1024 * 1024;
 
 class DecoderBufferFromMsg : public DecoderBufferBase {
  public:
   explicit DecoderBufferFromMsg(scoped_ptr<MediaMessage> msg);
 
   void Initialize();
 
   // DecoderBufferBase implementation.
+  StreamId stream_id() const override;
   base::TimeDelta timestamp() const override;
   const uint8* data() const override;
   uint8* writable_data() const override;
   size_t data_size() const override;
   const ::media::DecryptConfig* decrypt_config() const override;
   bool end_of_stream() const override;
 
  private:
   ~DecoderBufferFromMsg() override;
 
   // Indicates whether this is an end of stream frame.
   bool is_eos_;
 
+  // Stream Id this decoder buffer belonging to.

[gunsch, 2015/05/22 01:45:26]

wording: "Stream this decoder buffer belongs to."

[erickung1, 2015/05/22 17:33:22]

Done.

+  StreamId stream_id_;
+
   // Frame timestamp.
   base::TimeDelta pts_;
 
   // CENC parameters.
   scoped_ptr< ::media::DecryptConfig> decrypt_config_;
 
   // Size of the frame.
   size_t data_size_;
 
   // Keeps the message since frame data is not copied.
   scoped_ptr<MediaMessage> msg_;
   uint8* data_;
 
   DISALLOW_COPY_AND_ASSIGN(DecoderBufferFromMsg);
 };
 
 DecoderBufferFromMsg::DecoderBufferFromMsg(
     scoped_ptr<MediaMessage> msg)
     : is_eos_(true),
+      stream_id_(kPrimary),
       msg_(msg.Pass()),
       data_(NULL) {
   CHECK(msg_);
 }
 
 DecoderBufferFromMsg::~DecoderBufferFromMsg() {
 }
 
 void DecoderBufferFromMsg::Initialize() {
   CHECK_EQ(msg_->type(), FrameMediaMsg);
 
   CHECK(msg_->ReadPod(&is_eos_));
   if (is_eos_)
     return;
 
+  CHECK(msg_->ReadPod(&stream_id_));
+
   int64 pts_internal = 0;
   CHECK(msg_->ReadPod(&pts_internal));
   pts_ = base::TimeDelta::FromInternalValue(pts_internal);
 
   bool has_decrypt_config = false;
   CHECK(msg_->ReadPod(&has_decrypt_config));
   if (has_decrypt_config)
     decrypt_config_.reset(DecryptConfigMarshaller::Read(msg_.get()).release());
 
   CHECK(msg_->ReadPod(&data_size_));
   CHECK_GT(data_size_, 0u);
   CHECK_LT(data_size_, kMaxFrameSize);
 
   // Get a pointer to the frame data inside the message.
   // Avoid copying the frame data here.
   data_ = static_cast<uint8*>(msg_->GetWritableBuffer(data_size_));
   CHECK(data_);
 
   if (decrypt_config_) {
     uint32 subsample_total_size = 0;
     for (size_t k = 0; k < decrypt_config_->subsamples().size(); k++) {
       subsample_total_size += decrypt_config_->subsamples()[k].clear_bytes;
       subsample_total_size += decrypt_config_->subsamples()[k].cypher_bytes;
     }
     CHECK_EQ(subsample_total_size, data_size_);
   }
 }
 
+StreamId DecoderBufferFromMsg::stream_id() const {
+  return stream_id_;

[gunsch, 2015/05/22 01:45:26]

you could just return kPrimary here and not have the member variable

[erickung1, 2015/05/22 17:33:22]

Although right now all code uses kPrimary, we should still honer the data  IPC
message, so that in the future we don't have to go back to make the change here
if other stream id will be used

+}
+
 base::TimeDelta DecoderBufferFromMsg::timestamp() const {
   return pts_;
 }
 
 const uint8* DecoderBufferFromMsg::data() const {
   CHECK(msg_->IsSerializedMsgAvailable());
   return data_;
 }
 
 uint8* DecoderBufferFromMsg::writable_data() const {
@@ skipping 16 matching lines @@
 }  // namespace
 
 // static
 void DecoderBufferBaseMarshaller::Write(
     const scoped_refptr<DecoderBufferBase>& buffer,
     MediaMessage* msg) {
   CHECK(msg->WritePod(buffer->end_of_stream()));
   if (buffer->end_of_stream())
     return;
 
+  CHECK(msg->WritePod(buffer->stream_id()));
   CHECK(msg->WritePod(buffer->timestamp().ToInternalValue()));
 
   bool has_decrypt_config =
       (buffer->decrypt_config() != NULL &&
        buffer->decrypt_config()->iv().size() > 0);
   CHECK(msg->WritePod(has_decrypt_config));
 
   if (has_decrypt_config) {
     // DecryptConfig may contain 0 subsamples if all content is encrypted.
     // Map this case to a single fully-encrypted "subsample" for more consistent
@@ skipping 20 matching lines @@
 scoped_refptr<DecoderBufferBase> DecoderBufferBaseMarshaller::Read(
     scoped_ptr<MediaMessage> msg) {
   scoped_refptr<DecoderBufferFromMsg> buffer(
       new DecoderBufferFromMsg(msg.Pass()));
   buffer->Initialize();
   return buffer;
 }
 
 }  // namespace media
 }  // namespace chromecast