Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2             : /* This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
       4             :  * You can obtain one at http://mozilla.org/MPL/2.0/. */
       5             : 
       6             : #include "StreamTracks.h"
       7             : #include "mozilla/Logging.h"
       8             : #include <algorithm>
       9             : 
      10             : namespace mozilla {
      11             : 
      12             : extern LazyLogModule gMediaStreamGraphLog;
      13             : #define STREAM_LOG(type, msg) MOZ_LOG(gMediaStreamGraphLog, type, msg)
      14             : 
      15             : #ifdef DEBUG
      16             : void
      17           0 : StreamTracks::DumpTrackInfo() const
      18             : {
      19           0 :   STREAM_LOG(LogLevel::Info, ("DumpTracks: mTracksKnownTime %" PRId64, mTracksKnownTime));
      20           0 :   for (uint32_t i = 0; i < mTracks.Length(); ++i) {
      21           0 :     Track* track = mTracks[i];
      22           0 :     if (track->IsEnded()) {
      23           0 :       STREAM_LOG(LogLevel::Info, ("Track[%d] %d: ended", i, track->GetID()));
      24             :     } else {
      25           0 :       STREAM_LOG(LogLevel::Info, ("Track[%d] %d: %" PRId64 "", i, track->GetID(),
      26             :                                  track->GetEnd()));
      27             :     }
      28             :   }
      29           0 : }
      30             : #endif
      31             : 
      32             : StreamTime
      33           0 : StreamTracks::GetEnd() const
      34             : {
      35           0 :   StreamTime t = mTracksKnownTime;
      36           0 :   for (uint32_t i = 0; i < mTracks.Length(); ++i) {
      37           0 :     Track* track = mTracks[i];
      38           0 :     if (!track->IsEnded()) {
      39           0 :       t = std::min(t, track->GetEnd());
      40             :     }
      41             :   }
      42           0 :   return t;
      43             : }
      44             : 
      45             : StreamTime
      46           0 : StreamTracks::GetAllTracksEnd() const
      47             : {
      48           0 :   if (mTracksKnownTime < STREAM_TIME_MAX) {
      49             :     // A track might be added.
      50           0 :     return STREAM_TIME_MAX;
      51             :   }
      52           0 :   StreamTime t = 0;
      53           0 :   for (uint32_t i = 0; i < mTracks.Length(); ++i) {
      54           0 :     Track* track = mTracks[i];
      55           0 :     if (!track->IsEnded()) {
      56           0 :       return STREAM_TIME_MAX;
      57             :     }
      58           0 :     t = std::max(t, track->GetEnd());
      59             :   }
      60           0 :   return t;
      61             : }
      62             : 
      63             : StreamTracks::Track*
      64           0 : StreamTracks::FindTrack(TrackID aID)
      65             : {
      66           0 :   if (aID == TRACK_NONE || mTracks.IsEmpty()) {
      67           0 :     return nullptr;
      68             :   }
      69             : 
      70             :   // The tracks are sorted by ID. We can use a binary search.
      71             : 
      72           0 :   uint32_t left = 0, right = mTracks.Length() - 1;
      73           0 :   while (left <= right) {
      74           0 :     uint32_t middle = (left + right) / 2;
      75           0 :     if (mTracks[middle]->GetID() == aID) {
      76           0 :       return mTracks[middle];
      77             :     }
      78             : 
      79           0 :     if (mTracks[middle]->GetID() > aID) {
      80           0 :       if (middle == 0) {
      81           0 :         break;
      82             :       }
      83             : 
      84           0 :       right = middle - 1;
      85             :     } else {
      86           0 :       left = middle + 1;
      87             :     }
      88             :   }
      89             : 
      90           0 :   return nullptr;
      91             : }
      92             : 
      93             : void
      94           0 : StreamTracks::ForgetUpTo(StreamTime aTime)
      95             : {
      96             :   // Only prune if there is a reasonable chunk (50ms @ 48kHz) to forget, so we
      97             :   // don't spend too much time pruning segments.
      98           0 :   const StreamTime minChunkSize = 2400;
      99           0 :   if (aTime < mForgottenTime + minChunkSize) {
     100           0 :     return;
     101             :   }
     102           0 :   mForgottenTime = aTime;
     103             : 
     104           0 :   for (uint32_t i = 0; i < mTracks.Length(); ++i) {
     105           0 :     Track* track = mTracks[i];
     106           0 :     StreamTime forgetTo = std::min(track->GetEnd() - 1, aTime);
     107           0 :     track->ForgetUpTo(forgetTo);
     108             :   }
     109             : }
     110             : 
     111             : void
     112           0 : StreamTracks::Clear()
     113             : {
     114           0 :   mTracks.Clear();
     115           0 : }
     116             : 
     117             : } // namespace mozilla