modules/demux/adaptive/playlist/SegmentTemplate.cpp

   1 /*****************************************************************************
   2  * SegmentTemplate.cpp: Implement the UrlTemplate element.
   3  *****************************************************************************
   4  * Copyright (C) 1998-2007 VLC authors and VideoLAN
   5  *
   6  * Authors: Hugo Beauzée-Luyssen <hugo@beauzee.fr>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22 #ifdef HAVE_CONFIG_H
  23 # include "config.h"
  24 #endif
  25
  26 #include "SegmentTemplate.h"
  27 #include "SegmentTimeline.h"
  28 #include "SegmentInformation.hpp"
  29 #include "AbstractPlaylist.hpp"
  30 #include <limits>
  31
  32 using namespace adaptive::playlist;
  33
  34 SegmentTemplateSegment::SegmentTemplateSegment( SegmentTemplate *templ_,
  35                                                 ICanonicalUrl *parent ) :
  36     Segment( parent )
  37 {
  38     debugName = "SegmentTemplateSegment";
  39     classId = Segment::CLASSID_SEGMENT;
  40     templated = true;
  41     templ = templ_;
  42 }
  43
  44 SegmentTemplateSegment::~SegmentTemplateSegment()
  45 {
  46
  47 }
  48
  49 void SegmentTemplateSegment::setSourceUrl(const std::string &url)
  50 {
  51     sourceUrl = Url(Url::Component(url, templ));
  52 }
  53
  54 SegmentTemplate::SegmentTemplate( SegmentInformation *parent ) :
  55     AbstractMultipleSegmentBaseType( NULL ) /* we don't want auto inherit */
  56 {
  57     initialisationSegment.Set( NULL );
  58     parentSegmentInformation = parent;
  59     segments.push_back( new SegmentTemplateSegment( this, parent ) );
  60 }
  61
  62 SegmentTemplate::~SegmentTemplate()
  63 {
  64     delete *segments.begin();
  65 }
  66
  67 void SegmentTemplate::setSourceUrl( const std::string &url )
  68 {
  69     (*segments.begin())->setSourceUrl(url);
  70 }
  71
  72 void SegmentTemplate::pruneByPlaybackTime(vlc_tick_t time)
  73 {
  74     if(segmentTimeline)
  75         return segmentTimeline->pruneByPlaybackTime(time);
  76 }
  77
  78 size_t SegmentTemplate::pruneBySequenceNumber(uint64_t number)
  79 {
  80     if(segmentTimeline)
  81         return segmentTimeline->pruneBySequenceNumber(number);
  82     return 0;
  83 }
  84
  85 uint64_t SegmentTemplate::getLiveTemplateNumber(vlc_tick_t playbacktime, bool abs) const
  86 {
  87     uint64_t number = inheritStartNumber();
  88     /* live streams / templated */
  89     const stime_t dur = inheritDuration();
  90     if(dur)
  91     {
  92         /* compute, based on current time */
  93         /* N = (T - AST - PS - D)/D + sSN */
  94         const Timescale timescale = inheritTimescale();
  95         if(abs)
  96         {
  97             vlc_tick_t streamstart =
  98                     parentSegmentInformation->getPlaylist()->availabilityStartTime.Get();
  99             streamstart += parentSegmentInformation->getPeriodStart();
 100             playbacktime -= streamstart;
 101         }
 102         stime_t elapsed = timescale.ToScaled(playbacktime) - dur;
 103         if(elapsed > 0)
 104             number += elapsed / dur;
 105     }
 106
 107     return number;
 108 }
 109
 110 void SegmentTemplate::debug(vlc_object_t *obj, int indent) const
 111 {
 112     AbstractSegmentBaseType::debug(obj, indent);
 113     (*segments.begin())->debug(obj, indent);
 114     if(segmentTimeline)
 115         segmentTimeline->debug(obj, indent + 1);
 116 }
 117
 118 vlc_tick_t SegmentTemplate::getMinAheadTime(uint64_t number) const
 119 {
 120     if( segmentTimeline )
 121     {
 122         const Timescale timescale = segmentTimeline->inheritTimescale();
 123         return timescale.ToTime(segmentTimeline->getMinAheadScaledTime(number));
 124     }
 125     else
 126     {
 127         const Timescale timescale = inheritTimescale();
 128         uint64_t current = getLiveTemplateNumber(vlc_tick_from_sec(time(NULL)));
 129         stime_t i_length = (current - number) * inheritDuration();
 130         return timescale.ToTime(i_length);
 131     }
 132 }
 133
 134 Segment * SegmentTemplate::getMediaSegment(uint64_t number) const
 135 {
 136     const SegmentTimeline *tl = inheritSegmentTimeline();
 137     if(tl == NULL || tl->maxElementNumber() > number)
 138         return *segments.begin();
 139     return NULL;
 140 }
 141
 142 InitSegment * SegmentTemplate::getInitSegment() const
 143 {
 144     return initialisationSegment.Get();
 145 }
 146
 147 Segment *  SegmentTemplate::getNextMediaSegment(uint64_t i_pos,uint64_t *pi_newpos,
 148                                                      bool *pb_gap) const
 149 {
 150     *pb_gap = false;
 151     *pi_newpos = i_pos;
 152     /* Check if we don't exceed timeline */
 153     const SegmentTimeline *timeline = inheritSegmentTimeline();
 154     if(timeline)
 155     {
 156         *pi_newpos = std::max(timeline->minElementNumber(), i_pos);
 157         if (timeline->maxElementNumber() < i_pos)
 158             return NULL;
 159     }
 160     else
 161     {
 162         /* check template upper bound */
 163         const AbstractPlaylist *playlist = parentSegmentInformation->getPlaylist();
 164         if(!playlist->isLive())
 165         {
 166             const Timescale timescale = inheritTimescale();
 167             const stime_t segmentduration = inheritDuration();
 168             vlc_tick_t totalduration = parentSegmentInformation->getPeriodDuration();
 169             if(totalduration == 0)
 170                 totalduration = playlist->duration.Get();
 171             if(totalduration && segmentduration)
 172             {
 173                 uint64_t endnum = inheritStartNumber() +
 174                         (timescale.ToScaled(totalduration) + segmentduration - 1) / segmentduration;
 175                 if(i_pos >= endnum)
 176                 {
 177                     *pi_newpos = i_pos;
 178                     return NULL;
 179                 }
 180             }
 181         }
 182         *pi_newpos = i_pos;
 183         /* start number */
 184         *pi_newpos = std::max(inheritStartNumber(), i_pos);
 185     }
 186     return *segments.begin();
 187 }
 188
 189 uint64_t SegmentTemplate::getStartSegmentNumber() const
 190 {
 191     const SegmentTimeline *timeline = inheritSegmentTimeline();
 192     return timeline ? timeline->minElementNumber() : inheritStartNumber();
 193 }
 194
 195 bool SegmentTemplate::getSegmentNumberByTime(vlc_tick_t time, uint64_t *ret) const
 196 {
 197     const SegmentTimeline *timeline = inheritSegmentTimeline();
 198     if(timeline)
 199     {
 200         const Timescale timescale = timeline->getTimescale().isValid()
 201                                   ? timeline->getTimescale()
 202                                   : inheritTimescale();
 203         stime_t st = timescale.ToScaled(time);
 204         *ret = timeline->getElementNumberByScaledPlaybackTime(st);
 205         return true;
 206     }
 207
 208     const stime_t duration = inheritDuration();
 209     if( duration && parent )
 210     {
 211         AbstractPlaylist *playlist = parent->getPlaylist();
 212         if( playlist->isLive() )
 213         {
 214             vlc_tick_t now = vlc_tick_from_sec(::time(NULL));
 215             if(playlist->availabilityStartTime.Get())
 216             {
 217                 if(time >= playlist->availabilityStartTime.Get() && time < now)
 218                     *ret = getLiveTemplateNumber(time, true);
 219                 else if(now - playlist->availabilityStartTime.Get() > time)
 220                     *ret = getLiveTemplateNumber(time, false);
 221             }
 222             else return false;
 223         }
 224         else
 225         {
 226             const Timescale timescale = inheritTimescale();
 227             *ret = inheritStartNumber();
 228             *ret += timescale.ToScaled(time) / duration;
 229         }
 230         return true;
 231     }
 232
 233     return false;
 234 }
 235
 236
 237 bool SegmentTemplate::getPlaybackTimeDurationBySegmentNumber(uint64_t number,
 238                                                              vlc_tick_t *time,
 239                                                              vlc_tick_t *duration) const
 240 {
 241     if(number == std::numeric_limits<uint64_t>::max())
 242         return false;
 243
 244     Timescale timescale;
 245     stime_t stime, sduration;
 246
 247     const SegmentTimeline * timeline = inheritSegmentTimeline();
 248     if(timeline)
 249     {
 250         timescale = timeline->inheritTimescale();
 251         if(!timeline->getScaledPlaybackTimeDurationBySegmentNumber(number, &stime, &sduration))
 252             return false;
 253     }
 254     else
 255     {
 256         timescale = inheritTimescale();
 257         uint64_t startNumber = inheritStartNumber();
 258         if(number < startNumber)
 259             return false;
 260         sduration = inheritDuration();
 261         stime = (number - startNumber) * sduration;
 262     }
 263
 264     *time = timescale.ToTime(stime);
 265     *duration = timescale.ToTime(sduration);
 266     return true;
 267
 268 }
 269
 270 SegmentTemplateInit::SegmentTemplateInit( SegmentTemplate *templ_,
 271                                           ICanonicalUrl *parent ) :
 272     InitSegment(parent)
 273 {
 274     debugName = "InitSegmentTemplate";
 275     classId = InitSegment::CLASSID_INITSEGMENT;
 276     templ = templ_;
 277 }
 278
 279 SegmentTemplateInit::~SegmentTemplateInit()
 280 {
 281
 282 }
 283
 284 void SegmentTemplateInit::setSourceUrl(const std::string &url)
 285 {
 286     sourceUrl = Url(Url::Component(url, templ));
 287 }