Return buffers from StreamParsers in a single unified map

media/formats/mp4/mp4_stream_parser.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 "media/formats/mp4/mp4_stream_parser.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <memory>
@@ skipping 83 matching lines @@
 }
 
 bool MP4StreamParser::Parse(const uint8_t* buf, int size) {
   DCHECK_NE(state_, kWaitingForInit);
 
   if (state_ == kError)
     return false;
 
   queue_.Push(buf, size);
 
-  BufferQueue audio_buffers;
-  BufferQueue video_buffers;
+  BufferQueueMap buffers;
 
   bool result = false;
   bool err = false;
 
   do {
     switch (state_) {
       case kWaitingForInit:
       case kError:
         NOTREACHED();
         return false;
 
       case kParsingBoxes:
         result = ParseBox(&err);
         break;
 
       case kWaitingForSampleData:
         result = HaveEnoughDataToEnqueueSamples();
         if (result)
           ChangeState(kEmittingSamples);
         break;
 
       case kEmittingSamples:
-        result = EnqueueSample(&audio_buffers, &video_buffers, &err);
+        result = EnqueueSample(&buffers, &err);
         if (result) {
           int64_t max_clear = runs_->GetMaxClearOffset() + moof_head_;
           err = !ReadAndDiscardMDATsUntil(max_clear);
         }
         break;
     }
   } while (result && !err);
 
   if (!err)
-    err = !SendAndFlushSamples(&audio_buffers, &video_buffers);
+    err = !SendAndFlushSamples(&buffers);
 
   if (err) {
     DLOG(ERROR) << "Error while parsing MP4";
     moov_.reset();
     Reset();
     ChangeState(kError);
     return false;
   }
 
   return true;
@@ skipping 44 matching lines @@
 
   std::unique_ptr<MediaTracks> media_tracks(new MediaTracks());
   AudioDecoderConfig audio_config;
   VideoDecoderConfig video_config;
   int detected_audio_track_count = 0;
   int detected_video_track_count = 0;
   int detected_text_track_count = 0;
 
   for (std::vector<Track>::const_iterator track = moov_->tracks.begin();
        track != moov_->tracks.end(); ++track) {
-    // TODO(strobe): Only the first audio and video track present in a file are
-    // used. (Track selection is better accomplished via Source IDs, though, so
-    // adding support for track selection within a stream is low-priority.)
     const SampleDescription& samp_descr =
         track->media.information.sample_table.description;
 
     // TODO(strobe): When codec reconfigurations are supported, detect and send
     // a codec reconfiguration for fragments using a sample description index
     // different from the previous one
     size_t desc_idx = 0;
     for (size_t t = 0; t < moov_->extends.tracks.size(); t++) {
       const TrackExtends& trex = moov_->extends.tracks[t];
       if (trex.track_id == track->header.track_id) {
@@ skipping 263 matching lines @@
   // not required to use subsample encryption, so we may need to add an entry.
   if (subsamples->empty()) {
     subsamples->push_back(SubsampleEntry(
         kADTSHeaderMinSize, frame_buf->size() - kADTSHeaderMinSize));
   } else {
     (*subsamples)[0].clear_bytes += kADTSHeaderMinSize;
   }
   return true;
 }
 
-bool MP4StreamParser::EnqueueSample(BufferQueue* audio_buffers,
-                                    BufferQueue* video_buffers,
-                                    bool* err) {
+bool MP4StreamParser::EnqueueSample(BufferQueueMap* buffers, bool* err) {
   DCHECK_EQ(state_, kEmittingSamples);
 
   if (!runs_->IsRunValid()) {
     // Flush any buffers we've gotten in this chunk so that buffers don't
     // cross |new_segment_cb_| calls
-    *err = !SendAndFlushSamples(audio_buffers, video_buffers);
+    *err = !SendAndFlushSamples(buffers);
     if (*err)
       return false;
 
     // Remain in kEmittingSamples state, discarding data, until the end of
     // the current 'mdat' box has been appended to the queue.
     if (!queue_.Trim(mdat_tail_))
       return false;
 
     ChangeState(kParsingBoxes);
     end_of_segment_cb_.Run();
@@ skipping 108 matching lines @@
   stream_buf->set_timestamp(runs_->cts());
   stream_buf->SetDecodeTimestamp(runs_->dts());
 
   DVLOG(3) << "Pushing frame: aud=" << audio
            << ", key=" << runs_->is_keyframe()
            << ", dur=" << runs_->duration().InMilliseconds()
            << ", dts=" << runs_->dts().InMilliseconds()
            << ", cts=" << runs_->cts().InMilliseconds()
            << ", size=" << runs_->sample_size();
 
-  if (audio) {
-    audio_buffers->push_back(stream_buf);
-  } else {
-    video_buffers->push_back(stream_buf);
-  }
-
+  (*buffers)[runs_->track_id()].push_back(stream_buf);
   runs_->AdvanceSample();
   return true;
 }
 
-bool MP4StreamParser::SendAndFlushSamples(BufferQueue* audio_buffers,
-                                          BufferQueue* video_buffers) {
-  if (audio_buffers->empty() && video_buffers->empty())
+bool MP4StreamParser::SendAndFlushSamples(BufferQueueMap* buffers) {
+  if (buffers->empty())
     return true;
-
-  TextBufferQueueMap empty_text_map;
-  bool success = new_buffers_cb_.Run(*audio_buffers,
-                                     *video_buffers,
-                                     empty_text_map);
-  audio_buffers->clear();
-  video_buffers->clear();
+  bool success = new_buffers_cb_.Run(*buffers);
+  buffers->clear();
   return success;
 }
 
 bool MP4StreamParser::ReadAndDiscardMDATsUntil(int64_t max_clear_offset) {
   bool err = false;
   int64_t upper_bound = std::min(max_clear_offset, queue_.tail());
   while (mdat_tail_ < upper_bound) {
     const uint8_t* buf = NULL;
     int size = 0;
     queue_.PeekAt(mdat_tail_, &buf, &size);
@@ skipping 50 matching lines @@
       runs.AdvanceSample();
     }
     runs.AdvanceRun();
   }
 
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media