Home | History | Annotate | Download | only in filters 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "media/filters/chunk_demuxer.h"
      6 
      7 #include <algorithm>
      8 #include <limits>
      9 #include <list>
     10 
     11 #include "base/bind.h"
     12 #include "base/callback_helpers.h"
     13 #include "base/location.h"
     14 #include "base/message_loop/message_loop_proxy.h"
     15 #include "base/stl_util.h"
     16 #include "media/base/audio_decoder_config.h"
     17 #include "media/base/bind_to_current_loop.h"
     18 #include "media/base/stream_parser_buffer.h"
     19 #include "media/base/video_decoder_config.h"
     20 #include "media/filters/frame_processor.h"
     21 #include "media/filters/stream_parser_factory.h"
     22 
     23 using base::TimeDelta;
     24 
     25 namespace media {
     26 
     27 static TimeDelta EndTimestamp(const StreamParser::BufferQueue& queue) {
     28   return queue.back()->timestamp() + queue.back()->duration();
     29 }
     30 
     31 // List of time ranges for each SourceBuffer.
     32 typedef std::list<Ranges<TimeDelta> > RangesList;
     33 static Ranges<TimeDelta> ComputeIntersection(const RangesList& activeRanges,
     34                                              bool ended) {
     35   // Implementation of HTMLMediaElement.buffered algorithm in MSE spec.
     36   // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#dom-htmlmediaelement.buffered
     37 
     38   // Step 1: If activeSourceBuffers.length equals 0 then return an empty
     39   //  TimeRanges object and abort these steps.
     40   if (activeRanges.empty())
     41     return Ranges<TimeDelta>();
     42 
     43   // Step 2: Let active ranges be the ranges returned by buffered for each
     44   //  SourceBuffer object in activeSourceBuffers.
     45   // Step 3: Let highest end time be the largest range end time in the active
     46   //  ranges.
     47   TimeDelta highest_end_time;
     48   for (RangesList::const_iterator itr = activeRanges.begin();
     49        itr != activeRanges.end(); ++itr) {
     50     if (!itr->size())
     51       continue;
     52 
     53     highest_end_time = std::max(highest_end_time, itr->end(itr->size() - 1));
     54   }
     55 
     56   // Step 4: Let intersection ranges equal a TimeRange object containing a
     57   //  single range from 0 to highest end time.
     58   Ranges<TimeDelta> intersection_ranges;
     59   intersection_ranges.Add(TimeDelta(), highest_end_time);
     60 
     61   // Step 5: For each SourceBuffer object in activeSourceBuffers run the
     62   //  following steps:
     63   for (RangesList::const_iterator itr = activeRanges.begin();
     64        itr != activeRanges.end(); ++itr) {
     65     // Step 5.1: Let source ranges equal the ranges returned by the buffered
     66     //  attribute on the current SourceBuffer.
     67     Ranges<TimeDelta> source_ranges = *itr;
     68 
     69     // Step 5.2: If readyState is "ended", then set the end time on the last
     70     //  range in source ranges to highest end time.
     71     if (ended && source_ranges.size() > 0u) {
     72       source_ranges.Add(source_ranges.start(source_ranges.size() - 1),
     73                         highest_end_time);
     74     }
     75 
     76     // Step 5.3: Let new intersection ranges equal the intersection between
     77     // the intersection ranges and the source ranges.
     78     // Step 5.4: Replace the ranges in intersection ranges with the new
     79     // intersection ranges.
     80     intersection_ranges = intersection_ranges.IntersectionWith(source_ranges);
     81   }
     82 
     83   return intersection_ranges;
     84 }
     85 
     86 // Contains state belonging to a source id.
     87 class SourceState {
     88  public:
     89   // Callback signature used to create ChunkDemuxerStreams.
     90   typedef base::Callback<ChunkDemuxerStream*(
     91       DemuxerStream::Type)> CreateDemuxerStreamCB;
     92 
     93   typedef ChunkDemuxer::InitSegmentReceivedCB InitSegmentReceivedCB;
     94 
     95   typedef base::Callback<void(
     96       ChunkDemuxerStream*, const TextTrackConfig&)> NewTextTrackCB;
     97 
     98   SourceState(
     99       scoped_ptr<StreamParser> stream_parser,
    100       scoped_ptr<FrameProcessor> frame_processor, const LogCB& log_cb,
    101       const CreateDemuxerStreamCB& create_demuxer_stream_cb);
    102 
    103   ~SourceState();
    104 
    105   void Init(const StreamParser::InitCB& init_cb,
    106             bool allow_audio,
    107             bool allow_video,
    108             const StreamParser::NeedKeyCB& need_key_cb,
    109             const NewTextTrackCB& new_text_track_cb);
    110 
    111   // Appends new data to the StreamParser.
    112   // Returns true if the data was successfully appended. Returns false if an
    113   // error occurred. |*timestamp_offset| is used and possibly updated by the
    114   // append. |append_window_start| and |append_window_end| correspond to the MSE
    115   // spec's similarly named source buffer attributes that are used in coded
    116   // frame processing. |init_segment_received_cb| is run for each new fully
    117   // parsed initialization segment.
    118   bool Append(const uint8* data,
    119               size_t length,
    120               TimeDelta append_window_start,
    121               TimeDelta append_window_end,
    122               TimeDelta* timestamp_offset,
    123               const InitSegmentReceivedCB& init_segment_received_cb);
    124 
    125   // Aborts the current append sequence and resets the parser.
    126   void Abort(TimeDelta append_window_start,
    127              TimeDelta append_window_end,
    128              TimeDelta* timestamp_offset);
    129 
    130   // Calls Remove(|start|, |end|, |duration|) on all
    131   // ChunkDemuxerStreams managed by this object.
    132   void Remove(TimeDelta start, TimeDelta end, TimeDelta duration);
    133 
    134   // Returns true if currently parsing a media segment, or false otherwise.
    135   bool parsing_media_segment() const { return parsing_media_segment_; }
    136 
    137   // Sets |frame_processor_|'s sequence mode to |sequence_mode|.
    138   void SetSequenceMode(bool sequence_mode);
    139 
    140   // Signals the coded frame processor to update its group start timestamp to be
    141   // |timestamp_offset| if it is in sequence append mode.
    142   void SetGroupStartTimestampIfInSequenceMode(base::TimeDelta timestamp_offset);
    143 
    144   // Returns the range of buffered data in this source, capped at |duration|.
    145   // |ended| - Set to true if end of stream has been signaled and the special
    146   // end of stream range logic needs to be executed.
    147   Ranges<TimeDelta> GetBufferedRanges(TimeDelta duration, bool ended) const;
    148 
    149   // Returns the highest buffered duration across all streams managed
    150   // by this object.
    151   // Returns TimeDelta() if none of the streams contain buffered data.
    152   TimeDelta GetMaxBufferedDuration() const;
    153 
    154   // Helper methods that call methods with similar names on all the
    155   // ChunkDemuxerStreams managed by this object.
    156   void StartReturningData();
    157   void AbortReads();
    158   void Seek(TimeDelta seek_time);
    159   void CompletePendingReadIfPossible();
    160   void OnSetDuration(TimeDelta duration);
    161   void MarkEndOfStream();
    162   void UnmarkEndOfStream();
    163   void Shutdown();
    164   // Sets the memory limit on each stream of a specific type.
    165   // |memory_limit| is the maximum number of bytes each stream of type |type|
    166   // is allowed to hold in its buffer.
    167   void SetMemoryLimits(DemuxerStream::Type type, int memory_limit);
    168   bool IsSeekWaitingForData() const;
    169 
    170  private:
    171   // Called by the |stream_parser_| when a new initialization segment is
    172   // encountered.
    173   // Returns true on a successful call. Returns false if an error occurred while
    174   // processing decoder configurations.
    175   bool OnNewConfigs(bool allow_audio, bool allow_video,
    176                     const AudioDecoderConfig& audio_config,
    177                     const VideoDecoderConfig& video_config,
    178                     const StreamParser::TextTrackConfigMap& text_configs);
    179 
    180   // Called by the |stream_parser_| at the beginning of a new media segment.
    181   void OnNewMediaSegment();
    182 
    183   // Called by the |stream_parser_| at the end of a media segment.
    184   void OnEndOfMediaSegment();
    185 
    186   // Called by the |stream_parser_| when new buffers have been parsed.
    187   // It processes the new buffers using |frame_processor_|, which includes
    188   // appending the processed frames to associated demuxer streams for each
    189   // frame's track.
    190   // Returns true on a successful call. Returns false if an error occurred while
    191   // processing the buffers.
    192   bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
    193                     const StreamParser::BufferQueue& video_buffers,
    194                     const StreamParser::TextBufferQueueMap& text_map);
    195 
    196   void OnSourceInitDone(bool success,
    197                         const StreamParser::InitParameters& params);
    198 
    199   CreateDemuxerStreamCB create_demuxer_stream_cb_;
    200   NewTextTrackCB new_text_track_cb_;
    201 
    202   // During Append(), if OnNewBuffers() coded frame processing updates the
    203   // timestamp offset then |*timestamp_offset_during_append_| is also updated
    204   // so Append()'s caller can know the new offset. This pointer is only non-NULL
    205   // during the lifetime of an Append() call.
    206   TimeDelta* timestamp_offset_during_append_;
    207 
    208   // During Append(), coded frame processing triggered by OnNewBuffers()
    209   // requires these two attributes. These are only valid during the lifetime of
    210   // an Append() call.
    211   TimeDelta append_window_start_during_append_;
    212   TimeDelta append_window_end_during_append_;
    213 
    214   // Set to true if the next buffers appended within the append window
    215   // represent the start of a new media segment. This flag being set
    216   // triggers a call to |new_segment_cb_| when the new buffers are
    217   // appended. The flag is set on actual media segment boundaries and
    218   // when the "append window" filtering causes discontinuities in the
    219   // appended data.
    220   // TODO(wolenetz/acolwell): Investigate if we need this, or if coded frame
    221   // processing's discontinuity logic is enough. See http://crbug.com/351489.
    222   bool new_media_segment_;
    223 
    224   // Keeps track of whether a media segment is being parsed.
    225   bool parsing_media_segment_;
    226 
    227   // The object used to parse appended data.
    228   scoped_ptr<StreamParser> stream_parser_;
    229 
    230   ChunkDemuxerStream* audio_;  // Not owned by |this|.
    231   ChunkDemuxerStream* video_;  // Not owned by |this|.
    232 
    233   typedef std::map<StreamParser::TrackId, ChunkDemuxerStream*> TextStreamMap;
    234   TextStreamMap text_stream_map_;  // |this| owns the map's stream pointers.
    235 
    236   scoped_ptr<FrameProcessor> frame_processor_;
    237   LogCB log_cb_;
    238   StreamParser::InitCB init_cb_;
    239 
    240   // During Append(), OnNewConfigs() will trigger the initialization segment
    241   // received algorithm. This callback is only non-NULL during the lifetime of
    242   // an Append() call. Note, the MSE spec explicitly disallows this algorithm
    243   // during an Abort(), since Abort() is allowed only to emit coded frames, and
    244   // only if the parser is PARSING_MEDIA_SEGMENT (not an INIT segment).
    245   InitSegmentReceivedCB init_segment_received_cb_;
    246 
    247   // Indicates that timestampOffset should be updated automatically during
    248   // OnNewBuffers() based on the earliest end timestamp of the buffers provided.
    249   // TODO(wolenetz): Refactor this function while integrating April 29, 2014
    250   // changes to MSE spec. See http://crbug.com/371499.
    251   bool auto_update_timestamp_offset_;
    252 
    253   DISALLOW_COPY_AND_ASSIGN(SourceState);
    254 };
    255 
    256 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser,
    257                          scoped_ptr<FrameProcessor> frame_processor,
    258                          const LogCB& log_cb,
    259                          const CreateDemuxerStreamCB& create_demuxer_stream_cb)
    260     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
    261       timestamp_offset_during_append_(NULL),
    262       new_media_segment_(false),
    263       parsing_media_segment_(false),
    264       stream_parser_(stream_parser.release()),
    265       audio_(NULL),
    266       video_(NULL),
    267       frame_processor_(frame_processor.release()),
    268       log_cb_(log_cb),
    269       auto_update_timestamp_offset_(false) {
    270   DCHECK(!create_demuxer_stream_cb_.is_null());
    271   DCHECK(frame_processor_);
    272 }
    273 
    274 SourceState::~SourceState() {
    275   Shutdown();
    276 
    277   STLDeleteValues(&text_stream_map_);
    278 }
    279 
    280 void SourceState::Init(const StreamParser::InitCB& init_cb,
    281                        bool allow_audio,
    282                        bool allow_video,
    283                        const StreamParser::NeedKeyCB& need_key_cb,
    284                        const NewTextTrackCB& new_text_track_cb) {
    285   new_text_track_cb_ = new_text_track_cb;
    286   init_cb_ = init_cb;
    287 
    288   stream_parser_->Init(
    289       base::Bind(&SourceState::OnSourceInitDone, base::Unretained(this)),
    290       base::Bind(&SourceState::OnNewConfigs,
    291                  base::Unretained(this),
    292                  allow_audio,
    293                  allow_video),
    294       base::Bind(&SourceState::OnNewBuffers, base::Unretained(this)),
    295       new_text_track_cb_.is_null(),
    296       need_key_cb,
    297       base::Bind(&SourceState::OnNewMediaSegment, base::Unretained(this)),
    298       base::Bind(&SourceState::OnEndOfMediaSegment, base::Unretained(this)),
    299       log_cb_);
    300 }
    301 
    302 void SourceState::SetSequenceMode(bool sequence_mode) {
    303   DCHECK(!parsing_media_segment_);
    304 
    305   frame_processor_->SetSequenceMode(sequence_mode);
    306 }
    307 
    308 void SourceState::SetGroupStartTimestampIfInSequenceMode(
    309     base::TimeDelta timestamp_offset) {
    310   DCHECK(!parsing_media_segment_);
    311 
    312   frame_processor_->SetGroupStartTimestampIfInSequenceMode(timestamp_offset);
    313 }
    314 
    315 bool SourceState::Append(
    316     const uint8* data,
    317     size_t length,
    318     TimeDelta append_window_start,
    319     TimeDelta append_window_end,
    320     TimeDelta* timestamp_offset,
    321     const InitSegmentReceivedCB& init_segment_received_cb) {
    322   DCHECK(timestamp_offset);
    323   DCHECK(!timestamp_offset_during_append_);
    324   DCHECK(!init_segment_received_cb.is_null());
    325   DCHECK(init_segment_received_cb_.is_null());
    326   append_window_start_during_append_ = append_window_start;
    327   append_window_end_during_append_ = append_window_end;
    328   timestamp_offset_during_append_ = timestamp_offset;
    329   init_segment_received_cb_= init_segment_received_cb;
    330 
    331   // TODO(wolenetz/acolwell): Curry and pass a NewBuffersCB here bound with
    332   // append window and timestamp offset pointer. See http://crbug.com/351454.
    333   bool err = stream_parser_->Parse(data, length);
    334   timestamp_offset_during_append_ = NULL;
    335   init_segment_received_cb_.Reset();
    336   return err;
    337 }
    338 
    339 void SourceState::Abort(TimeDelta append_window_start,
    340                         TimeDelta append_window_end,
    341                         base::TimeDelta* timestamp_offset) {
    342   DCHECK(timestamp_offset);
    343   DCHECK(!timestamp_offset_during_append_);
    344   timestamp_offset_during_append_ = timestamp_offset;
    345   append_window_start_during_append_ = append_window_start;
    346   append_window_end_during_append_ = append_window_end;
    347 
    348   stream_parser_->Flush();
    349   timestamp_offset_during_append_ = NULL;
    350 
    351   frame_processor_->Reset();
    352   parsing_media_segment_ = false;
    353 }
    354 
    355 void SourceState::Remove(TimeDelta start, TimeDelta end, TimeDelta duration) {
    356   if (audio_)
    357     audio_->Remove(start, end, duration);
    358 
    359   if (video_)
    360     video_->Remove(start, end, duration);
    361 
    362   for (TextStreamMap::iterator itr = text_stream_map_.begin();
    363        itr != text_stream_map_.end(); ++itr) {
    364     itr->second->Remove(start, end, duration);
    365   }
    366 }
    367 
    368 Ranges<TimeDelta> SourceState::GetBufferedRanges(TimeDelta duration,
    369                                                  bool ended) const {
    370   // TODO(acolwell): When we start allowing disabled tracks we'll need to update
    371   // this code to only add ranges from active tracks.
    372   RangesList ranges_list;
    373   if (audio_)
    374     ranges_list.push_back(audio_->GetBufferedRanges(duration));
    375 
    376   if (video_)
    377     ranges_list.push_back(video_->GetBufferedRanges(duration));
    378 
    379   for (TextStreamMap::const_iterator itr = text_stream_map_.begin();
    380        itr != text_stream_map_.end(); ++itr) {
    381     ranges_list.push_back(itr->second->GetBufferedRanges(duration));
    382   }
    383 
    384   return ComputeIntersection(ranges_list, ended);
    385 }
    386 
    387 TimeDelta SourceState::GetMaxBufferedDuration() const {
    388   TimeDelta max_duration;
    389 
    390   if (audio_)
    391     max_duration = std::max(max_duration, audio_->GetBufferedDuration());
    392 
    393   if (video_)
    394     max_duration = std::max(max_duration, video_->GetBufferedDuration());
    395 
    396   for (TextStreamMap::const_iterator itr = text_stream_map_.begin();
    397        itr != text_stream_map_.end(); ++itr) {
    398     max_duration = std::max(max_duration, itr->second->GetBufferedDuration());
    399   }
    400 
    401   return max_duration;
    402 }
    403 
    404 void SourceState::StartReturningData() {
    405   if (audio_)
    406     audio_->StartReturningData();
    407 
    408   if (video_)
    409     video_->StartReturningData();
    410 
    411   for (TextStreamMap::iterator itr = text_stream_map_.begin();
    412        itr != text_stream_map_.end(); ++itr) {
    413     itr->second->StartReturningData();
    414   }
    415 }
    416 
    417 void SourceState::AbortReads() {
    418   if (audio_)
    419     audio_->AbortReads();
    420 
    421   if (video_)
    422     video_->AbortReads();
    423 
    424   for (TextStreamMap::iterator itr = text_stream_map_.begin();
    425        itr != text_stream_map_.end(); ++itr) {
    426     itr->second->AbortReads();
    427   }
    428 }
    429 
    430 void SourceState::Seek(TimeDelta seek_time) {
    431   if (audio_)
    432     audio_->Seek(seek_time);
    433 
    434   if (video_)
    435     video_->Seek(seek_time);
    436 
    437   for (TextStreamMap::iterator itr = text_stream_map_.begin();
    438        itr != text_stream_map_.end(); ++itr) {
    439     itr->second->Seek(seek_time);
    440   }
    441 }
    442 
    443 void SourceState::CompletePendingReadIfPossible() {
    444   if (audio_)
    445     audio_->CompletePendingReadIfPossible();
    446 
    447   if (video_)
    448     video_->CompletePendingReadIfPossible();
    449 
    450   for (TextStreamMap::iterator itr = text_stream_map_.begin();
    451        itr != text_stream_map_.end(); ++itr) {
    452     itr->second->CompletePendingReadIfPossible();
    453   }
    454 }
    455 
    456 void SourceState::OnSetDuration(TimeDelta duration) {
    457   if (audio_)
    458     audio_->OnSetDuration(duration);
    459 
    460   if (video_)
    461     video_->OnSetDuration(duration);
    462 
    463   for (TextStreamMap::iterator itr = text_stream_map_.begin();
    464        itr != text_stream_map_.end(); ++itr) {
    465     itr->second->OnSetDuration(duration);
    466   }
    467 }
    468 
    469 void SourceState::MarkEndOfStream() {
    470   if (audio_)
    471     audio_->MarkEndOfStream();
    472 
    473   if (video_)
    474     video_->MarkEndOfStream();
    475 
    476   for (TextStreamMap::iterator itr = text_stream_map_.begin();
    477        itr != text_stream_map_.end(); ++itr) {
    478     itr->second->MarkEndOfStream();
    479   }
    480 }
    481 
    482 void SourceState::UnmarkEndOfStream() {
    483   if (audio_)
    484     audio_->UnmarkEndOfStream();
    485 
    486   if (video_)
    487     video_->UnmarkEndOfStream();
    488 
    489   for (TextStreamMap::iterator itr = text_stream_map_.begin();
    490        itr != text_stream_map_.end(); ++itr) {
    491     itr->second->UnmarkEndOfStream();
    492   }
    493 }
    494 
    495 void SourceState::Shutdown() {
    496   if (audio_)
    497     audio_->Shutdown();
    498 
    499   if (video_)
    500     video_->Shutdown();
    501 
    502   for (TextStreamMap::iterator itr = text_stream_map_.begin();
    503        itr != text_stream_map_.end(); ++itr) {
    504     itr->second->Shutdown();
    505   }
    506 }
    507 
    508 void SourceState::SetMemoryLimits(DemuxerStream::Type type, int memory_limit) {
    509   switch (type) {
    510     case DemuxerStream::AUDIO:
    511       if (audio_)
    512         audio_->set_memory_limit(memory_limit);
    513       break;
    514     case DemuxerStream::VIDEO:
    515       if (video_)
    516         video_->set_memory_limit(memory_limit);
    517       break;
    518     case DemuxerStream::TEXT:
    519       for (TextStreamMap::iterator itr = text_stream_map_.begin();
    520            itr != text_stream_map_.end(); ++itr) {
    521         itr->second->set_memory_limit(memory_limit);
    522       }
    523       break;
    524     case DemuxerStream::UNKNOWN:
    525     case DemuxerStream::NUM_TYPES:
    526       NOTREACHED();
    527       break;
    528   }
    529 }
    530 
    531 bool SourceState::IsSeekWaitingForData() const {
    532   if (audio_ && audio_->IsSeekWaitingForData())
    533     return true;
    534 
    535   if (video_ && video_->IsSeekWaitingForData())
    536     return true;
    537 
    538   // NOTE: We are intentionally not checking the text tracks
    539   // because text tracks are discontinuous and may not have data
    540   // for the seek position. This is ok and playback should not be
    541   // stalled because we don't have cues. If cues, with timestamps after
    542   // the seek time, eventually arrive they will be delivered properly
    543   // in response to ChunkDemuxerStream::Read() calls.
    544 
    545   return false;
    546 }
    547 
    548 bool SourceState::OnNewConfigs(
    549     bool allow_audio, bool allow_video,
    550     const AudioDecoderConfig& audio_config,
    551     const VideoDecoderConfig& video_config,
    552     const StreamParser::TextTrackConfigMap& text_configs) {
    553   DVLOG(1) << "OnNewConfigs(" << allow_audio << ", " << allow_video
    554            << ", " << audio_config.IsValidConfig()
    555            << ", " << video_config.IsValidConfig() << ")";
    556   DCHECK(!init_segment_received_cb_.is_null());
    557 
    558   if (!audio_config.IsValidConfig() && !video_config.IsValidConfig()) {
    559     DVLOG(1) << "OnNewConfigs() : Audio & video config are not valid!";
    560     return false;
    561   }
    562 
    563   // Signal an error if we get configuration info for stream types that weren't
    564   // specified in AddId() or more configs after a stream is initialized.
    565   if (allow_audio != audio_config.IsValidConfig()) {
    566     MEDIA_LOG(log_cb_)
    567         << "Initialization segment"
    568         << (audio_config.IsValidConfig() ? " has" : " does not have")
    569         << " an audio track, but the mimetype"
    570         << (allow_audio ? " specifies" : " does not specify")
    571         << " an audio codec.";
    572     return false;
    573   }
    574 
    575   if (allow_video != video_config.IsValidConfig()) {
    576     MEDIA_LOG(log_cb_)
    577         << "Initialization segment"
    578         << (video_config.IsValidConfig() ? " has" : " does not have")
    579         << " a video track, but the mimetype"
    580         << (allow_video ? " specifies" : " does not specify")
    581         << " a video codec.";
    582     return false;
    583   }
    584 
    585   bool success = true;
    586   if (audio_config.IsValidConfig()) {
    587     if (!audio_) {
    588       audio_ = create_demuxer_stream_cb_.Run(DemuxerStream::AUDIO);
    589 
    590       if (!audio_) {
    591         DVLOG(1) << "Failed to create an audio stream.";
    592         return false;
    593       }
    594 
    595       if (!frame_processor_->AddTrack(FrameProcessor::kAudioTrackId, audio_)) {
    596         DVLOG(1) << "Failed to add audio track to frame processor.";
    597         return false;
    598       }
    599     }
    600 
    601     frame_processor_->OnPossibleAudioConfigUpdate(audio_config);
    602     success &= audio_->UpdateAudioConfig(audio_config, log_cb_);
    603   }
    604 
    605   if (video_config.IsValidConfig()) {
    606     if (!video_) {
    607       video_ = create_demuxer_stream_cb_.Run(DemuxerStream::VIDEO);
    608 
    609       if (!video_) {
    610         DVLOG(1) << "Failed to create a video stream.";
    611         return false;
    612       }
    613 
    614       if (!frame_processor_->AddTrack(FrameProcessor::kVideoTrackId, video_)) {
    615         DVLOG(1) << "Failed to add video track to frame processor.";
    616         return false;
    617       }
    618     }
    619 
    620     success &= video_->UpdateVideoConfig(video_config, log_cb_);
    621   }
    622 
    623   typedef StreamParser::TextTrackConfigMap::const_iterator TextConfigItr;
    624   if (text_stream_map_.empty()) {
    625     for (TextConfigItr itr = text_configs.begin();
    626          itr != text_configs.end(); ++itr) {
    627       ChunkDemuxerStream* const text_stream =
    628           create_demuxer_stream_cb_.Run(DemuxerStream::TEXT);
    629       if (!frame_processor_->AddTrack(itr->first, text_stream)) {
    630         success &= false;
    631         MEDIA_LOG(log_cb_) << "Failed to add text track ID " << itr->first
    632                            << " to frame processor.";
    633         break;
    634       }
    635       text_stream->UpdateTextConfig(itr->second, log_cb_);
    636       text_stream_map_[itr->first] = text_stream;
    637       new_text_track_cb_.Run(text_stream, itr->second);
    638     }
    639   } else {
    640     const size_t text_count = text_stream_map_.size();
    641     if (text_configs.size() != text_count) {
    642       success &= false;
    643       MEDIA_LOG(log_cb_) << "The number of text track configs changed.";
    644     } else if (text_count == 1) {
    645       TextConfigItr config_itr = text_configs.begin();
    646       TextStreamMap::iterator stream_itr = text_stream_map_.begin();
    647       ChunkDemuxerStream* text_stream = stream_itr->second;
    648       TextTrackConfig old_config = text_stream->text_track_config();
    649       TextTrackConfig new_config(config_itr->second.kind(),
    650                                  config_itr->second.label(),
    651                                  config_itr->second.language(),
    652                                  old_config.id());
    653       if (!new_config.Matches(old_config)) {
    654         success &= false;
    655         MEDIA_LOG(log_cb_) << "New text track config does not match old one.";
    656       } else {
    657         StreamParser::TrackId old_id = stream_itr->first;
    658         StreamParser::TrackId new_id = config_itr->first;
    659         if (new_id != old_id) {
    660           if (frame_processor_->UpdateTrack(old_id, new_id)) {
    661             text_stream_map_.clear();
    662             text_stream_map_[config_itr->first] = text_stream;
    663           } else {
    664             success &= false;
    665             MEDIA_LOG(log_cb_) << "Error remapping single text track number";
    666           }
    667         }
    668       }
    669     } else {
    670       for (TextConfigItr config_itr = text_configs.begin();
    671            config_itr != text_configs.end(); ++config_itr) {
    672         TextStreamMap::iterator stream_itr =
    673             text_stream_map_.find(config_itr->first);
    674         if (stream_itr == text_stream_map_.end()) {
    675           success &= false;
    676           MEDIA_LOG(log_cb_) << "Unexpected text track configuration "
    677                                 "for track ID "
    678                              << config_itr->first;
    679           break;
    680         }
    681 
    682         const TextTrackConfig& new_config = config_itr->second;
    683         ChunkDemuxerStream* stream = stream_itr->second;
    684         TextTrackConfig old_config = stream->text_track_config();
    685         if (!new_config.Matches(old_config)) {
    686           success &= false;
    687           MEDIA_LOG(log_cb_) << "New text track config for track ID "
    688                              << config_itr->first
    689                              << " does not match old one.";
    690           break;
    691         }
    692       }
    693     }
    694   }
    695 
    696   frame_processor_->SetAllTrackBuffersNeedRandomAccessPoint();
    697 
    698   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
    699   if (success)
    700     init_segment_received_cb_.Run();
    701 
    702   return success;
    703 }
    704 
    705 void SourceState::OnNewMediaSegment() {
    706   DVLOG(2) << "OnNewMediaSegment()";
    707   parsing_media_segment_ = true;
    708   new_media_segment_ = true;
    709 }
    710 
    711 void SourceState::OnEndOfMediaSegment() {
    712   DVLOG(2) << "OnEndOfMediaSegment()";
    713   parsing_media_segment_ = false;
    714   new_media_segment_ = false;
    715 }
    716 
    717 bool SourceState::OnNewBuffers(
    718     const StreamParser::BufferQueue& audio_buffers,
    719     const StreamParser::BufferQueue& video_buffers,
    720     const StreamParser::TextBufferQueueMap& text_map) {
    721   DVLOG(2) << "OnNewBuffers()";
    722   DCHECK(timestamp_offset_during_append_);
    723   DCHECK(parsing_media_segment_);
    724 
    725   const TimeDelta timestamp_offset_before_processing =
    726       *timestamp_offset_during_append_;
    727 
    728   // Calculate the new timestamp offset for audio/video tracks if the stream
    729   // parser has requested automatic updates.
    730   TimeDelta new_timestamp_offset = timestamp_offset_before_processing;
    731   if (auto_update_timestamp_offset_) {
    732     const bool have_audio_buffers = !audio_buffers.empty();
    733     const bool have_video_buffers = !video_buffers.empty();
    734     if (have_audio_buffers && have_video_buffers) {
    735       new_timestamp_offset +=
    736           std::min(EndTimestamp(audio_buffers), EndTimestamp(video_buffers));
    737     } else if (have_audio_buffers) {
    738       new_timestamp_offset += EndTimestamp(audio_buffers);
    739     } else if (have_video_buffers) {
    740       new_timestamp_offset += EndTimestamp(video_buffers);
    741     }
    742   }
    743 
    744   if (!frame_processor_->ProcessFrames(audio_buffers,
    745                                        video_buffers,
    746                                        text_map,
    747                                        append_window_start_during_append_,
    748                                        append_window_end_during_append_,
    749                                        &new_media_segment_,
    750                                        timestamp_offset_during_append_)) {
    751     return false;
    752   }
    753 
    754   // Only update the timestamp offset if the frame processor hasn't already.
    755   if (auto_update_timestamp_offset_ &&
    756       timestamp_offset_before_processing == *timestamp_offset_during_append_) {
    757     *timestamp_offset_during_append_ = new_timestamp_offset;
    758   }
    759 
    760   return true;
    761 }
    762 
    763 void SourceState::OnSourceInitDone(bool success,
    764                                    const StreamParser::InitParameters& params) {
    765   auto_update_timestamp_offset_ = params.auto_update_timestamp_offset;
    766   base::ResetAndReturn(&init_cb_).Run(success, params);
    767 }
    768 
    769 ChunkDemuxerStream::ChunkDemuxerStream(Type type, bool splice_frames_enabled)
    770     : type_(type),
    771       state_(UNINITIALIZED),
    772       splice_frames_enabled_(splice_frames_enabled),
    773       partial_append_window_trimming_enabled_(false) {
    774 }
    775 
    776 void ChunkDemuxerStream::StartReturningData() {
    777   DVLOG(1) << "ChunkDemuxerStream::StartReturningData()";
    778   base::AutoLock auto_lock(lock_);
    779   DCHECK(read_cb_.is_null());
    780   ChangeState_Locked(RETURNING_DATA_FOR_READS);
    781 }
    782 
    783 void ChunkDemuxerStream::AbortReads() {
    784   DVLOG(1) << "ChunkDemuxerStream::AbortReads()";
    785   base::AutoLock auto_lock(lock_);
    786   ChangeState_Locked(RETURNING_ABORT_FOR_READS);
    787   if (!read_cb_.is_null())
    788     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
    789 }
    790 
    791 void ChunkDemuxerStream::CompletePendingReadIfPossible() {
    792   base::AutoLock auto_lock(lock_);
    793   if (read_cb_.is_null())
    794     return;
    795 
    796   CompletePendingReadIfPossible_Locked();
    797 }
    798 
    799 void ChunkDemuxerStream::Shutdown() {
    800   DVLOG(1) << "ChunkDemuxerStream::Shutdown()";
    801   base::AutoLock auto_lock(lock_);
    802   ChangeState_Locked(SHUTDOWN);
    803 
    804   // Pass an end of stream buffer to the pending callback to signal that no more
    805   // data will be sent.
    806   if (!read_cb_.is_null()) {
    807     base::ResetAndReturn(&read_cb_).Run(DemuxerStream::kOk,
    808                                         StreamParserBuffer::CreateEOSBuffer());
    809   }
    810 }
    811 
    812 bool ChunkDemuxerStream::IsSeekWaitingForData() const {
    813   base::AutoLock auto_lock(lock_);
    814 
    815   // This method should not be called for text tracks. See the note in
    816   // SourceState::IsSeekWaitingForData().
    817   DCHECK_NE(type_, DemuxerStream::TEXT);
    818 
    819   return stream_->IsSeekPending();
    820 }
    821 
    822 void ChunkDemuxerStream::Seek(TimeDelta time) {
    823   DVLOG(1) << "ChunkDemuxerStream::Seek(" << time.InSecondsF() << ")";
    824   base::AutoLock auto_lock(lock_);
    825   DCHECK(read_cb_.is_null());
    826   DCHECK(state_ == UNINITIALIZED || state_ == RETURNING_ABORT_FOR_READS)
    827       << state_;
    828 
    829   stream_->Seek(time);
    830 }
    831 
    832 bool ChunkDemuxerStream::Append(const StreamParser::BufferQueue& buffers) {
    833   if (buffers.empty())
    834     return false;
    835 
    836   base::AutoLock auto_lock(lock_);
    837   DCHECK_NE(state_, SHUTDOWN);
    838   if (!stream_->Append(buffers)) {
    839     DVLOG(1) << "ChunkDemuxerStream::Append() : stream append failed";
    840     return false;
    841   }
    842 
    843   if (!read_cb_.is_null())
    844     CompletePendingReadIfPossible_Locked();
    845 
    846   return true;
    847 }
    848 
    849 void ChunkDemuxerStream::Remove(TimeDelta start, TimeDelta end,
    850                                 TimeDelta duration) {
    851   base::AutoLock auto_lock(lock_);
    852   stream_->Remove(start, end, duration);
    853 }
    854 
    855 void ChunkDemuxerStream::OnSetDuration(TimeDelta duration) {
    856   base::AutoLock auto_lock(lock_);
    857   stream_->OnSetDuration(duration);
    858 }
    859 
    860 Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedRanges(
    861     TimeDelta duration) const {
    862   base::AutoLock auto_lock(lock_);
    863 
    864   if (type_ == TEXT) {
    865     // Since text tracks are discontinuous and the lack of cues should not block
    866     // playback, report the buffered range for text tracks as [0, |duration|) so
    867     // that intesections with audio & video tracks are computed correctly when
    868     // no cues are present.
    869     Ranges<TimeDelta> text_range;
    870     text_range.Add(TimeDelta(), duration);
    871     return text_range;
    872   }
    873 
    874   Ranges<TimeDelta> range = stream_->GetBufferedTime();
    875 
    876   if (range.size() == 0u)
    877     return range;
    878 
    879   // Clamp the end of the stream's buffered ranges to fit within the duration.
    880   // This can be done by intersecting the stream's range with the valid time
    881   // range.
    882   Ranges<TimeDelta> valid_time_range;
    883   valid_time_range.Add(range.start(0), duration);
    884   return range.IntersectionWith(valid_time_range);
    885 }
    886 
    887 TimeDelta ChunkDemuxerStream::GetBufferedDuration() const {
    888   return stream_->GetBufferedDuration();
    889 }
    890 
    891 void ChunkDemuxerStream::OnNewMediaSegment(DecodeTimestamp start_timestamp) {
    892   DVLOG(2) << "ChunkDemuxerStream::OnNewMediaSegment("
    893            << start_timestamp.InSecondsF() << ")";
    894   base::AutoLock auto_lock(lock_);
    895   stream_->OnNewMediaSegment(start_timestamp);
    896 }
    897 
    898 bool ChunkDemuxerStream::UpdateAudioConfig(const AudioDecoderConfig& config,
    899                                            const LogCB& log_cb) {
    900   DCHECK(config.IsValidConfig());
    901   DCHECK_EQ(type_, AUDIO);
    902   base::AutoLock auto_lock(lock_);
    903   if (!stream_) {
    904     DCHECK_EQ(state_, UNINITIALIZED);
    905 
    906     // On platforms which support splice frames, enable splice frames and
    907     // partial append window support for most codecs (notably: not opus).
    908     const bool codec_supported = config.codec() == kCodecMP3 ||
    909                                  config.codec() == kCodecAAC ||
    910                                  config.codec() == kCodecVorbis;
    911     splice_frames_enabled_ = splice_frames_enabled_ && codec_supported;
    912     partial_append_window_trimming_enabled_ =
    913         splice_frames_enabled_ && codec_supported;
    914 
    915     stream_.reset(
    916         new SourceBufferStream(config, log_cb, splice_frames_enabled_));
    917     return true;
    918   }
    919 
    920   return stream_->UpdateAudioConfig(config);
    921 }
    922 
    923 bool ChunkDemuxerStream::UpdateVideoConfig(const VideoDecoderConfig& config,
    924                                            const LogCB& log_cb) {
    925   DCHECK(config.IsValidConfig());
    926   DCHECK_EQ(type_, VIDEO);
    927   base::AutoLock auto_lock(lock_);
    928 
    929   if (!stream_) {
    930     DCHECK_EQ(state_, UNINITIALIZED);
    931     stream_.reset(
    932         new SourceBufferStream(config, log_cb, splice_frames_enabled_));
    933     return true;
    934   }
    935 
    936   return stream_->UpdateVideoConfig(config);
    937 }
    938 
    939 void ChunkDemuxerStream::UpdateTextConfig(const TextTrackConfig& config,
    940                                           const LogCB& log_cb) {
    941   DCHECK_EQ(type_, TEXT);
    942   base::AutoLock auto_lock(lock_);
    943   DCHECK(!stream_);
    944   DCHECK_EQ(state_, UNINITIALIZED);
    945   stream_.reset(new SourceBufferStream(config, log_cb, splice_frames_enabled_));
    946 }
    947 
    948 void ChunkDemuxerStream::MarkEndOfStream() {
    949   base::AutoLock auto_lock(lock_);
    950   stream_->MarkEndOfStream();
    951 }
    952 
    953 void ChunkDemuxerStream::UnmarkEndOfStream() {
    954   base::AutoLock auto_lock(lock_);
    955   stream_->UnmarkEndOfStream();
    956 }
    957 
    958 // DemuxerStream methods.
    959 void ChunkDemuxerStream::Read(const ReadCB& read_cb) {
    960   base::AutoLock auto_lock(lock_);
    961   DCHECK_NE(state_, UNINITIALIZED);
    962   DCHECK(read_cb_.is_null());
    963 
    964   read_cb_ = BindToCurrentLoop(read_cb);
    965   CompletePendingReadIfPossible_Locked();
    966 }
    967 
    968 DemuxerStream::Type ChunkDemuxerStream::type() { return type_; }
    969 
    970 AudioDecoderConfig ChunkDemuxerStream::audio_decoder_config() {
    971   CHECK_EQ(type_, AUDIO);
    972   base::AutoLock auto_lock(lock_);
    973   return stream_->GetCurrentAudioDecoderConfig();
    974 }
    975 
    976 VideoDecoderConfig ChunkDemuxerStream::video_decoder_config() {
    977   CHECK_EQ(type_, VIDEO);
    978   base::AutoLock auto_lock(lock_);
    979   return stream_->GetCurrentVideoDecoderConfig();
    980 }
    981 
    982 bool ChunkDemuxerStream::SupportsConfigChanges() { return true; }
    983 
    984 TextTrackConfig ChunkDemuxerStream::text_track_config() {
    985   CHECK_EQ(type_, TEXT);
    986   base::AutoLock auto_lock(lock_);
    987   return stream_->GetCurrentTextTrackConfig();
    988 }
    989 
    990 VideoRotation ChunkDemuxerStream::video_rotation() {
    991   return VIDEO_ROTATION_0;
    992 }
    993 
    994 void ChunkDemuxerStream::ChangeState_Locked(State state) {
    995   lock_.AssertAcquired();
    996   DVLOG(1) << "ChunkDemuxerStream::ChangeState_Locked() : "
    997            << "type " << type_
    998            << " - " << state_ << " -> " << state;
    999   state_ = state;
   1000 }
   1001 
   1002 ChunkDemuxerStream::~ChunkDemuxerStream() {}
   1003 
   1004 void ChunkDemuxerStream::CompletePendingReadIfPossible_Locked() {
   1005   lock_.AssertAcquired();
   1006   DCHECK(!read_cb_.is_null());
   1007 
   1008   DemuxerStream::Status status;
   1009   scoped_refptr<StreamParserBuffer> buffer;
   1010 
   1011   switch (state_) {
   1012     case UNINITIALIZED:
   1013       NOTREACHED();
   1014       return;
   1015     case RETURNING_DATA_FOR_READS:
   1016       switch (stream_->GetNextBuffer(&buffer)) {
   1017         case SourceBufferStream::kSuccess:
   1018           status = DemuxerStream::kOk;
   1019           break;
   1020         case SourceBufferStream::kNeedBuffer:
   1021           // Return early without calling |read_cb_| since we don't have
   1022           // any data to return yet.
   1023           return;
   1024         case SourceBufferStream::kEndOfStream:
   1025           status = DemuxerStream::kOk;
   1026           buffer = StreamParserBuffer::CreateEOSBuffer();
   1027           break;
   1028         case SourceBufferStream::kConfigChange:
   1029           DVLOG(2) << "Config change reported to ChunkDemuxerStream.";
   1030           status = kConfigChanged;
   1031           buffer = NULL;
   1032           break;
   1033       }
   1034       break;
   1035     case RETURNING_ABORT_FOR_READS:
   1036       // Null buffers should be returned in this state since we are waiting
   1037       // for a seek. Any buffers in the SourceBuffer should NOT be returned
   1038       // because they are associated with the seek.
   1039       status = DemuxerStream::kAborted;
   1040       buffer = NULL;
   1041       break;
   1042     case SHUTDOWN:
   1043       status = DemuxerStream::kOk;
   1044       buffer = StreamParserBuffer::CreateEOSBuffer();
   1045       break;
   1046   }
   1047 
   1048   base::ResetAndReturn(&read_cb_).Run(status, buffer);
   1049 }
   1050 
   1051 ChunkDemuxer::ChunkDemuxer(const base::Closure& open_cb,
   1052                            const NeedKeyCB& need_key_cb,
   1053                            const LogCB& log_cb,
   1054                            bool splice_frames_enabled)
   1055     : state_(WAITING_FOR_INIT),
   1056       cancel_next_seek_(false),
   1057       host_(NULL),
   1058       open_cb_(open_cb),
   1059       need_key_cb_(need_key_cb),
   1060       enable_text_(false),
   1061       log_cb_(log_cb),
   1062       duration_(kNoTimestamp()),
   1063       user_specified_duration_(-1),
   1064       liveness_(LIVENESS_UNKNOWN),
   1065       splice_frames_enabled_(splice_frames_enabled) {
   1066   DCHECK(!open_cb_.is_null());
   1067   DCHECK(!need_key_cb_.is_null());
   1068 }
   1069 
   1070 void ChunkDemuxer::Initialize(
   1071     DemuxerHost* host,
   1072     const PipelineStatusCB& cb,
   1073     bool enable_text_tracks) {
   1074   DVLOG(1) << "Init()";
   1075 
   1076   base::AutoLock auto_lock(lock_);
   1077 
   1078   init_cb_ = BindToCurrentLoop(cb);
   1079   if (state_ == SHUTDOWN) {
   1080     base::ResetAndReturn(&init_cb_).Run(DEMUXER_ERROR_COULD_NOT_OPEN);
   1081     return;
   1082   }
   1083   DCHECK_EQ(state_, WAITING_FOR_INIT);
   1084   host_ = host;
   1085   enable_text_ = enable_text_tracks;
   1086 
   1087   ChangeState_Locked(INITIALIZING);
   1088 
   1089   base::ResetAndReturn(&open_cb_).Run();
   1090 }
   1091 
   1092 void ChunkDemuxer::Stop() {
   1093   DVLOG(1) << "Stop()";
   1094   Shutdown();
   1095 }
   1096 
   1097 void ChunkDemuxer::Seek(TimeDelta time, const PipelineStatusCB& cb) {
   1098   DVLOG(1) << "Seek(" << time.InSecondsF() << ")";
   1099   DCHECK(time >= TimeDelta());
   1100 
   1101   base::AutoLock auto_lock(lock_);
   1102   DCHECK(seek_cb_.is_null());
   1103 
   1104   seek_cb_ = BindToCurrentLoop(cb);
   1105   if (state_ != INITIALIZED && state_ != ENDED) {
   1106     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_ERROR_INVALID_STATE);
   1107     return;
   1108   }
   1109 
   1110   if (cancel_next_seek_) {
   1111     cancel_next_seek_ = false;
   1112     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
   1113     return;
   1114   }
   1115 
   1116   SeekAllSources(time);
   1117   StartReturningData();
   1118 
   1119   if (IsSeekWaitingForData_Locked()) {
   1120     DVLOG(1) << "Seek() : waiting for more data to arrive.";
   1121     return;
   1122   }
   1123 
   1124   base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
   1125 }
   1126 
   1127 // Demuxer implementation.
   1128 base::Time ChunkDemuxer::GetTimelineOffset() const {
   1129   return timeline_offset_;
   1130 }
   1131 
   1132 DemuxerStream* ChunkDemuxer::GetStream(DemuxerStream::Type type) {
   1133   DCHECK_NE(type, DemuxerStream::TEXT);
   1134   base::AutoLock auto_lock(lock_);
   1135   if (type == DemuxerStream::VIDEO)
   1136     return video_.get();
   1137 
   1138   if (type == DemuxerStream::AUDIO)
   1139     return audio_.get();
   1140 
   1141   return NULL;
   1142 }
   1143 
   1144 TimeDelta ChunkDemuxer::GetStartTime() const {
   1145   return TimeDelta();
   1146 }
   1147 
   1148 Demuxer::Liveness ChunkDemuxer::GetLiveness() const {
   1149   return liveness_;
   1150 }
   1151 
   1152 void ChunkDemuxer::StartWaitingForSeek(TimeDelta seek_time) {
   1153   DVLOG(1) << "StartWaitingForSeek()";
   1154   base::AutoLock auto_lock(lock_);
   1155   DCHECK(state_ == INITIALIZED || state_ == ENDED || state_ == SHUTDOWN ||
   1156          state_ == PARSE_ERROR) << state_;
   1157   DCHECK(seek_cb_.is_null());
   1158 
   1159   if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
   1160     return;
   1161 
   1162   AbortPendingReads();
   1163   SeekAllSources(seek_time);
   1164 
   1165   // Cancel state set in CancelPendingSeek() since we want to
   1166   // accept the next Seek().
   1167   cancel_next_seek_ = false;
   1168 }
   1169 
   1170 void ChunkDemuxer::CancelPendingSeek(TimeDelta seek_time) {
   1171   base::AutoLock auto_lock(lock_);
   1172   DCHECK_NE(state_, INITIALIZING);
   1173   DCHECK(seek_cb_.is_null() || IsSeekWaitingForData_Locked());
   1174 
   1175   if (cancel_next_seek_)
   1176     return;
   1177 
   1178   AbortPendingReads();
   1179   SeekAllSources(seek_time);
   1180 
   1181   if (seek_cb_.is_null()) {
   1182     cancel_next_seek_ = true;
   1183     return;
   1184   }
   1185 
   1186   base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
   1187 }
   1188 
   1189 ChunkDemuxer::Status ChunkDemuxer::AddId(const std::string& id,
   1190                                          const std::string& type,
   1191                                          std::vector<std::string>& codecs) {
   1192   base::AutoLock auto_lock(lock_);
   1193 
   1194   if ((state_ != WAITING_FOR_INIT && state_ != INITIALIZING) || IsValidId(id))
   1195     return kReachedIdLimit;
   1196 
   1197   bool has_audio = false;
   1198   bool has_video = false;
   1199   scoped_ptr<media::StreamParser> stream_parser(
   1200       StreamParserFactory::Create(type, codecs, log_cb_,
   1201                                   &has_audio, &has_video));
   1202 
   1203   if (!stream_parser)
   1204     return ChunkDemuxer::kNotSupported;
   1205 
   1206   if ((has_audio && !source_id_audio_.empty()) ||
   1207       (has_video && !source_id_video_.empty()))
   1208     return kReachedIdLimit;
   1209 
   1210   if (has_audio)
   1211     source_id_audio_ = id;
   1212 
   1213   if (has_video)
   1214     source_id_video_ = id;
   1215 
   1216   scoped_ptr<FrameProcessor> frame_processor(
   1217       new FrameProcessor(base::Bind(&ChunkDemuxer::IncreaseDurationIfNecessary,
   1218                          base::Unretained(this))));
   1219 
   1220   scoped_ptr<SourceState> source_state(
   1221       new SourceState(stream_parser.Pass(),
   1222                       frame_processor.Pass(), log_cb_,
   1223                       base::Bind(&ChunkDemuxer::CreateDemuxerStream,
   1224                                  base::Unretained(this))));
   1225 
   1226   SourceState::NewTextTrackCB new_text_track_cb;
   1227 
   1228   if (enable_text_) {
   1229     new_text_track_cb = base::Bind(&ChunkDemuxer::OnNewTextTrack,
   1230                                    base::Unretained(this));
   1231   }
   1232 
   1233   source_state->Init(
   1234       base::Bind(&ChunkDemuxer::OnSourceInitDone, base::Unretained(this)),
   1235       has_audio,
   1236       has_video,
   1237       need_key_cb_,
   1238       new_text_track_cb);
   1239 
   1240   source_state_map_[id] = source_state.release();
   1241   return kOk;
   1242 }
   1243 
   1244 void ChunkDemuxer::RemoveId(const std::string& id) {
   1245   base::AutoLock auto_lock(lock_);
   1246   CHECK(IsValidId(id));
   1247 
   1248   delete source_state_map_[id];
   1249   source_state_map_.erase(id);
   1250 
   1251   if (source_id_audio_ == id)
   1252     source_id_audio_.clear();
   1253 
   1254   if (source_id_video_ == id)
   1255     source_id_video_.clear();
   1256 }
   1257 
   1258 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const {
   1259   base::AutoLock auto_lock(lock_);
   1260   DCHECK(!id.empty());
   1261 
   1262   SourceStateMap::const_iterator itr = source_state_map_.find(id);
   1263 
   1264   DCHECK(itr != source_state_map_.end());
   1265   return itr->second->GetBufferedRanges(duration_, state_ == ENDED);
   1266 }
   1267 
   1268 void ChunkDemuxer::AppendData(
   1269     const std::string& id,
   1270     const uint8* data,
   1271     size_t length,
   1272     TimeDelta append_window_start,
   1273     TimeDelta append_window_end,
   1274     TimeDelta* timestamp_offset,
   1275     const InitSegmentReceivedCB& init_segment_received_cb) {
   1276   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
   1277 
   1278   DCHECK(!id.empty());
   1279   DCHECK(timestamp_offset);
   1280   DCHECK(!init_segment_received_cb.is_null());
   1281 
   1282   Ranges<TimeDelta> ranges;
   1283 
   1284   {
   1285     base::AutoLock auto_lock(lock_);
   1286     DCHECK_NE(state_, ENDED);
   1287 
   1288     // Capture if any of the SourceBuffers are waiting for data before we start
   1289     // parsing.
   1290     bool old_waiting_for_data = IsSeekWaitingForData_Locked();
   1291 
   1292     if (length == 0u)
   1293       return;
   1294 
   1295     DCHECK(data);
   1296 
   1297     switch (state_) {
   1298       case INITIALIZING:
   1299         DCHECK(IsValidId(id));
   1300         if (!source_state_map_[id]->Append(data, length,
   1301                                            append_window_start,
   1302                                            append_window_end,
   1303                                            timestamp_offset,
   1304                                            init_segment_received_cb)) {
   1305           ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
   1306           return;
   1307         }
   1308         break;
   1309 
   1310       case INITIALIZED: {
   1311         DCHECK(IsValidId(id));
   1312         if (!source_state_map_[id]->Append(data, length,
   1313                                            append_window_start,
   1314                                            append_window_end,
   1315                                            timestamp_offset,
   1316                                            init_segment_received_cb)) {
   1317           ReportError_Locked(PIPELINE_ERROR_DECODE);
   1318           return;
   1319         }
   1320       } break;
   1321 
   1322       case PARSE_ERROR:
   1323         DVLOG(1) << "AppendData(): Ignoring data after a parse error.";
   1324         return;
   1325 
   1326       case WAITING_FOR_INIT:
   1327       case ENDED:
   1328       case SHUTDOWN:
   1329         DVLOG(1) << "AppendData(): called in unexpected state " << state_;
   1330         return;
   1331     }
   1332 
   1333     // Check to see if data was appended at the pending seek point. This
   1334     // indicates we have parsed enough data to complete the seek.
   1335     if (old_waiting_for_data && !IsSeekWaitingForData_Locked() &&
   1336         !seek_cb_.is_null()) {
   1337       base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
   1338     }
   1339 
   1340     ranges = GetBufferedRanges_Locked();
   1341   }
   1342 
   1343   for (size_t i = 0; i < ranges.size(); ++i)
   1344     host_->AddBufferedTimeRange(ranges.start(i), ranges.end(i));
   1345 }
   1346 
   1347 void ChunkDemuxer::Abort(const std::string& id,
   1348                          TimeDelta append_window_start,
   1349                          TimeDelta append_window_end,
   1350                          TimeDelta* timestamp_offset) {
   1351   DVLOG(1) << "Abort(" << id << ")";
   1352   base::AutoLock auto_lock(lock_);
   1353   DCHECK(!id.empty());
   1354   CHECK(IsValidId(id));
   1355   bool old_waiting_for_data = IsSeekWaitingForData_Locked();
   1356   source_state_map_[id]->Abort(append_window_start,
   1357                                append_window_end,
   1358                                timestamp_offset);
   1359   // Abort can possibly emit some buffers.
   1360   // Need to check whether seeking can be completed.
   1361   if (old_waiting_for_data && !IsSeekWaitingForData_Locked() &&
   1362       !seek_cb_.is_null()) {
   1363     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
   1364   }
   1365 }
   1366 
   1367 void ChunkDemuxer::Remove(const std::string& id, TimeDelta start,
   1368                           TimeDelta end) {
   1369   DVLOG(1) << "Remove(" << id << ", " << start.InSecondsF()
   1370            << ", " << end.InSecondsF() << ")";
   1371   base::AutoLock auto_lock(lock_);
   1372 
   1373   DCHECK(!id.empty());
   1374   CHECK(IsValidId(id));
   1375   DCHECK(start >= base::TimeDelta()) << start.InSecondsF();
   1376   DCHECK(start < end) << "start " << start.InSecondsF()
   1377                       << " end " << end.InSecondsF();
   1378   DCHECK(duration_ != kNoTimestamp());
   1379   DCHECK(start <= duration_) << "start " << start.InSecondsF()
   1380                              << " duration " << duration_.InSecondsF();
   1381 
   1382   if (start == duration_)
   1383     return;
   1384 
   1385   source_state_map_[id]->Remove(start, end, duration_);
   1386 }
   1387 
   1388 double ChunkDemuxer::GetDuration() {
   1389   base::AutoLock auto_lock(lock_);
   1390   return GetDuration_Locked();
   1391 }
   1392 
   1393 double ChunkDemuxer::GetDuration_Locked() {
   1394   lock_.AssertAcquired();
   1395   if (duration_ == kNoTimestamp())
   1396     return std::numeric_limits<double>::quiet_NaN();
   1397 
   1398   // Return positive infinity if the resource is unbounded.
   1399   // http://www.whatwg.org/specs/web-apps/current-work/multipage/video.html#dom-media-duration
   1400   if (duration_ == kInfiniteDuration())
   1401     return std::numeric_limits<double>::infinity();
   1402 
   1403   if (user_specified_duration_ >= 0)
   1404     return user_specified_duration_;
   1405 
   1406   return duration_.InSecondsF();
   1407 }
   1408 
   1409 void ChunkDemuxer::SetDuration(double duration) {
   1410   base::AutoLock auto_lock(lock_);
   1411   DVLOG(1) << "SetDuration(" << duration << ")";
   1412   DCHECK_GE(duration, 0);
   1413 
   1414   if (duration == GetDuration_Locked())
   1415     return;
   1416 
   1417   // Compute & bounds check the TimeDelta representation of duration.
   1418   // This can be different if the value of |duration| doesn't fit the range or
   1419   // precision of TimeDelta.
   1420   TimeDelta min_duration = TimeDelta::FromInternalValue(1);
   1421   // Don't use TimeDelta::Max() here, as we want the largest finite time delta.
   1422   TimeDelta max_duration = TimeDelta::FromInternalValue(kint64max - 1);
   1423   double min_duration_in_seconds = min_duration.InSecondsF();
   1424   double max_duration_in_seconds = max_duration.InSecondsF();
   1425 
   1426   TimeDelta duration_td;
   1427   if (duration == std::numeric_limits<double>::infinity()) {
   1428     duration_td = media::kInfiniteDuration();
   1429   } else if (duration < min_duration_in_seconds) {
   1430     duration_td = min_duration;
   1431   } else if (duration > max_duration_in_seconds) {
   1432     duration_td = max_duration;
   1433   } else {
   1434     duration_td = TimeDelta::FromMicroseconds(
   1435         duration * base::Time::kMicrosecondsPerSecond);
   1436   }
   1437 
   1438   DCHECK(duration_td > TimeDelta());
   1439 
   1440   user_specified_duration_ = duration;
   1441   duration_ = duration_td;
   1442   host_->SetDuration(duration_);
   1443 
   1444   for (SourceStateMap::iterator itr = source_state_map_.begin();
   1445        itr != source_state_map_.end(); ++itr) {
   1446     itr->second->OnSetDuration(duration_);
   1447   }
   1448 }
   1449 
   1450 bool ChunkDemuxer::IsParsingMediaSegment(const std::string& id) {
   1451   base::AutoLock auto_lock(lock_);
   1452   DVLOG(1) << "IsParsingMediaSegment(" << id << ")";
   1453   CHECK(IsValidId(id));
   1454 
   1455   return source_state_map_[id]->parsing_media_segment();
   1456 }
   1457 
   1458 void ChunkDemuxer::SetSequenceMode(const std::string& id,
   1459                                    bool sequence_mode) {
   1460   base::AutoLock auto_lock(lock_);
   1461   DVLOG(1) << "SetSequenceMode(" << id << ", " << sequence_mode << ")";
   1462   CHECK(IsValidId(id));
   1463   DCHECK_NE(state_, ENDED);
   1464 
   1465   source_state_map_[id]->SetSequenceMode(sequence_mode);
   1466 }
   1467 
   1468 void ChunkDemuxer::SetGroupStartTimestampIfInSequenceMode(
   1469     const std::string& id,
   1470     base::TimeDelta timestamp_offset) {
   1471   base::AutoLock auto_lock(lock_);
   1472   DVLOG(1) << "SetGroupStartTimestampIfInSequenceMode(" << id << ", "
   1473            << timestamp_offset.InSecondsF() << ")";
   1474   CHECK(IsValidId(id));
   1475   DCHECK_NE(state_, ENDED);
   1476 
   1477   source_state_map_[id]->SetGroupStartTimestampIfInSequenceMode(
   1478       timestamp_offset);
   1479 }
   1480 
   1481 
   1482 void ChunkDemuxer::MarkEndOfStream(PipelineStatus status) {
   1483   DVLOG(1) << "MarkEndOfStream(" << status << ")";
   1484   base::AutoLock auto_lock(lock_);
   1485   DCHECK_NE(state_, WAITING_FOR_INIT);
   1486   DCHECK_NE(state_, ENDED);
   1487 
   1488   if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
   1489     return;
   1490 
   1491   if (state_ == INITIALIZING) {
   1492     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
   1493     return;
   1494   }
   1495 
   1496   bool old_waiting_for_data = IsSeekWaitingForData_Locked();
   1497   for (SourceStateMap::iterator itr = source_state_map_.begin();
   1498        itr != source_state_map_.end(); ++itr) {
   1499     itr->second->MarkEndOfStream();
   1500   }
   1501 
   1502   CompletePendingReadsIfPossible();
   1503 
   1504   // Give a chance to resume the pending seek process.
   1505   if (status != PIPELINE_OK) {
   1506     ReportError_Locked(status);
   1507     return;
   1508   }
   1509 
   1510   ChangeState_Locked(ENDED);
   1511   DecreaseDurationIfNecessary();
   1512 
   1513   if (old_waiting_for_data && !IsSeekWaitingForData_Locked() &&
   1514       !seek_cb_.is_null()) {
   1515     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
   1516   }
   1517 }
   1518 
   1519 void ChunkDemuxer::UnmarkEndOfStream() {
   1520   DVLOG(1) << "UnmarkEndOfStream()";
   1521   base::AutoLock auto_lock(lock_);
   1522   DCHECK_EQ(state_, ENDED);
   1523 
   1524   ChangeState_Locked(INITIALIZED);
   1525 
   1526   for (SourceStateMap::iterator itr = source_state_map_.begin();
   1527        itr != source_state_map_.end(); ++itr) {
   1528     itr->second->UnmarkEndOfStream();
   1529   }
   1530 }
   1531 
   1532 void ChunkDemuxer::Shutdown() {
   1533   DVLOG(1) << "Shutdown()";
   1534   base::AutoLock auto_lock(lock_);
   1535 
   1536   if (state_ == SHUTDOWN)
   1537     return;
   1538 
   1539   ShutdownAllStreams();
   1540 
   1541   ChangeState_Locked(SHUTDOWN);
   1542 
   1543   if(!seek_cb_.is_null())
   1544     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_ERROR_ABORT);
   1545 }
   1546 
   1547 void ChunkDemuxer::SetMemoryLimits(DemuxerStream::Type type, int memory_limit) {
   1548   for (SourceStateMap::iterator itr = source_state_map_.begin();
   1549        itr != source_state_map_.end(); ++itr) {
   1550     itr->second->SetMemoryLimits(type, memory_limit);
   1551   }
   1552 }
   1553 
   1554 void ChunkDemuxer::ChangeState_Locked(State new_state) {
   1555   lock_.AssertAcquired();
   1556   DVLOG(1) << "ChunkDemuxer::ChangeState_Locked() : "
   1557            << state_ << " -> " << new_state;
   1558   state_ = new_state;
   1559 }
   1560 
   1561 ChunkDemuxer::~ChunkDemuxer() {
   1562   DCHECK_NE(state_, INITIALIZED);
   1563 
   1564   STLDeleteValues(&source_state_map_);
   1565 }
   1566 
   1567 void ChunkDemuxer::ReportError_Locked(PipelineStatus error) {
   1568   DVLOG(1) << "ReportError_Locked(" << error << ")";
   1569   lock_.AssertAcquired();
   1570   DCHECK_NE(error, PIPELINE_OK);
   1571 
   1572   ChangeState_Locked(PARSE_ERROR);
   1573 
   1574   PipelineStatusCB cb;
   1575 
   1576   if (!init_cb_.is_null()) {
   1577     std::swap(cb, init_cb_);
   1578   } else {
   1579     if (!seek_cb_.is_null())
   1580       std::swap(cb, seek_cb_);
   1581 
   1582     ShutdownAllStreams();
   1583   }
   1584 
   1585   if (!cb.is_null()) {
   1586     cb.Run(error);
   1587     return;
   1588   }
   1589 
   1590   base::AutoUnlock auto_unlock(lock_);
   1591   host_->OnDemuxerError(error);
   1592 }
   1593 
   1594 bool ChunkDemuxer::IsSeekWaitingForData_Locked() const {
   1595   lock_.AssertAcquired();
   1596   for (SourceStateMap::const_iterator itr = source_state_map_.begin();
   1597        itr != source_state_map_.end(); ++itr) {
   1598     if (itr->second->IsSeekWaitingForData())
   1599       return true;
   1600   }
   1601 
   1602   return false;
   1603 }
   1604 
   1605 void ChunkDemuxer::OnSourceInitDone(
   1606     bool success,
   1607     const StreamParser::InitParameters& params) {
   1608   DVLOG(1) << "OnSourceInitDone(" << success << ", "
   1609            << params.duration.InSecondsF() << ")";
   1610   lock_.AssertAcquired();
   1611   DCHECK_EQ(state_, INITIALIZING);
   1612   if (!success || (!audio_ && !video_)) {
   1613     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
   1614     return;
   1615   }
   1616 
   1617   if (params.duration != TimeDelta() && duration_ == kNoTimestamp())
   1618     UpdateDuration(params.duration);
   1619 
   1620   if (!params.timeline_offset.is_null()) {
   1621     if (!timeline_offset_.is_null() &&
   1622         params.timeline_offset != timeline_offset_) {
   1623       MEDIA_LOG(log_cb_)
   1624           << "Timeline offset is not the same across all SourceBuffers.";
   1625       ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
   1626       return;
   1627     }
   1628 
   1629     timeline_offset_ = params.timeline_offset;
   1630   }
   1631 
   1632   if (params.liveness != LIVENESS_UNKNOWN) {
   1633     if (liveness_ != LIVENESS_UNKNOWN && params.liveness != liveness_) {
   1634       MEDIA_LOG(log_cb_)
   1635           << "Liveness is not the same across all SourceBuffers.";
   1636       ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
   1637       return;
   1638     }
   1639 
   1640     liveness_ = params.liveness;
   1641   }
   1642 
   1643   // Wait until all streams have initialized.
   1644   if ((!source_id_audio_.empty() && !audio_) ||
   1645       (!source_id_video_.empty() && !video_)) {
   1646     return;
   1647   }
   1648 
   1649   SeekAllSources(GetStartTime());
   1650   StartReturningData();
   1651 
   1652   if (duration_ == kNoTimestamp())
   1653     duration_ = kInfiniteDuration();
   1654 
   1655   // The demuxer is now initialized after the |start_timestamp_| was set.
   1656   ChangeState_Locked(INITIALIZED);
   1657   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
   1658 }
   1659 
   1660 ChunkDemuxerStream*
   1661 ChunkDemuxer::CreateDemuxerStream(DemuxerStream::Type type) {
   1662   switch (type) {
   1663     case DemuxerStream::AUDIO:
   1664       if (audio_)
   1665         return NULL;
   1666       audio_.reset(
   1667           new ChunkDemuxerStream(DemuxerStream::AUDIO, splice_frames_enabled_));
   1668       return audio_.get();
   1669       break;
   1670     case DemuxerStream::VIDEO:
   1671       if (video_)
   1672         return NULL;
   1673       video_.reset(
   1674           new ChunkDemuxerStream(DemuxerStream::VIDEO, splice_frames_enabled_));
   1675       return video_.get();
   1676       break;
   1677     case DemuxerStream::TEXT: {
   1678       return new ChunkDemuxerStream(DemuxerStream::TEXT,
   1679                                     splice_frames_enabled_);
   1680       break;
   1681     }
   1682     case DemuxerStream::UNKNOWN:
   1683     case DemuxerStream::NUM_TYPES:
   1684       NOTREACHED();
   1685       return NULL;
   1686   }
   1687   NOTREACHED();
   1688   return NULL;
   1689 }
   1690 
   1691 void ChunkDemuxer::OnNewTextTrack(ChunkDemuxerStream* text_stream,
   1692                                   const TextTrackConfig& config) {
   1693   lock_.AssertAcquired();
   1694   DCHECK_NE(state_, SHUTDOWN);
   1695   host_->AddTextStream(text_stream, config);
   1696 }
   1697 
   1698 bool ChunkDemuxer::IsValidId(const std::string& source_id) const {
   1699   lock_.AssertAcquired();
   1700   return source_state_map_.count(source_id) > 0u;
   1701 }
   1702 
   1703 void ChunkDemuxer::UpdateDuration(TimeDelta new_duration) {
   1704   DCHECK(duration_ != new_duration);
   1705   user_specified_duration_ = -1;
   1706   duration_ = new_duration;
   1707   host_->SetDuration(new_duration);
   1708 }
   1709 
   1710 void ChunkDemuxer::IncreaseDurationIfNecessary(TimeDelta new_duration) {
   1711   DCHECK(new_duration != kNoTimestamp());
   1712   DCHECK(new_duration != kInfiniteDuration());
   1713 
   1714   // Per April 1, 2014 MSE spec editor's draft:
   1715   // https://dvcs.w3.org/hg/html-media/raw-file/d471a4412040/media-source/
   1716   //     media-source.html#sourcebuffer-coded-frame-processing
   1717   // 5. If the media segment contains data beyond the current duration, then run
   1718   //    the duration change algorithm with new duration set to the maximum of
   1719   //    the current duration and the group end timestamp.
   1720 
   1721   if (new_duration <= duration_)
   1722     return;
   1723 
   1724   DVLOG(2) << __FUNCTION__ << ": Increasing duration: "
   1725            << duration_.InSecondsF() << " -> " << new_duration.InSecondsF();
   1726 
   1727   UpdateDuration(new_duration);
   1728 }
   1729 
   1730 void ChunkDemuxer::DecreaseDurationIfNecessary() {
   1731   lock_.AssertAcquired();
   1732 
   1733   TimeDelta max_duration;
   1734 
   1735   for (SourceStateMap::const_iterator itr = source_state_map_.begin();
   1736        itr != source_state_map_.end(); ++itr) {
   1737     max_duration = std::max(max_duration,
   1738                             itr->second->GetMaxBufferedDuration());
   1739   }
   1740 
   1741   if (max_duration == TimeDelta())
   1742     return;
   1743 
   1744   if (max_duration < duration_)
   1745     UpdateDuration(max_duration);
   1746 }
   1747 
   1748 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   1749   base::AutoLock auto_lock(lock_);
   1750   return GetBufferedRanges_Locked();
   1751 }
   1752 
   1753 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges_Locked() const {
   1754   lock_.AssertAcquired();
   1755 
   1756   bool ended = state_ == ENDED;
   1757   // TODO(acolwell): When we start allowing SourceBuffers that are not active,
   1758   // we'll need to update this loop to only add ranges from active sources.
   1759   RangesList ranges_list;
   1760   for (SourceStateMap::const_iterator itr = source_state_map_.begin();
   1761        itr != source_state_map_.end(); ++itr) {
   1762     ranges_list.push_back(itr->second->GetBufferedRanges(duration_, ended));
   1763   }
   1764 
   1765   return ComputeIntersection(ranges_list, ended);
   1766 }
   1767 
   1768 void ChunkDemuxer::StartReturningData() {
   1769   for (SourceStateMap::iterator itr = source_state_map_.begin();
   1770        itr != source_state_map_.end(); ++itr) {
   1771     itr->second->StartReturningData();
   1772   }
   1773 }
   1774 
   1775 void ChunkDemuxer::AbortPendingReads() {
   1776   for (SourceStateMap::iterator itr = source_state_map_.begin();
   1777        itr != source_state_map_.end(); ++itr) {
   1778     itr->second->AbortReads();
   1779   }
   1780 }
   1781 
   1782 void ChunkDemuxer::SeekAllSources(TimeDelta seek_time) {
   1783   for (SourceStateMap::iterator itr = source_state_map_.begin();
   1784        itr != source_state_map_.end(); ++itr) {
   1785     itr->second->Seek(seek_time);
   1786   }
   1787 }
   1788 
   1789 void ChunkDemuxer::CompletePendingReadsIfPossible() {
   1790   for (SourceStateMap::iterator itr = source_state_map_.begin();
   1791        itr != source_state_map_.end(); ++itr) {
   1792     itr->second->CompletePendingReadIfPossible();
   1793   }
   1794 }
   1795 
   1796 void ChunkDemuxer::ShutdownAllStreams() {
   1797   for (SourceStateMap::iterator itr = source_state_map_.begin();
   1798        itr != source_state_map_.end(); ++itr) {
   1799     itr->second->Shutdown();
   1800   }
   1801 }
   1802 
   1803 }  // namespace media
   1804