modules/demux/adaptive/playlist/BaseRepresentation.cpp

   1 /*
   2  * BaseRepresentation.cpp
   3  *****************************************************************************
   4  * Copyright (C) 2010 - 2011 Klagenfurt University
   5  *
   6  * Created on: Aug 10, 2010
   7  * Authors: Christopher Mueller <christopher.mueller@itec.uni-klu.ac.at>
   8  *          Christian Timmerer  <christian.timmerer@itec.uni-klu.ac.at>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published
  12  * by the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27
  28 #include <cstdlib>
  29
  30 #include "BaseRepresentation.h"
  31 #include "BaseAdaptationSet.h"
  32 #include "BasePlaylist.hpp"
  33 #include "SegmentTemplate.h"
  34 #include "SegmentTimeline.h"
  35 #include "SegmentList.h"
  36 #include "SegmentBase.h"
  37 #include "../ID.hpp"
  38 #include "../tools/Helper.h"
  39
  40 #include <limits>
  41
  42 using namespace adaptive;
  43 using namespace adaptive::playlist;
  44
  45 BaseRepresentation::BaseRepresentation( BaseAdaptationSet *set ) :
  46                 SegmentInformation( set ),
  47                 adaptationSet   ( set ),
  48                 bandwidth       (0)
  49 {
  50     b_consistent = true;
  51 }
  52
  53 BaseRepresentation::~BaseRepresentation ()
  54 {
  55 }
  56
  57 StreamFormat BaseRepresentation::getStreamFormat() const
  58 {
  59     return StreamFormat();
  60 }
  61
  62 BaseAdaptationSet * BaseRepresentation::getAdaptationSet()
  63 {
  64     return adaptationSet;
  65 }
  66
  67 uint64_t     BaseRepresentation::getBandwidth            () const
  68 {
  69     return bandwidth;
  70 }
  71
  72 void    BaseRepresentation::setBandwidth( uint64_t bandwidth )
  73 {
  74     this->bandwidth = bandwidth;
  75 }
  76
  77 const std::list<std::string> & BaseRepresentation::getCodecs() const
  78 {
  79     return codecs;
  80 }
  81
  82 void BaseRepresentation::addCodecs(const std::string &s)
  83 {
  84     std::list<std::string> list = Helper::tokenize(s, ',');
  85     std::list<std::string>::const_iterator it;
  86     for(it=list.begin(); it!=list.end(); ++it)
  87         codecs.push_back(*it);
  88 }
  89
  90 void BaseRepresentation::getCodecsDesc(CodecDescriptionList *desc) const
  91 {
  92     std::list<std::string> codecs = getCodecs();
  93     if(codecs.empty())
  94     {
  95         const StreamFormat format = getStreamFormat();
  96         switch(format)
  97         {
  98             case StreamFormat::TTML:
  99                 codecs.push_front("stpp");
 100                 break;
 101             case StreamFormat::WEBVTT:
 102                 codecs.push_front("wvtt");
 103                 break;
 104             default:
 105                 break;
 106         }
 107     }
 108
 109     for(auto it = codecs.cbegin(); it != codecs.cend(); ++it)
 110     {
 111         CodecDescription *dsc = makeCodecDescription(*it);
 112         dsc->setDescription(adaptationSet->description.Get());
 113         dsc->setLanguage(adaptationSet->getLang());
 114         desc->push_back(dsc);
 115     }
 116 }
 117
 118 CodecDescription * BaseRepresentation::makeCodecDescription(const std::string &codec) const
 119 {
 120     return new CodecDescription(codec);
 121 }
 122
 123 bool BaseRepresentation::needsUpdate(uint64_t) const
 124 {
 125     return false;
 126 }
 127
 128 bool BaseRepresentation::needsIndex() const
 129 {
 130     SegmentBase *base = inheritSegmentBase();
 131     return base && base->subSegments().empty();
 132 }
 133
 134 bool BaseRepresentation::runLocalUpdates(SharedResources *)
 135 {
 136     return false;
 137 }
 138
 139 void BaseRepresentation::scheduleNextUpdate(uint64_t, bool)
 140 {
 141
 142 }
 143
 144 bool BaseRepresentation::consistentSegmentNumber() const
 145 {
 146     return b_consistent;
 147 }
 148
 149 void BaseRepresentation::pruneByPlaybackTime(vlc_tick_t time)
 150 {
 151     uint64_t num;
 152     if(getSegmentNumberByTime(time, &num))
 153         pruneBySegmentNumber(num);
 154 }
 155
 156 vlc_tick_t BaseRepresentation::getMinAheadTime(uint64_t curnum) const
 157 {
 158     AbstractSegmentBaseType *profile = inheritSegmentTemplate();
 159     if(!profile)
 160         profile = inheritSegmentList();
 161     if(!profile)
 162         profile = inheritSegmentBase();
 163
 164     return profile ? profile->getMinAheadTime(curnum) : 0;
 165 }
 166
 167 void BaseRepresentation::debug(vlc_object_t *obj, int indent) const
 168 {
 169     std::string text(indent, ' ');
 170     text.append("Representation ");
 171     text.append(id.str());
 172     if(!codecs.empty())
 173     {
 174         std::list<std::string>::const_iterator c = codecs.begin();
 175         text.append(" [" + *c++);
 176         while(c != codecs.end())
 177             text.append("," + *c++);
 178         text.append("]");
 179     }
 180     msg_Dbg(obj, "%s", text.c_str());
 181     const AbstractSegmentBaseType *profile = getProfile();
 182     if(profile)
 183         profile->debug(obj, indent + 1);
 184 }
 185
 186 std::string BaseRepresentation::contextualize(size_t, const std::string &component,
 187                                               const SegmentTemplate *) const
 188 {
 189     return component;
 190 }
 191
 192 bool BaseRepresentation::bwCompare(const BaseRepresentation *a,
 193                                    const BaseRepresentation *b)
 194 {
 195     return a->getBandwidth() < b->getBandwidth();
 196 }
 197
 198 bool BaseRepresentation::validateCodec(const std::string &) const
 199 {
 200     return true;
 201 }
 202
 203 uint64_t BaseRepresentation::translateSegmentNumber(uint64_t num, const BaseRepresentation *from) const
 204 {
 205     vlc_tick_t time, duration;
 206     if( from->getPlaybackTimeDurationBySegmentNumber(num, &time, &duration) )
 207         getSegmentNumberByTime(time, &num);
 208     return num;
 209 }
 210
 211 bool BaseRepresentation::getSegmentNumberByTime(vlc_tick_t time, uint64_t *ret) const
 212 {
 213     const AbstractSegmentBaseType *profile = inheritSegmentProfile();
 214     return profile && profile->getSegmentNumberByTime(time, ret);
 215 }
 216
 217 bool BaseRepresentation::getPlaybackTimeDurationBySegmentNumber(uint64_t number,
 218                                                                 vlc_tick_t *time, vlc_tick_t *duration) const
 219 {
 220     if(number == std::numeric_limits<uint64_t>::max())
 221         return false;
 222
 223     const AbstractSegmentBaseType *profile = inheritSegmentProfile();
 224     return profile && profile->getPlaybackTimeDurationBySegmentNumber(number, time, duration);
 225 }
 226
 227 bool BaseRepresentation::getMediaPlaybackRange(vlc_tick_t *rangeBegin,
 228                                                vlc_tick_t *rangeEnd,
 229                                                vlc_tick_t *rangeLength) const
 230 {
 231     SegmentTemplate *mediaSegmentTemplate = inheritSegmentTemplate();
 232     if( mediaSegmentTemplate )
 233     {
 234         const Timescale timescale = mediaSegmentTemplate->inheritTimescale();
 235         const SegmentTimeline *timeline = mediaSegmentTemplate->inheritSegmentTimeline();
 236         if( timeline )
 237         {
 238             stime_t startTime, endTime, duration;
 239             if(!timeline->getScaledPlaybackTimeDurationBySegmentNumber(timeline->minElementNumber(),
 240                                                                        &startTime, &duration) ||
 241                !timeline->getScaledPlaybackTimeDurationBySegmentNumber(timeline->maxElementNumber(),
 242                                                                        &endTime, &duration))
 243                 return false;
 244
 245             *rangeBegin = timescale.ToTime(startTime);
 246             *rangeEnd = timescale.ToTime(endTime+duration);
 247             *rangeLength = timescale.ToTime(timeline->getTotalLength());
 248             return true;
 249         }
 250         /* Else compute, current time and timeshiftdepth based */
 251         else if( mediaSegmentTemplate->inheritDuration() )
 252         {
 253             *rangeEnd = 0;
 254             *rangeBegin = -1 * getPlaylist()->timeShiftBufferDepth.Get();
 255             *rangeLength = getPlaylist()->timeShiftBufferDepth.Get();
 256             return true;
 257         }
 258     }
 259
 260     SegmentList *segmentList = inheritSegmentList();
 261     if ( segmentList && !segmentList->getSegments().empty() )
 262     {
 263         const Timescale timescale = segmentList->inheritTimescale();
 264         const std::vector<Segment *> &list = segmentList->getSegments();
 265         const ISegment *back = list.back();
 266         const stime_t startTime = list.front()->startTime.Get();
 267         const stime_t endTime = back->startTime.Get() + back->duration.Get();
 268         *rangeBegin = timescale.ToTime(startTime);
 269         *rangeEnd = timescale.ToTime(endTime);
 270         *rangeLength = timescale.ToTime(segmentList->getTotalLength());
 271         return true;
 272     }
 273
 274     SegmentBase *segmentBase = inheritSegmentBase();
 275     if( segmentBase )
 276     {
 277         const std::vector<Segment *> &list = segmentBase->subSegments();
 278         if(list.empty())
 279             return false;
 280
 281         const Timescale timescale = inheritTimescale();
 282         const Segment *back = list.back();
 283         const stime_t startTime = list.front()->startTime.Get();
 284         const stime_t endTime = back->startTime.Get() + back->duration.Get();
 285         *rangeBegin = timescale.ToTime(startTime);
 286         *rangeEnd = timescale.ToTime(endTime);
 287         *rangeLength = 0;
 288         return true;
 289     }
 290
 291     return false;
 292 }