Implemented passing media track info from ffmpeg into blink

media/filters/media_source_state.h

 // Copyright (c) 2016 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_FILTERS_MEDIA_SOURCE_STATE_H_
 #define MEDIA_FILTERS_MEDIA_SOURCE_STATE_H_
 
 #include <list>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 class ChunkDemuxerStream;
 class FrameProcessor;
 
 // Contains state belonging to a source id.
 class MEDIA_EXPORT MediaSourceState {
  public:
   // Callback signature used to create ChunkDemuxerStreams.
   typedef base::Callback<ChunkDemuxerStream*(DemuxerStream::Type)>
       CreateDemuxerStreamCB;
 
-  typedef base::Closure InitSegmentReceivedCB;
-
   typedef base::Callback<void(ChunkDemuxerStream*, const TextTrackConfig&)>
       NewTextTrackCB;
 
   MediaSourceState(scoped_ptr<StreamParser> stream_parser,
                    scoped_ptr<FrameProcessor> frame_processor,
                    const CreateDemuxerStreamCB& create_demuxer_stream_cb,
                    const scoped_refptr<MediaLog>& media_log);
 
   ~MediaSourceState();
 
   void Init(const StreamParser::InitCB& init_cb,
             bool allow_audio,
             bool allow_video,
             const StreamParser::EncryptedMediaInitDataCB&
                 encrypted_media_init_data_cb,
             const NewTextTrackCB& new_text_track_cb);
 
   // Appends new data to the StreamParser.
   // Returns true if the data was successfully appended. Returns false if an
   // error occurred. |*timestamp_offset| is used and possibly updated by the
   // append. |append_window_start| and |append_window_end| correspond to the MSE
   // spec's similarly named source buffer attributes that are used in coded
-  // frame processing. |init_segment_received_cb| is run for each new fully
-  // parsed initialization segment.
+  // frame processing.
   bool Append(const uint8_t* data,
               size_t length,
               TimeDelta append_window_start,
               TimeDelta append_window_end,
-              TimeDelta* timestamp_offset,
-              const InitSegmentReceivedCB& init_segment_received_cb);
+              TimeDelta* timestamp_offset);
 
   // Aborts the current append sequence and resets the parser.
   void ResetParserState(TimeDelta append_window_start,
                         TimeDelta append_window_end,
                         TimeDelta* timestamp_offset);
 
   // Calls Remove(|start|, |end|, |duration|) on all
   // ChunkDemuxerStreams managed by this object.
   void Remove(TimeDelta start, TimeDelta end, TimeDelta duration);
 
@@ skipping 37 matching lines @@
   // |memory_limit| is the maximum number of bytes each stream of type |type|
   // is allowed to hold in its buffer.
   void SetMemoryLimits(DemuxerStream::Type type, size_t memory_limit);
   bool IsSeekWaitingForData() const;
 
   typedef std::list<Ranges<TimeDelta>> RangesList;
   static Ranges<TimeDelta> ComputeRangesIntersection(
       const RangesList& activeRanges,
       bool ended);
 
+  void SetTracksWatcher(const Demuxer::MediaTracksUpdatedCB& tracks_updated_cb);
+
  private:
   // Called by the |stream_parser_| when a new initialization segment is
   // encountered.
   // Returns true on a successful call. Returns false if an error occurred while
   // processing decoder configurations.
   bool OnNewConfigs(bool allow_audio,
                     bool allow_video,
-                    const AudioDecoderConfig& audio_config,
-                    const VideoDecoderConfig& video_config,
+                    scoped_ptr<MediaTracks> tracks,
                     const StreamParser::TextTrackConfigMap& text_configs);
 
   // Called by the |stream_parser_| at the beginning of a new media segment.
   void OnNewMediaSegment();
 
   // Called by the |stream_parser_| at the end of a media segment.
   void OnEndOfMediaSegment();
 
   // Called by the |stream_parser_| when new buffers have been parsed.
   // It processes the new buffers using |frame_processor_|, which includes
@@ skipping 37 matching lines @@
 
   // Valid only while |parsing_media_segment_| is true. These flags enable
   // warning when at least one frame for each A/V track is not in a parsed media
   // segment.
   bool media_segment_contained_audio_frame_;
   bool media_segment_contained_video_frame_;
 
   // The object used to parse appended data.
   scoped_ptr<StreamParser> stream_parser_;
 
+  scoped_ptr<MediaTracks> media_tracks_;
+
   ChunkDemuxerStream* audio_;  // Not owned by |this|.
   ChunkDemuxerStream* video_;  // Not owned by |this|.
 
   typedef std::map<StreamParser::TrackId, ChunkDemuxerStream*> TextStreamMap;
   TextStreamMap text_stream_map_;  // |this| owns the map's stream pointers.
 
   scoped_ptr<FrameProcessor> frame_processor_;
   scoped_refptr<MediaLog> media_log_;
   StreamParser::InitCB init_cb_;
 
   // During Append(), OnNewConfigs() will trigger the initialization segment
-  // received algorithm. This callback is only non-NULL during the lifetime of
-  // an Append() call. Note, the MSE spec explicitly disallows this algorithm
+  // received algorithm. Note, the MSE spec explicitly disallows this algorithm
   // during an Abort(), since Abort() is allowed only to emit coded frames, and
-  // only if the parser is PARSING_MEDIA_SEGMENT (not an INIT segment).
-  InitSegmentReceivedCB init_segment_received_cb_;
+  // only if the parser is PARSING_MEDIA_SEGMENT (not an INIT segment). So we
+  // also have a flag here that indicates if Append is in progress and we can
+  // invoke this callback.
+  Demuxer::MediaTracksUpdatedCB init_segment_received_cb_;
+  bool append_in_progress_ = false;
 
   // Indicates that timestampOffset should be updated automatically during
   // OnNewBuffers() based on the earliest end timestamp of the buffers provided.
   // TODO(wolenetz): Refactor this function while integrating April 29, 2014
   // changes to MSE spec. See http://crbug.com/371499.
   bool auto_update_timestamp_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSourceState);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_MEDIA_SOURCE_STATE_H_