modules/demux/adaptive/PlaylistManager.cpp

   1 /*
   2  * PlaylistManager.cpp
   3  *****************************************************************************
   4  * Copyright © 2010 - 2011 Klagenfurt University
   5  *             2015 VideoLAN and VLC Authors
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU Lesser General Public License as published
   9  * by the Free Software Foundation; either version 2.1 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public License
  18  * along with this program; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  20  *****************************************************************************/
  21
  22 #ifdef HAVE_CONFIG_H
  23 # include "config.h"
  24 #endif
  25
  26 #include "PlaylistManager.h"
  27 #include "SegmentTracker.hpp"
  28 #include "playlist/AbstractPlaylist.hpp"
  29 #include "playlist/BasePeriod.h"
  30 #include "playlist/BaseAdaptationSet.h"
  31 #include "playlist/BaseRepresentation.h"
  32 #include "http/HTTPConnectionManager.h"
  33 #include "logic/AlwaysBestAdaptationLogic.h"
  34 #include "logic/RateBasedAdaptationLogic.h"
  35 #include "logic/AlwaysLowestAdaptationLogic.hpp"
  36 #include "logic/PredictiveAdaptationLogic.hpp"
  37 #include "logic/NearOptimalAdaptationLogic.hpp"
  38 #include "tools/Debug.hpp"
  39 #include <vlc_stream.h>
  40 #include <vlc_demux.h>
  41 #include <vlc_threads.h>
  42
  43 #include <algorithm>
  44 #include <ctime>
  45
  46 using namespace adaptive::http;
  47 using namespace adaptive::logic;
  48 using namespace adaptive;
  49
  50 PlaylistManager::PlaylistManager( demux_t *p_demux_,
  51                                   AbstractPlaylist *pl,
  52                                   AbstractStreamFactory *factory,
  53                                   AbstractAdaptationLogic::LogicType type ) :
  54              conManager     ( NULL ),
  55              logicType      ( type ),
  56              logic          ( NULL ),
  57              playlist       ( pl ),
  58              streamFactory  ( factory ),
  59              p_demux        ( p_demux_ )
  60 {
  61     currentPeriod = playlist->getFirstPeriod();
  62     failedupdates = 0;
  63     b_thread = false;
  64     b_buffering = false;
  65     nextPlaylistupdate = 0;
  66     demux.i_nzpcr = VLC_TS_INVALID;
  67     demux.i_firstpcr = VLC_TS_INVALID;
  68     vlc_mutex_init(&demux.lock);
  69     vlc_cond_init(&demux.cond);
  70     vlc_mutex_init(&lock);
  71     vlc_cond_init(&waitcond);
  72     vlc_mutex_init(&cached.lock);
  73     cached.b_live = false;
  74     cached.i_length = 0;
  75     cached.f_position = 0.0;
  76     cached.i_time = VLC_TS_INVALID;
  77 }
  78
  79 PlaylistManager::~PlaylistManager   ()
  80 {
  81     delete streamFactory;
  82     unsetPeriod();
  83     delete playlist;
  84     delete conManager;
  85     delete logic;
  86     vlc_cond_destroy(&waitcond);
  87     vlc_mutex_destroy(&lock);
  88     vlc_mutex_destroy(&demux.lock);
  89     vlc_cond_destroy(&demux.cond);
  90     vlc_mutex_destroy(&cached.lock);
  91 }
  92
  93 void PlaylistManager::unsetPeriod()
  94 {
  95     std::vector<AbstractStream *>::iterator it;
  96     for(it=streams.begin(); it!=streams.end(); ++it)
  97         delete *it;
  98     streams.clear();
  99 }
 100
 101 bool PlaylistManager::setupPeriod()
 102 {
 103     if(!currentPeriod)
 104         return false;
 105
 106     if(!logic && !(logic = createLogic(logicType, conManager)))
 107         return false;
 108
 109     std::vector<BaseAdaptationSet*> sets = currentPeriod->getAdaptationSets();
 110     std::vector<BaseAdaptationSet*>::iterator it;
 111     for(it=sets.begin();it!=sets.end();++it)
 112     {
 113         BaseAdaptationSet *set = *it;
 114         if(set && streamFactory)
 115         {
 116             SegmentTracker *tracker = new (std::nothrow) SegmentTracker(logic, set);
 117             if(!tracker)
 118                 continue;
 119
 120             AbstractStream *st = streamFactory->create(p_demux, set->getStreamFormat(),
 121                                                        tracker, conManager);
 122             if(!st)
 123             {
 124                 delete tracker;
 125                 continue;
 126             }
 127
 128             streams.push_back(st);
 129
 130             /* Generate stream description */
 131             std::list<std::string> languages;
 132             if(!set->getLang().empty())
 133             {
 134                 languages = set->getLang();
 135             }
 136             else if(!set->getRepresentations().empty())
 137             {
 138                 languages = set->getRepresentations().front()->getLang();
 139             }
 140
 141             if(!languages.empty())
 142                 st->setLanguage(languages.front());
 143
 144             if(!set->description.Get().empty())
 145                 st->setDescription(set->description.Get());
 146         }
 147     }
 148     return true;
 149 }
 150
 151 bool PlaylistManager::start()
 152 {
 153     if(!conManager && !(conManager = new (std::nothrow) HTTPConnectionManager(VLC_OBJECT(p_demux->s))))
 154         return false;
 155
 156     if(!setupPeriod())
 157         return false;
 158
 159     playlist->playbackStart.Set(time(NULL));
 160     nextPlaylistupdate = playlist->playbackStart.Get();
 161
 162     updateControlsContentType();
 163     updateControlsPosition();
 164
 165     b_thread = !vlc_clone(&thread, managerThread,
 166                           static_cast<void *>(this), VLC_THREAD_PRIORITY_INPUT);
 167     if(!b_thread)
 168         return false;
 169
 170     setBufferingRunState(true);
 171
 172     return true;
 173 }
 174
 175 void PlaylistManager::stop()
 176 {
 177     if(b_thread)
 178     {
 179         vlc_cancel(thread);
 180         vlc_join(thread, NULL);
 181         b_thread = false;
 182     }
 183 }
 184
 185 struct PrioritizedAbstractStream
 186 {
 187     AbstractStream::buffering_status status;
 188     mtime_t demuxed_amount;
 189     AbstractStream *st;
 190 };
 191
 192 static bool streamCompare(PrioritizedAbstractStream a,  PrioritizedAbstractStream b)
 193 {
 194     if( a.status >= b.status ) /* Highest prio is higer value in enum */
 195     {
 196         if ( a.status == b.status ) /* Highest prio is lowest buffering */
 197            return a.demuxed_amount < b.demuxed_amount;
 198         else
 199             return true;
 200     }
 201     return false;
 202 }
 203
 204 AbstractStream::buffering_status PlaylistManager::bufferize(mtime_t i_nzdeadline,
 205                                                             unsigned i_min_buffering, unsigned i_extra_buffering)
 206 {
 207     AbstractStream::buffering_status i_return = AbstractStream::buffering_end;
 208
 209     /* First reorder by status >> buffering level */
 210     std::vector<PrioritizedAbstractStream> prioritized_streams(streams.size());
 211     std::vector<PrioritizedAbstractStream>::iterator it = prioritized_streams.begin();
 212     std::vector<AbstractStream *>::iterator sit = streams.begin();
 213     for( ; sit!=streams.end(); ++sit)
 214     {
 215         PrioritizedAbstractStream &p = *it;
 216         p.st = *sit;
 217         p.status = p.st->getLastBufferStatus();
 218         p.demuxed_amount = p.st->getDemuxedAmount();
 219         ++it;
 220     }
 221     std::sort(prioritized_streams.begin(), prioritized_streams.end(), streamCompare);
 222
 223     for(it=prioritized_streams.begin(); it!=prioritized_streams.end(); ++it)
 224     {
 225         AbstractStream *st = (*it).st;
 226
 227         if (st->isDisabled() &&
 228             (!st->isSelected() || !st->canActivate() || !reactivateStream(st)))
 229                 continue;
 230
 231         AbstractStream::buffering_status i_ret = st->bufferize(i_nzdeadline, i_min_buffering, i_extra_buffering);
 232         if(i_return != AbstractStream::buffering_ongoing) /* Buffering streams need to keep going */
 233         {
 234             if(i_ret > i_return)
 235                 i_return = i_ret;
 236         }
 237
 238         /* Bail out, will start again (high prio could be same starving stream) */
 239         if( i_return == AbstractStream::buffering_lessthanmin )
 240             break;
 241     }
 242
 243     vlc_mutex_lock(&demux.lock);
 244     if(demux.i_nzpcr == VLC_TS_INVALID &&
 245        i_return != AbstractStream::buffering_lessthanmin /* prevents starting before buffering is reached */ )
 246     {
 247         demux.i_nzpcr = getFirstDTS();
 248     }
 249     vlc_mutex_unlock(&demux.lock);
 250
 251     return i_return;
 252 }
 253
 254 AbstractStream::status PlaylistManager::dequeue(mtime_t i_floor, mtime_t *pi_nzbarrier)
 255 {
 256     AbstractStream::status i_return = AbstractStream::status_eof;
 257
 258     const mtime_t i_nzdeadline = *pi_nzbarrier;
 259
 260     std::vector<AbstractStream *>::iterator it;
 261     for(it=streams.begin(); it!=streams.end(); ++it)
 262     {
 263         AbstractStream *st = *it;
 264
 265         mtime_t i_pcr;
 266         AbstractStream::status i_ret = st->dequeue(i_nzdeadline, &i_pcr);
 267         if( i_ret > i_return )
 268             i_return = i_ret;
 269
 270         if( i_pcr > i_floor )
 271             *pi_nzbarrier = std::min( *pi_nzbarrier, i_pcr - VLC_TS_0 );
 272     }
 273
 274     return i_return;
 275 }
 276
 277 void PlaylistManager::drain()
 278 {
 279     for(;;)
 280     {
 281         bool b_drained = true;
 282         std::vector<AbstractStream *>::iterator it;
 283         for(it=streams.begin(); it!=streams.end(); ++it)
 284         {
 285             AbstractStream *st = *it;
 286
 287             if (st->isDisabled())
 288                 continue;
 289
 290             b_drained &= st->decodersDrained();
 291         }
 292
 293         if(b_drained)
 294             break;
 295
 296         msleep(20*1000); /* ugly, but we have no way to get feedback */
 297     }
 298     es_out_Control(p_demux->out, ES_OUT_RESET_PCR);
 299 }
 300
 301 mtime_t PlaylistManager::getPCR() const
 302 {
 303     mtime_t minpcr = VLC_TS_INVALID;
 304     std::vector<AbstractStream *>::const_iterator it;
 305     for(it=streams.begin(); it!=streams.end(); ++it)
 306     {
 307         const mtime_t pcr = (*it)->getPCR();
 308         if(minpcr == VLC_TS_INVALID)
 309             minpcr = pcr;
 310         else if(pcr > VLC_TS_INVALID)
 311             minpcr = std::min(minpcr, pcr);
 312     }
 313     return minpcr;
 314 }
 315
 316 mtime_t PlaylistManager::getFirstDTS() const
 317 {
 318     mtime_t mindts = VLC_TS_INVALID;
 319     std::vector<AbstractStream *>::const_iterator it;
 320     for(it=streams.begin(); it!=streams.end(); ++it)
 321     {
 322         const mtime_t dts = (*it)->getFirstDTS();
 323         if(mindts == VLC_TS_INVALID)
 324             mindts = dts;
 325         else if(dts > VLC_TS_INVALID)
 326             mindts = std::min(mindts, dts);
 327     }
 328     return mindts;
 329 }
 330
 331 mtime_t PlaylistManager::getDuration() const
 332 {
 333     if (playlist->isLive())
 334         return 0;
 335     else
 336         return playlist->duration.Get();
 337 }
 338
 339 bool PlaylistManager::setPosition(mtime_t time)
 340 {
 341     bool ret = true;
 342     for(int real = 0; real < 2; real++)
 343     {
 344         /* Always probe if we can seek first */
 345         std::vector<AbstractStream *>::iterator it;
 346         for(it=streams.begin(); it!=streams.end(); ++it)
 347         {
 348             AbstractStream *st = *it;
 349             if(!st->isDisabled())
 350                 ret &= st->setPosition(time, !real);
 351         }
 352         if(!ret)
 353             break;
 354     }
 355     return ret;
 356 }
 357
 358 bool PlaylistManager::needsUpdate() const
 359 {
 360     return playlist->isLive() && (failedupdates < 3);
 361 }
 362
 363 void PlaylistManager::scheduleNextUpdate()
 364 {
 365
 366 }
 367
 368 bool PlaylistManager::updatePlaylist()
 369 {
 370     std::vector<AbstractStream *>::const_iterator it;
 371     for(it=streams.begin(); it!=streams.end(); ++it)
 372         (*it)->runUpdates();
 373
 374     updateControlsContentType();
 375     updateControlsPosition();
 376     return true;
 377 }
 378
 379 mtime_t PlaylistManager::getFirstPlaybackTime() const
 380 {
 381     return 0;
 382 }
 383
 384 mtime_t PlaylistManager::getCurrentPlaybackTime() const
 385 {
 386     return demux.i_nzpcr;
 387 }
 388
 389 void PlaylistManager::pruneLiveStream()
 390 {
 391     mtime_t minValidPos = 0;
 392     std::vector<AbstractStream *>::const_iterator it;
 393     for(it=streams.begin(); it!=streams.end(); it++)
 394     {
 395         const AbstractStream *st = *it;
 396         if(st->isDisabled() || !st->isSelected())
 397             continue;
 398         const mtime_t t = st->getPlaybackTime();
 399         if(minValidPos == 0 || t < minValidPos)
 400             minValidPos = t;
 401     }
 402
 403     if(minValidPos)
 404         playlist->pruneByPlaybackTime(minValidPos);
 405 }
 406
 407 bool PlaylistManager::reactivateStream(AbstractStream *stream)
 408 {
 409     return stream->reactivate(getPCR());
 410 }
 411
 412 #define DEMUX_INCREMENT (CLOCK_FREQ / 20)
 413 int PlaylistManager::demux_callback(demux_t *p_demux)
 414 {
 415     PlaylistManager *manager = reinterpret_cast<PlaylistManager *>(p_demux->p_sys);
 416     return manager->doDemux(DEMUX_INCREMENT);
 417 }
 418
 419 int PlaylistManager::doDemux(int64_t increment)
 420 {
 421     vlc_mutex_lock(&demux.lock);
 422     if(demux.i_nzpcr == VLC_TS_INVALID)
 423     {
 424         bool b_dead = true;
 425         std::vector<AbstractStream *>::const_iterator it;
 426         for(it=streams.begin(); it!=streams.end(); ++it)
 427             b_dead &= !(*it)->canActivate();
 428         if(!b_dead)
 429             vlc_cond_timedwait(&demux.cond, &demux.lock, mdate() + CLOCK_FREQ / 20);
 430         vlc_mutex_unlock(&demux.lock);
 431         return (b_dead) ? AbstractStream::status_eof : AbstractStream::status_buffering;
 432     }
 433
 434     if(demux.i_firstpcr == VLC_TS_INVALID)
 435         demux.i_firstpcr = demux.i_nzpcr;
 436
 437     mtime_t i_nzbarrier = demux.i_nzpcr + increment;
 438     vlc_mutex_unlock(&demux.lock);
 439
 440     AbstractStream::status status = dequeue(demux.i_nzpcr, &i_nzbarrier);
 441
 442     updateControlsContentType();
 443     updateControlsPosition();
 444
 445     switch(status)
 446     {
 447     case AbstractStream::status_eof:
 448         {
 449             /* might be end of current period */
 450             if(currentPeriod)
 451             {
 452                 setBufferingRunState(false);
 453                 BasePeriod *nextPeriod = playlist->getNextPeriod(currentPeriod);
 454                 if(!nextPeriod)
 455                     return VLC_DEMUXER_EOF;
 456                 unsetPeriod();
 457                 currentPeriod = nextPeriod;
 458                 if (!setupPeriod())
 459                     return VLC_DEMUXER_EOF;
 460
 461                 demux.i_nzpcr = VLC_TS_INVALID;
 462                 demux.i_firstpcr = VLC_TS_INVALID;
 463                 es_out_Control(p_demux->out, ES_OUT_RESET_PCR);
 464
 465                 setBufferingRunState(true);
 466             }
 467         }
 468         break;
 469     case AbstractStream::status_buffering:
 470         vlc_mutex_lock(&demux.lock);
 471         vlc_cond_timedwait(&demux.cond, &demux.lock, mdate() + CLOCK_FREQ / 20);
 472         vlc_mutex_unlock(&demux.lock);
 473         break;
 474     case AbstractStream::status_discontinuity:
 475         vlc_mutex_lock(&demux.lock);
 476         demux.i_nzpcr = VLC_TS_INVALID;
 477         demux.i_firstpcr = VLC_TS_INVALID;
 478         es_out_Control(p_demux->out, ES_OUT_RESET_PCR);
 479         vlc_mutex_unlock(&demux.lock);
 480         break;
 481     case AbstractStream::status_demuxed:
 482         vlc_mutex_lock(&demux.lock);
 483         if( demux.i_nzpcr != VLC_TS_INVALID && i_nzbarrier != demux.i_nzpcr )
 484         {
 485             demux.i_nzpcr = i_nzbarrier;
 486             mtime_t pcr = VLC_TS_0 + std::max(INT64_C(0), demux.i_nzpcr - CLOCK_FREQ / 10);
 487             es_out_Control(p_demux->out, ES_OUT_SET_GROUP_PCR, 0, pcr);
 488         }
 489         vlc_mutex_unlock(&demux.lock);
 490         break;
 491     }
 492
 493     return VLC_DEMUXER_SUCCESS;
 494 }
 495
 496 int PlaylistManager::control_callback(demux_t *p_demux, int i_query, va_list args)
 497 {
 498     PlaylistManager *manager = reinterpret_cast<PlaylistManager *>(p_demux->p_sys);
 499     return manager->doControl(i_query, args);
 500 }
 501
 502 int PlaylistManager::doControl(int i_query, va_list args)
 503 {
 504     switch (i_query)
 505     {
 506         case DEMUX_CAN_SEEK:
 507         {
 508             vlc_mutex_locker locker(&cached.lock);
 509             *(va_arg (args, bool *)) = ! cached.b_live;
 510             break;
 511         }
 512
 513         case DEMUX_CAN_CONTROL_PACE:
 514             *(va_arg (args, bool *)) = true;
 515             break;
 516
 517         case DEMUX_CAN_PAUSE:
 518         {
 519             /* Always return true then fail late.
 520              * See demux.c/demux_vaControl,
 521              * misleading and should be DEMUX_CAN_CONTROL_PAUSE */
 522             *(va_arg (args, bool *)) = true;
 523             break;
 524         }
 525
 526         case DEMUX_SET_PAUSE_STATE:
 527         {
 528             vlc_mutex_locker locker(&cached.lock);
 529             return cached.b_live ? VLC_EGENERIC : VLC_SUCCESS;
 530         }
 531
 532         case DEMUX_GET_TIME:
 533         {
 534             vlc_mutex_locker locker(&cached.lock);
 535             *(va_arg (args, int64_t *)) = cached.i_time;
 536             break;
 537         }
 538
 539         case DEMUX_GET_LENGTH:
 540         {
 541             vlc_mutex_locker locker(&cached.lock);
 542             if(cached.b_live)
 543                 return VLC_EGENERIC;
 544             *(va_arg (args, int64_t *)) = cached.i_length;
 545             break;
 546         }
 547
 548         case DEMUX_GET_POSITION:
 549         {
 550             vlc_mutex_locker locker(&cached.lock);
 551             if(cached.b_live)
 552                 return VLC_EGENERIC;
 553             *(va_arg (args, double *)) = cached.f_position;
 554             break;
 555         }
 556
 557         case DEMUX_SET_POSITION:
 558         {
 559             setBufferingRunState(false); /* stop downloader first */
 560
 561             const mtime_t i_duration = getDuration();
 562             if(i_duration == 0) /* == playlist->isLive() */
 563             {
 564                 setBufferingRunState(true);
 565                 return VLC_EGENERIC;
 566             }
 567
 568             int64_t time = i_duration * va_arg(args, double);
 569             time += getFirstPlaybackTime();
 570
 571             if(!setPosition(time))
 572             {
 573                 setBufferingRunState(true);
 574                 return VLC_EGENERIC;
 575             }
 576
 577             demux.i_nzpcr = VLC_TS_INVALID;
 578             setBufferingRunState(true);
 579             break;
 580         }
 581
 582         case DEMUX_SET_TIME:
 583         {
 584             setBufferingRunState(false); /* stop downloader first */
 585             if(playlist->isLive())
 586             {
 587                 setBufferingRunState(true);
 588                 return VLC_EGENERIC;
 589             }
 590
 591             int64_t time = va_arg(args, int64_t);// + getFirstPlaybackTime();
 592             if(!setPosition(time))
 593             {
 594                 setBufferingRunState(true);
 595                 return VLC_EGENERIC;
 596             }
 597
 598             demux.i_nzpcr = VLC_TS_INVALID;
 599             setBufferingRunState(true);
 600             break;
 601         }
 602
 603         case DEMUX_GET_PTS_DELAY:
 604             *va_arg (args, int64_t *) = 1000 * INT64_C(1000);
 605             break;
 606
 607         default:
 608             return VLC_EGENERIC;
 609     }
 610     return VLC_SUCCESS;
 611 }
 612
 613 void PlaylistManager::setBufferingRunState(bool b)
 614 {
 615     vlc_mutex_lock(&lock);
 616     b_buffering = b;
 617     vlc_cond_signal(&waitcond);
 618     vlc_mutex_unlock(&lock);
 619 }
 620
 621 void PlaylistManager::Run()
 622 {
 623     vlc_mutex_lock(&lock);
 624     const unsigned i_min_buffering = playlist->getMinBuffering();
 625     const unsigned i_extra_buffering = playlist->getMaxBuffering() - i_min_buffering;
 626     while(1)
 627     {
 628         mutex_cleanup_push(&lock);
 629         while(!b_buffering)
 630             vlc_cond_wait(&waitcond, &lock);
 631         vlc_testcancel();
 632         vlc_cleanup_pop();
 633
 634         if(needsUpdate())
 635         {
 636             if(updatePlaylist())
 637                 scheduleNextUpdate();
 638             else
 639                 failedupdates++;
 640         }
 641
 642         vlc_mutex_lock(&demux.lock);
 643         mtime_t i_nzpcr = demux.i_nzpcr;
 644         vlc_mutex_unlock(&demux.lock);
 645
 646         int canc = vlc_savecancel();
 647         AbstractStream::buffering_status i_return = bufferize(i_nzpcr, i_min_buffering, i_extra_buffering);
 648         vlc_restorecancel( canc );
 649
 650         if(i_return != AbstractStream::buffering_lessthanmin)
 651         {
 652             mtime_t i_deadline = mdate();
 653             if(i_return == AbstractStream::buffering_ongoing)
 654                 i_deadline += (CLOCK_FREQ / 20);
 655             else if(i_return == AbstractStream::buffering_full)
 656                 i_deadline += (CLOCK_FREQ / 10);
 657             else if(i_return == AbstractStream::buffering_end)
 658                 i_deadline += (CLOCK_FREQ);
 659             else /*if(i_return == AbstractStream::buffering_suspended)*/
 660                 i_deadline += (CLOCK_FREQ / 4);
 661
 662             vlc_mutex_lock(&demux.lock);
 663             vlc_cond_signal(&demux.cond);
 664             vlc_mutex_unlock(&demux.lock);
 665
 666             mutex_cleanup_push(&lock);
 667             while(b_buffering &&
 668                     vlc_cond_timedwait(&waitcond, &lock, i_deadline) == 0 &&
 669                     i_deadline > mdate());
 670             vlc_cleanup_pop();
 671         }
 672     }
 673     vlc_mutex_unlock(&lock);
 674 }
 675
 676 void * PlaylistManager::managerThread(void *opaque)
 677 {
 678     static_cast<PlaylistManager *>(opaque)->Run();
 679     return NULL;
 680 }
 681
 682 void PlaylistManager::updateControlsPosition()
 683 {
 684     vlc_mutex_locker locker(&cached.lock);
 685     const mtime_t i_duration = cached.i_length;
 686     if(i_duration == 0)
 687     {
 688         cached.f_position = 0.0;
 689     }
 690     else
 691     {
 692         const mtime_t i_length = getCurrentPlaybackTime() - getFirstPlaybackTime();
 693         cached.f_position = (double) i_length / i_duration;
 694     }
 695
 696     mtime_t i_time = getCurrentPlaybackTime();
 697     if(!playlist->isLive())
 698         i_time -= getFirstPlaybackTime();
 699     cached.i_time = i_time;
 700 }
 701
 702 void PlaylistManager::updateControlsContentType()
 703 {
 704     vlc_mutex_locker locker(&cached.lock);
 705     if(playlist->isLive())
 706     {
 707         cached.b_live = true;
 708         cached.i_length = 0;
 709     }
 710     else
 711     {
 712         cached.b_live = false;
 713         cached.i_length = getDuration();
 714     }
 715 }
 716
 717 AbstractAdaptationLogic *PlaylistManager::createLogic(AbstractAdaptationLogic::LogicType type, AbstractConnectionManager *conn)
 718 {
 719     AbstractAdaptationLogic *logic = NULL;
 720     switch(type)
 721     {
 722         case AbstractAdaptationLogic::FixedRate:
 723         {
 724             size_t bps = var_InheritInteger(p_demux, "adaptive-bw") * 8192;
 725             logic = new (std::nothrow) FixedRateAdaptationLogic(bps);
 726             break;
 727         }
 728         case AbstractAdaptationLogic::AlwaysLowest:
 729             logic = new (std::nothrow) AlwaysLowestAdaptationLogic();
 730             break;
 731         case AbstractAdaptationLogic::AlwaysBest:
 732             logic = new (std::nothrow) AlwaysBestAdaptationLogic();
 733             break;
 734         case AbstractAdaptationLogic::RateBased:
 735         {
 736             RateBasedAdaptationLogic *ratelogic =
 737                     new (std::nothrow) RateBasedAdaptationLogic(VLC_OBJECT(p_demux));
 738             if(ratelogic)
 739                 conn->setDownloadRateObserver(ratelogic);
 740             logic = ratelogic;
 741             break;
 742         }
 743         case AbstractAdaptationLogic::Default:
 744         case AbstractAdaptationLogic::NearOptimal:
 745         {
 746             NearOptimalAdaptationLogic *noplogic =
 747                     new (std::nothrow) NearOptimalAdaptationLogic(VLC_OBJECT(p_demux));
 748             if(noplogic)
 749                 conn->setDownloadRateObserver(noplogic);
 750             logic = noplogic;
 751             break;
 752         }
 753         case AbstractAdaptationLogic::Predictive:
 754         {
 755             AbstractAdaptationLogic *predictivelogic =
 756                     new (std::nothrow) PredictiveAdaptationLogic(VLC_OBJECT(p_demux));
 757             if(predictivelogic)
 758                 conn->setDownloadRateObserver(predictivelogic);
 759             logic = predictivelogic;
 760         }
 761
 762         default:
 763             break;
 764     }
 765
 766     if(logic)
 767     {
 768         logic->setMaxDeviceResolution( var_InheritInteger(p_demux, "adaptive-maxwidth"),
 769                                        var_InheritInteger(p_demux, "adaptive-maxheight") );
 770     }
 771
 772     return logic;
 773 }