modules/demux/adaptive/SegmentTracker.cpp

   1 /*
   2  * SegmentTracker.cpp
   3  *****************************************************************************
   4  * Copyright (C) 2014 - VideoLAN and VLC authors
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 #ifdef HAVE_CONFIG_H
  22 # include "config.h"
  23 #endif
  24
  25 #include "SegmentTracker.hpp"
  26 #include "playlist/AbstractPlaylist.hpp"
  27 #include "playlist/BaseRepresentation.h"
  28 #include "playlist/BaseAdaptationSet.h"
  29 #include "playlist/Segment.h"
  30 #include "playlist/SegmentChunk.hpp"
  31 #include "logic/AbstractAdaptationLogic.h"
  32
  33 using namespace adaptive;
  34 using namespace adaptive::logic;
  35 using namespace adaptive::playlist;
  36
  37 SegmentTrackerEvent::SegmentTrackerEvent(SegmentChunk *s)
  38 {
  39     type = DISCONTINUITY;
  40     u.discontinuity.sc = s;
  41 }
  42
  43 SegmentTrackerEvent::SegmentTrackerEvent(BaseRepresentation *prev, BaseRepresentation *next)
  44 {
  45     type = SWITCHING;
  46     u.switching.prev = prev;
  47     u.switching.next = next;
  48 }
  49
  50 SegmentTrackerEvent::SegmentTrackerEvent(const StreamFormat *fmt)
  51 {
  52     type = FORMATCHANGE;
  53     u.format.f = fmt;
  54 }
  55
  56 SegmentTrackerEvent::SegmentTrackerEvent(const ID &id, bool enabled)
  57 {
  58     type = BUFFERING_STATE;
  59     u.buffering.enabled = enabled;
  60     u.buffering.id = &id;
  61 }
  62
  63 SegmentTrackerEvent::SegmentTrackerEvent(const ID &id, mtime_t min, mtime_t current, mtime_t target)
  64 {
  65     type = BUFFERING_LEVEL_CHANGE;
  66     u.buffering_level.minimum = min;
  67     u.buffering_level.current = current;
  68     u.buffering_level.target = target;
  69     u.buffering.id = &id;
  70 }
  71
  72 SegmentTrackerEvent::SegmentTrackerEvent(const ID &id, mtime_t duration)
  73 {
  74     type = SEGMENT_CHANGE;
  75     u.segment.duration = duration;
  76     u.segment.id = &id;
  77 }
  78
  79 SegmentTracker::SegmentTracker(AbstractAdaptationLogic *logic_, BaseAdaptationSet *adaptSet)
  80 {
  81     first = true;
  82     curNumber = next = 0;
  83     initializing = true;
  84     index_sent = false;
  85     init_sent = false;
  86     curRepresentation = NULL;
  87     setAdaptationLogic(logic_);
  88     adaptationSet = adaptSet;
  89     format = StreamFormat::UNSUPPORTED;
  90 }
  91
  92 SegmentTracker::~SegmentTracker()
  93 {
  94     reset();
  95 }
  96
  97 void SegmentTracker::setAdaptationLogic(AbstractAdaptationLogic *logic_)
  98 {
  99     logic = logic_;
 100     registerListener(logic);
 101 }
 102
 103 StreamFormat SegmentTracker::getCurrentFormat() const
 104 {
 105     BaseRepresentation *rep = curRepresentation;
 106     if(!rep)
 107         rep = logic->getNextRepresentation(adaptationSet, NULL);
 108     if(rep)
 109     {
 110         /* Ensure ephemere content is updated/loaded */
 111         if(rep->needsUpdate())
 112             (void) rep->runLocalUpdates(0, curNumber, false);
 113         return rep->getStreamFormat();
 114     }
 115     return StreamFormat();
 116 }
 117
 118 bool SegmentTracker::segmentsListReady() const
 119 {
 120     BaseRepresentation *rep = curRepresentation;
 121     if(!rep)
 122         rep = logic->getNextRepresentation(adaptationSet, NULL);
 123     if(rep && rep->getPlaylist()->isLive())
 124         return rep->getMinAheadTime(curNumber) > 0;
 125     return true;
 126 }
 127
 128 void SegmentTracker::reset()
 129 {
 130     notify(SegmentTrackerEvent(curRepresentation, NULL));
 131     curRepresentation = NULL;
 132     init_sent = false;
 133     index_sent = false;
 134     initializing = true;
 135     format = StreamFormat::UNSUPPORTED;
 136 }
 137
 138 SegmentChunk * SegmentTracker::getNextChunk(bool switch_allowed,
 139                                             AbstractConnectionManager *connManager)
 140 {
 141     BaseRepresentation *rep = NULL, *prevRep = NULL;
 142     ISegment *segment;
 143
 144     if(!adaptationSet)
 145         return NULL;
 146
 147     /* Ensure we don't keep chaining init/index without data */
 148     if( initializing )
 149     {
 150         if( curRepresentation )
 151             switch_allowed = false;
 152         else
 153             switch_allowed = true;
 154     }
 155
 156     if( !switch_allowed ||
 157        (curRepresentation && curRepresentation->getSwitchPolicy() == SegmentInformation::SWITCH_UNAVAILABLE) )
 158         rep = curRepresentation;
 159     else
 160         rep = logic->getNextRepresentation(adaptationSet, curRepresentation);
 161
 162     if ( rep == NULL )
 163             return NULL;
 164
 165
 166     if(rep != curRepresentation)
 167     {
 168         notify(SegmentTrackerEvent(curRepresentation, rep));
 169         prevRep = curRepresentation;
 170         curRepresentation = rep;
 171         init_sent = false;
 172         index_sent = false;
 173         initializing = true;
 174     }
 175
 176     bool b_updated = false;
 177     /* Ensure ephemere content is updated/loaded */
 178     if(rep->needsUpdate())
 179         b_updated = rep->runLocalUpdates(getPlaybackTime(), curNumber, false);
 180
 181     if(prevRep && !rep->consistentSegmentNumber())
 182     {
 183         /* Convert our segment number */
 184         next = rep->translateSegmentNumber(next, prevRep);
 185     }
 186     else if(first && rep->getPlaylist()->isLive())
 187     {
 188         next = rep->getLiveStartSegmentNumber(next);
 189         first = false;
 190     }
 191
 192     if(b_updated)
 193     {
 194         if(!rep->consistentSegmentNumber())
 195             curRepresentation->pruneBySegmentNumber(curNumber);
 196         curRepresentation->scheduleNextUpdate(next);
 197     }
 198
 199     if(rep->getStreamFormat() != format)
 200     {
 201         /* Initial format ? */
 202         if(format == StreamFormat(StreamFormat::UNSUPPORTED))
 203         {
 204             format = rep->getStreamFormat();
 205         }
 206         else
 207         {
 208             format = rep->getStreamFormat();
 209             notify(SegmentTrackerEvent(&format)); /* Notify new demux format */
 210             return NULL; /* Force current demux to end */
 211         }
 212     }
 213
 214     if(format == StreamFormat(StreamFormat::UNSUPPORTED))
 215     {
 216         return NULL; /* Can't return chunk because no demux will be created */
 217     }
 218
 219     if(!init_sent)
 220     {
 221         init_sent = true;
 222         segment = rep->getSegment(BaseRepresentation::INFOTYPE_INIT);
 223         if(segment)
 224             return segment->toChunk(next, rep, connManager);
 225     }
 226
 227     if(!index_sent)
 228     {
 229         index_sent = true;
 230         segment = rep->getSegment(BaseRepresentation::INFOTYPE_INDEX);
 231         if(segment)
 232             return segment->toChunk(next, rep, connManager);
 233     }
 234
 235     bool b_gap = false;
 236     segment = rep->getNextSegment(BaseRepresentation::INFOTYPE_MEDIA, next, &next, &b_gap);
 237     if(!segment)
 238     {
 239         reset();
 240         return NULL;
 241     }
 242
 243     if(initializing)
 244     {
 245         b_gap = false;
 246         /* stop initializing after 1st chunk */
 247         initializing = false;
 248     }
 249
 250     SegmentChunk *chunk = segment->toChunk(next, rep, connManager);
 251
 252     /* Notify new segment length for stats / logic */
 253     if(chunk)
 254     {
 255         const Timescale timescale = rep->inheritTimescale();
 256         notify(SegmentTrackerEvent(rep->getAdaptationSet()->getID(),
 257                                    timescale.ToTime(segment->duration.Get())));
 258     }
 259
 260     /* We need to check segment/chunk format changes, as we can't rely on representation's (HLS)*/
 261     if(chunk && format != chunk->getStreamFormat())
 262     {
 263         format = chunk->getStreamFormat();
 264         notify(SegmentTrackerEvent(&format));
 265     }
 266
 267     /* Handle both implicit and explicit discontinuities */
 268     if( (b_gap && next) || (chunk && chunk->discontinuity) )
 269     {
 270         notify(SegmentTrackerEvent(chunk));
 271     }
 272
 273     if(chunk)
 274     {
 275         curNumber = next;
 276         next++;
 277     }
 278
 279     return chunk;
 280 }
 281
 282 bool SegmentTracker::setPositionByTime(mtime_t time, bool restarted, bool tryonly)
 283 {
 284     uint64_t segnumber;
 285     BaseRepresentation *rep = curRepresentation;
 286     if(!rep)
 287         rep = logic->getNextRepresentation(adaptationSet, NULL);
 288
 289     if(rep &&
 290        rep->getSegmentNumberByTime(time, &segnumber))
 291     {
 292         if(!tryonly)
 293             setPositionByNumber(segnumber, restarted);
 294         return true;
 295     }
 296     return false;
 297 }
 298
 299 void SegmentTracker::setPositionByNumber(uint64_t segnumber, bool restarted)
 300 {
 301     if(restarted)
 302     {
 303         initializing = true;
 304         index_sent = false;
 305         init_sent = false;
 306     }
 307     curNumber = next = segnumber;
 308 }
 309
 310 mtime_t SegmentTracker::getPlaybackTime() const
 311 {
 312     mtime_t time, duration;
 313
 314     BaseRepresentation *rep = curRepresentation;
 315     if(!rep)
 316         rep = logic->getNextRepresentation(adaptationSet, NULL);
 317
 318     if(rep &&
 319        rep->getPlaybackTimeDurationBySegmentNumber(next, &time, &duration))
 320     {
 321         return time;
 322     }
 323     return 0;
 324 }
 325
 326 mtime_t SegmentTracker::getMinAheadTime() const
 327 {
 328     BaseRepresentation *rep = curRepresentation;
 329     if(!rep)
 330         rep = logic->getNextRepresentation(adaptationSet, NULL);
 331     if(rep)
 332         return rep->getMinAheadTime(curNumber);
 333     return 0;
 334 }
 335
 336 void SegmentTracker::notifyBufferingState(bool enabled) const
 337 {
 338     notify(SegmentTrackerEvent(adaptationSet->getID(), enabled));
 339 }
 340
 341 void SegmentTracker::notifyBufferingLevel(mtime_t min, mtime_t current, mtime_t target) const
 342 {
 343     notify(SegmentTrackerEvent(adaptationSet->getID(), min, current, target));
 344 }
 345
 346 void SegmentTracker::registerListener(SegmentTrackerListenerInterface *listener)
 347 {
 348     listeners.push_back(listener);
 349 }
 350
 351 void SegmentTracker::updateSelected()
 352 {
 353     if(curRepresentation && curRepresentation->needsUpdate())
 354     {
 355         curRepresentation->runLocalUpdates(getPlaybackTime(), curNumber, true);
 356         curRepresentation->scheduleNextUpdate(curNumber);
 357     }
 358 }
 359
 360 void SegmentTracker::notify(const SegmentTrackerEvent &event) const
 361 {
 362     std::list<SegmentTrackerListenerInterface *>::const_iterator it;
 363     for(it=listeners.begin();it != listeners.end(); ++it)
 364         (*it)->trackerEvent(event);
 365 }