MSE: Add StreamParser buffer remuxing utility and tests

media/base/stream_parser_buffer.h

 // 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.
 
 #ifndef MEDIA_BASE_STREAM_PARSER_BUFFER_H_
 #define MEDIA_BASE_STREAM_PARSER_BUFFER_H_
 
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_export.h"
 
 namespace media {
 
 class MEDIA_EXPORT StreamParserBuffer : public DecoderBuffer {
  public:
   // Value used to signal an invalid decoder config ID.
   enum { kInvalidConfigId = -1 };
 
+  enum Type {

[xhwang, 2014/01/29 08:04:50]

Does it make sense to reuse DemuxerStream::Type? If we do that, we can use
UNKNOWN for EOS.

e.g. you can do typedef DemuxerStream::Type Type; But unfortunately we still
need to use StreamType::VIDEO et al.

[wolenetz, 2014/02/05 02:49:53]

tl;dr: Seems reasonable to me. I've made the changes.

pros of reusing DemuxerStream::Type:
* one less media type enum 
* well-defined UNKNOWN for edge cases like EOS or when constructing dummy
buffers for sorting purposes.
cons:
* Parsers must not emit UNKNOWN-annotated buffers. It seems this can be
DCHECK'ed+cause parse-failure in the upcoming coded-frame-processing
reimplementation of SourceState::OnNewBuffers().

+    kAudio,
+    kVideo,
+    kText
+  };

[xhwang, 2014/01/29 08:04:50]

FYI, we are moving from kCamelCase to UPPER_CASE style for enums.

[wolenetz, 2014/02/05 02:49:53]

Cool. Thank you.

+
   static scoped_refptr<StreamParserBuffer> CreateEOSBuffer();
   static scoped_refptr<StreamParserBuffer> CopyFrom(
-      const uint8* data, int data_size, bool is_keyframe);
+      const uint8* data, int data_size, bool is_keyframe, Type type);
   static scoped_refptr<StreamParserBuffer> CopyFrom(
       const uint8* data, int data_size,
-      const uint8* side_data, int side_data_size, bool is_keyframe);
+      const uint8* side_data, int side_data_size, bool is_keyframe, Type type);
   bool IsKeyframe() const { return is_keyframe_; }
 
   // Decode timestamp. If not explicitly set, or set to kNoTimestamp(), the
   // value will be taken from the normal timestamp.
   base::TimeDelta GetDecodeTimestamp() const;
   void SetDecodeTimestamp(const base::TimeDelta& timestamp);
 
-  // Gets/sets the ID of the decoder config associated with this
-  // buffer.
+  // Gets/sets the ID of the decoder config associated with this buffer.
   int GetConfigId() const;
   void SetConfigId(int config_id);
 
+  // Gets the parser's media type associated with this buffer. Value is
+  // meaningless for EOS buffers.
+  Type type() const { return type_; }
+
+  // Gets/sets the parser's text track number associated with this buffer. Value
+  // is meaningless for EOS buffers or buffers whose type() is not |kText|.
+  int text_track_number() const { return text_track_number_; }
+  void set_text_track_number(int track_num) { text_track_number_ =  track_num; }
+
   // Buffers to be exhausted before using the data in this DecoderBuffer.  Used
   // to implement the Audio Splice Frame Algorithm per the MSE specification.
   const std::vector<scoped_refptr<StreamParserBuffer> >& GetFadeOutPreroll()
       const;
   void SetFadeOutPreroll(
       const std::vector<scoped_refptr<StreamParserBuffer> >& fade_out_preroll);
 
  private:
   StreamParserBuffer(const uint8* data, int data_size,
                      const uint8* side_data, int side_data_size,
-                     bool is_keyframe);
+                     bool is_keyframe, Type type);
   virtual ~StreamParserBuffer();
 
   bool is_keyframe_;
   base::TimeDelta decode_timestamp_;
   int config_id_;
+  Type type_;
+  int text_track_number_;

[xhwang, 2014/01/29 08:04:50]

document range of |text_track_number|, e.g. -1 is invalid.

[wolenetz, 2014/02/05 02:49:53]

For the current WebM Tracks Parser, -1 is indeed invalid. I'm not sure that will
apply to all MSE stream parsers that may eventually support text tracks. Perhaps
leaking too much of StreamParser, I've now commented this is the key for the
buffer's text track in the applicable TextTrackConfigMap (which is passed in
StreamParser::NewConfigCB).

   std::vector<scoped_refptr<StreamParserBuffer> > fade_out_preroll_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamParserBuffer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_STREAM_PARSER_BUFFER_H_