From 05c1a838c881ea502888659848d8792843b28718 Mon Sep 17 00:00:00 2001 From: Luca Muscariello Date: Sat, 25 Feb 2017 23:42:31 +0100 Subject: Initial commit: video player - viper Change-Id: Id5aa33598ce34659bad4a7a9ae5006bfb84f9bd1 Signed-off-by: Luca Muscariello --- Adaptation/AbstractAdaptationLogic.cpp | 54 +++ Adaptation/AbstractAdaptationLogic.h | 58 +++ Adaptation/AdaptationLogicFactory.cpp | 48 ++ Adaptation/AdaptationLogicFactory.h | 40 ++ Adaptation/AlwaysLowestLogic.cpp | 71 +++ Adaptation/AlwaysLowestLogic.h | 48 ++ Adaptation/Bola.cpp | 506 +++++++++++++++++++++ Adaptation/Bola.h | 118 +++++ Adaptation/BufferBasedAdaptation.cpp | 141 ++++++ Adaptation/BufferBasedAdaptation.h | 64 +++ Adaptation/BufferBasedAdaptationWithRateBased.cpp | 206 +++++++++ Adaptation/BufferBasedAdaptationWithRateBased.h | 72 +++ Adaptation/BufferBasedThreeThresholdAdaptation.cpp | 166 +++++++ Adaptation/BufferBasedThreeThresholdAdaptation.h | 69 +++ Adaptation/IAdaptationLogic.h | 115 +++++ Adaptation/Panda.cpp | 274 +++++++++++ Adaptation/Panda.h | 89 ++++ Adaptation/RateBasedAdaptation.cpp | 140 ++++++ Adaptation/RateBasedAdaptation.h | 61 +++ 19 files changed, 2340 insertions(+) create mode 100644 Adaptation/AbstractAdaptationLogic.cpp create mode 100644 Adaptation/AbstractAdaptationLogic.h create mode 100644 Adaptation/AdaptationLogicFactory.cpp create mode 100644 Adaptation/AdaptationLogicFactory.h create mode 100644 Adaptation/AlwaysLowestLogic.cpp create mode 100644 Adaptation/AlwaysLowestLogic.h create mode 100644 Adaptation/Bola.cpp create mode 100644 Adaptation/Bola.h create mode 100644 Adaptation/BufferBasedAdaptation.cpp create mode 100644 Adaptation/BufferBasedAdaptation.h create mode 100644 Adaptation/BufferBasedAdaptationWithRateBased.cpp create mode 100644 Adaptation/BufferBasedAdaptationWithRateBased.h create mode 100644 Adaptation/BufferBasedThreeThresholdAdaptation.cpp create mode 100644 Adaptation/BufferBasedThreeThresholdAdaptation.h create mode 100644 Adaptation/IAdaptationLogic.h create mode 100644 Adaptation/Panda.cpp create mode 100644 Adaptation/Panda.h create mode 100644 Adaptation/RateBasedAdaptation.cpp create mode 100644 Adaptation/RateBasedAdaptation.h (limited to 'Adaptation') diff --git a/Adaptation/AbstractAdaptationLogic.cpp b/Adaptation/AbstractAdaptationLogic.cpp new file mode 100644 index 00000000..4f578958 --- /dev/null +++ b/Adaptation/AbstractAdaptationLogic.cpp @@ -0,0 +1,54 @@ +/* + * AbstractAdaptationLogic.cpp + ***************************************************************************** + * Copyright (C) 2012, bitmovin Softwareentwicklung OG, All Rights Reserved + * + * Email: libdash-dev@vicky.bitmovin.net + * + * This source code and its use and distribution, is subject to the terms + * and conditions of the applicable license agreement. + *****************************************************************************/ + +#include "AbstractAdaptationLogic.h" + +using namespace libdash::framework::adaptation; +using namespace dash::mpd; + +AbstractAdaptationLogic::AbstractAdaptationLogic(dash::mpd::IMPD *mpd, dash::mpd::IPeriod *period, dash::mpd::IAdaptationSet *adaptationSet, bool isVid) : + mpd (mpd), + period (period), + adaptationSet (adaptationSet), + representation (NULL), + isVideo (isVid) +{ +} + +AbstractAdaptationLogic::~AbstractAdaptationLogic() +{ +} + +uint32_t AbstractAdaptationLogic::getPosition() +{ + return 0; +} + +void AbstractAdaptationLogic::setPosition(uint32_t segmentNumber) +{ + this->segmentNumber = segmentNumber; +} + +IRepresentation* AbstractAdaptationLogic::getRepresentation() +{ + return this->representation; +} + +void AbstractAdaptationLogic::setRepresentation(IPeriod *period, IAdaptationSet *adaptationSet, IRepresentation *representation) +{ + this->period = period; + this->adaptationSet = adaptationSet; + this->representation = representation; +} + +void AbstractAdaptationLogic::dLTimeUpdate(double time) +{ +} diff --git a/Adaptation/AbstractAdaptationLogic.h b/Adaptation/AbstractAdaptationLogic.h new file mode 100644 index 00000000..24fab91d --- /dev/null +++ b/Adaptation/AbstractAdaptationLogic.h @@ -0,0 +1,58 @@ +/* + * AbstractAdaptationLogic.h + ***************************************************************************** + * Copyright (C) 2012, bitmovin Softwareentwicklung OG, All Rights Reserved + * + * Email: libdash-dev@vicky.bitmovin.net + * + * This source code and its use and distribution, is subject to the terms + * and conditions of the applicable license agreement. + *****************************************************************************/ + +#ifndef LIBDASH_FRAMEWORK_ADAPTATION_ABSTRACTADAPTATIONLOGIC_H_ +#define LIBDASH_FRAMEWORK_ADAPTATION_ABSTRACTADAPTATIONLOGIC_H_ + +#include "IAdaptationLogic.h" +#include "IMPD.h" + +namespace libdash +{ +namespace framework +{ +namespace adaptation +{ +class AbstractAdaptationLogic : public IAdaptationLogic +{ +public: + AbstractAdaptationLogic(dash::mpd::IMPD *mpd, dash::mpd::IPeriod* period, dash::mpd::IAdaptationSet *adaptationSet, bool isVideo); + virtual ~AbstractAdaptationLogic(); + + virtual uint32_t getPosition(); + virtual void setPosition(uint32_t segmentNumber); + virtual dash::mpd::IRepresentation* getRepresentation (); + virtual void setRepresentation(dash::mpd::IPeriod *period, + dash::mpd::IAdaptationSet *adaptationSet, + dash::mpd::IRepresentation *representation); + + virtual LogicType getType() = 0; + virtual bool isUserDependent() = 0; + virtual bool isRateBased() = 0; + virtual bool isBufferBased() = 0; + virtual void bitrateUpdate(uint64_t, uint32_t) = 0; + virtual void bufferUpdate(uint32_t, int) = 0; + virtual void onEOS(bool value)= 0; + virtual void dLTimeUpdate(double) = 0; + + virtual void checkedByDASHReceiver() = 0; +protected: + dash::mpd::IMPD *mpd; + dash::mpd::IPeriod *period; + dash::mpd::IAdaptationSet *adaptationSet; + dash::mpd::IRepresentation *representation; + uint32_t segmentNumber; + bool isVideo; +}; +} +} +} +#endif /* LIBDASH_FRAMEWORK_ADAPTATION_ABSTRACTADAPTATIONLOGIC_H_ */ diff --git a/Adaptation/AdaptationLogicFactory.cpp b/Adaptation/AdaptationLogicFactory.cpp new file mode 100644 index 00000000..6901a597 --- /dev/null +++ b/Adaptation/AdaptationLogicFactory.cpp @@ -0,0 +1,48 @@ +/* + * AdaptationLogicFactory.cpp + ***************************************************************************** + * Copyright (C) 2012, bitmovin Softwareentwicklung OG, All Rights Reserved + * + * Email: libdash-dev@vicky.bitmovin.net + * + * This source code and its use and distribution, is subject to the terms + * and conditions of the applicable license agreement. + *****************************************************************************/ + +#include "AdaptationLogicFactory.h" +#include + +using namespace libdash::framework::adaptation; +using namespace dash::mpd; + +IAdaptationLogic* AdaptationLogicFactory::create(LogicType logic, IMPD *mpd, IPeriod *period, IAdaptationSet *adaptationSet,bool isVid, struct AdaptationParameters* paramsForAdaptation) +{ + Debug("Adaptation Logic for %s: ", isVid ? "video" : "audio"); + switch(logic) + { + case AlwaysLowest: + Debug("Always lowest\n"); + return new AlwaysLowestLogic(mpd, period, adaptationSet, isVid, paramsForAdaptation); + case RateBased: + Debug("Rate based\n"); + return new RateBasedAdaptation(mpd,period,adaptationSet, isVid, paramsForAdaptation); + case BufferBased: + Debug("Buffer based\n"); + return new BufferBasedAdaptation(mpd,period,adaptationSet, isVid, paramsForAdaptation); + case BufferRateBased: + Debug("Buffer Rate based\n"); + return new BufferBasedAdaptationWithRateBased(mpd,period,adaptationSet, isVid, paramsForAdaptation); + case BufferBasedThreeThreshold: + Debug("Buffer based 3 threshold\n"); + return new BufferBasedThreeThresholdAdaptation(mpd,period,adaptationSet, isVid, paramsForAdaptation); + case Panda: + Debug("Panda\n"); + return new PandaAdaptation(mpd, period, adaptationSet, isVid, paramsForAdaptation); + case Bola: + Debug("Bola\n"); + return new BolaAdaptation(mpd, period, adaptationSet, isVid, paramsForAdaptation); + default: + Debug("default => return Always Lowest\n"); + return new AlwaysLowestLogic(mpd, period, adaptationSet, isVid, paramsForAdaptation); + } +} diff --git a/Adaptation/AdaptationLogicFactory.h b/Adaptation/AdaptationLogicFactory.h new file mode 100644 index 00000000..0f1616a7 --- /dev/null +++ b/Adaptation/AdaptationLogicFactory.h @@ -0,0 +1,40 @@ +/* + * AdaptationLogicFactory.h + ***************************************************************************** + * Copyright (C) 2012, bitmovin Softwareentwicklung OG, All Rights Reserved + * + * Email: libdash-dev@vicky.bitmovin.net + * + * This source code and its use and distribution, is subject to the terms + * and conditions of the applicable license agreement. + *****************************************************************************/ + +#ifndef LIBDASH_FRAMEWORK_ADAPTATION_ADAPTATIONLOGICFACTORY_H_ +#define LIBDASH_FRAMEWORK_ADAPTATION_ADAPTATIONLOGICFACTORY_H_ + +#include "IAdaptationLogic.h" +#include "AlwaysLowestLogic.h" +#include "RateBasedAdaptation.h" +#include "BufferBasedAdaptation.h" +#include "BufferBasedAdaptationWithRateBased.h" +#include "BufferBasedThreeThresholdAdaptation.h" +#include "Panda.h" +#include "Bola.h" + +namespace libdash +{ +namespace framework +{ +namespace adaptation +{ +class AdaptationLogicFactory +{ +public: + static IAdaptationLogic* create(libdash::framework::adaptation::LogicType logic, + dash::mpd::IMPD *mpd, dash::mpd::IPeriod *period, dash::mpd::IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params); +}; +} +} +} + +#endif /* LIBDASH_FRAMEWORK_ADAPTATION_ADAPTATIONLOGICFACTORY_H_ */ diff --git a/Adaptation/AlwaysLowestLogic.cpp b/Adaptation/AlwaysLowestLogic.cpp new file mode 100644 index 00000000..54409bfd --- /dev/null +++ b/Adaptation/AlwaysLowestLogic.cpp @@ -0,0 +1,71 @@ +/* + * AlwaysLowestLogic.cpp + ***************************************************************************** + * Copyright (C) 2012, bitmovin Softwareentwicklung OG, All Rights Reserved + * + * Email: libdash-dev@vicky.bitmovin.net + * + * This source code and its use and distribution, is subject to the terms + * and conditions of the applicable license agreement. + *****************************************************************************/ + +#include "AlwaysLowestLogic.h" +#include + +using namespace libdash::framework::adaptation; +using namespace libdash::framework::input; +using namespace dash::mpd; + +AlwaysLowestLogic::AlwaysLowestLogic(IMPD *mpd, IPeriod *period, IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params) : + AbstractAdaptationLogic(mpd, period, adaptationSet, isVid) +{ + this->representation = this->adaptationSet->GetRepresentation().at(0); +} + +AlwaysLowestLogic::~AlwaysLowestLogic() +{ +} + +LogicType AlwaysLowestLogic::getType() +{ + return adaptation::AlwaysLowest; +} + +bool AlwaysLowestLogic::isUserDependent() +{ + return false; +} + +bool AlwaysLowestLogic::isRateBased() +{ + return false; +} + +bool AlwaysLowestLogic::isBufferBased() +{ + return false; +} + +void AlwaysLowestLogic::bitrateUpdate(uint64_t bps, uint32_t segNum) +{ +} + +void AlwaysLowestLogic::bufferUpdate(uint32_t bufferfill, int maxC) +{ +} + +void AlwaysLowestLogic::setMultimediaManager(viper::managers::IMultimediaManagerBase *mmM) +{ +} + +void AlwaysLowestLogic::onEOS(bool value) +{ +} + +void AlwaysLowestLogic::dLTimeUpdate(double time) +{ +} + +void AlwaysLowestLogic::checkedByDASHReceiver() +{ +} diff --git a/Adaptation/AlwaysLowestLogic.h b/Adaptation/AlwaysLowestLogic.h new file mode 100644 index 00000000..782a8b29 --- /dev/null +++ b/Adaptation/AlwaysLowestLogic.h @@ -0,0 +1,48 @@ +/* + * AlwaysLowestLogic.h + ***************************************************************************** + * Copyright (C) 2012, bitmovin Softwareentwicklung OG, All Rights Reserved + * + * Email: libdash-dev@vicky.bitmovin.net + * + * This source code and its use and distribution, is subject to the terms + * and conditions of the applicable license agreement. + *****************************************************************************/ + +#ifndef LIBDASH_FRAMEWORK_ADAPTATION_ALWAYSLOWESTLOGIC_H_ +#define LIBDASH_FRAMEWORK_ADAPTATION_ALWAYSLOWESTLOGIC_H_ + +#include "IMPD.h" +#include "AbstractAdaptationLogic.h" + +namespace libdash +{ +namespace framework +{ +namespace adaptation +{ +class AlwaysLowestLogic : public AbstractAdaptationLogic +{ +public: + AlwaysLowestLogic(dash::mpd::IMPD *mpd, dash::mpd::IPeriod *period, dash::mpd::IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params); + virtual ~AlwaysLowestLogic(); + + virtual LogicType getType(); + virtual bool isUserDependent(); + virtual bool isRateBased(); + virtual bool isBufferBased(); + virtual void bitrateUpdate(uint64_t, uint32_t); + virtual void dLTimeUpdate(double time); + virtual void bufferUpdate(uint32_t, int); + virtual void setMultimediaManager(viper::managers::IMultimediaManagerBase *mmM); + virtual void onEOS(bool value); + virtual void checkedByDASHReceiver(); +private: + + +}; +} +} +} + +#endif /* LIBDASH_FRAMEWORK_ADAPTATION_ALWAYSLOWESTLOGIC_H_ */ diff --git a/Adaptation/Bola.cpp b/Adaptation/Bola.cpp new file mode 100644 index 00000000..6477e0f5 --- /dev/null +++ b/Adaptation/Bola.cpp @@ -0,0 +1,506 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "Bola.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +const double MINIMUM_BUFFER_LEVEL_SPACING = 5.0; // The minimum space required between buffer levels (in seconds). +const uint32_t THROUGHPUT_SAMPLES = 3; // Number of samples considered for throughput estimate. +const double SAFETY_FACTOR = 0.9; // Safety factor used with bandwidth estimate. + +using namespace dash::mpd; +using namespace libdash::framework::adaptation; +using namespace libdash::framework::input; +using namespace libdash::framework::mpd; + +using std::bind; +using std::placeholders::_1; +using std::placeholders::_2; + + +using duration_in_seconds = std::chrono::duration >; + +BolaAdaptation::BolaAdaptation(IMPD *mpd, IPeriod *period, IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params) : + AbstractAdaptationLogic (mpd, period, adaptationSet, isVid) +{ + this->bufferMaxSizeSeconds =(double) params->segmentBufferSize * params->segmentDuration; + this->alphaRate = params->Bola_Alpha; + this->bufferTargetSeconds = params->Bola_bufferTargetSeconds; + + // Set Bola init STATE + this->initState = true; + this->bolaState = STARTUP; + + this->lastDownloadTimeInstant = 0.0; + this->currentDownloadTimeInstant = 0.0; + //this->lastSegmentDownloadTime = 0.0; + this->currentQuality = 0; + + this->bufferTargetPerc = (uint32_t) ( round(this->bufferTargetSeconds / this->bufferMaxSizeSeconds)*100 ); + + /// Retrieve available bitrates + std::vector representations = this->adaptationSet->GetRepresentation(); + + this->availableBitrates.clear(); + Debug("BOLA Available Bitrates...\n"); + for(size_t i = 0; i < representations.size(); i++) + { + this->availableBitrates.push_back((uint64_t)(representations.at(i)->GetBandwidth())); + Debug("%d - %I64u bps\n", i+1, this->availableBitrates[i]); + } + // Check if they are in increasing order (i.e., bitrate[0] <= bitrate[1], etc.) + + this->bitrateCount = this->availableBitrates.size(); + + // We check if we have only one birate value or if the bitrate list is irregular (i.e., it is not strictly increasing) + if (this->bitrateCount < 2 || this->availableBitrates[0] >= this->availableBitrates[1] || this->availableBitrates[this->bitrateCount - 2] >= this->availableBitrates[this->bitrateCount - 1]) { + this->bolaState = ONE_BITRATE; + // return 0; // Check if exit with a message is necessary + } + + // Check if the following is correct + this->totalDuration = TimeResolver::getDurationInSec(this->mpd->GetMediaPresentationDuration()); +// this->segmentDuration = (double) (representations.at(0)->GetSegmentTemplate()->GetDuration() / representations.at(0)->GetSegmentTemplate()->GetTimescale() ); + this->segmentDuration = 2.0; + Debug("Total Duration - BOLA:\t%f\nSegment Duration - BOLA:\t%f\n",this->totalDuration, this->segmentDuration); + // if not correct --> segmentDuration = 2.0; + + // Compute the BOLA Buffer Target + this->bolaBufferTargetSeconds = this->bufferTargetSeconds; + if (this->bolaBufferTargetSeconds < this->segmentDuration + MINIMUM_BUFFER_LEVEL_SPACING) + { + this->bolaBufferTargetSeconds = this->segmentDuration + MINIMUM_BUFFER_LEVEL_SPACING; + } + Debug("BOLA Buffer Target Seconds:\t%f\n",this->bolaBufferTargetSeconds); + + // Compute UTILTY vector, Vp, and gp + Debug("BOLA Utility Values...\n"); + for (uint32_t i = 0; i < this->bitrateCount; ++i) { + this->utilityVector.push_back( log(((double)this->availableBitrates[i] * (1./(double)this->availableBitrates[0])))); + Debug("%d - %f\n", i+1, this->utilityVector[i]); + } + + this->Vp = (this->bolaBufferTargetSeconds - this->segmentDuration) / this->utilityVector[this->bitrateCount - 1]; + this->gp = 1.0 + this->utilityVector[this->bitrateCount - 1] / (this->bolaBufferTargetSeconds / this->segmentDuration - 1.0); + + Debug("BOLA Parameters:\tVp: %f\tgp: %f\n",this->Vp, this->gp); + /* If bufferTargetSeconds (not bolaBufferTargetSecond) is large enough, we might guarantee that Bola will never rebuffer + * unless the network bandwidth drops below the lowest encoded bitrate level. For this to work, Bola needs to use the real buffer + * level without the additional virtualBuffer. Also, for this to work efficiently, we need to make sure that if the buffer level + * drops to one fragment during a download, the current download does not have more bits remaining than the size of one fragment + * at the lowest quality*/ + + this->maxRtt = 0.2; // Is this reasonable? + if(this->bolaBufferTargetSeconds == this->bufferTargetSeconds) { + this->safetyGuarantee = true; + } + if (this->safetyGuarantee) { + Debug("BOLA SafetyGuarantee...\n"); + // we might need to adjust Vp and gp + double VpNew = this->Vp; + double gpNew = this->gp; + for (uint32_t i = 1; i < this->bitrateCount; ++i) { + double threshold = VpNew * (gpNew - this->availableBitrates[0] * this->utilityVector[i] / (this->availableBitrates[i] - this->availableBitrates[0])); + double minThreshold = this->segmentDuration * (2.0 - this->availableBitrates[0] / this->availableBitrates[i]) + maxRtt; + if (minThreshold >= this->bufferTargetSeconds) { + safetyGuarantee = false; + break; + } + if (threshold < minThreshold) { + VpNew = VpNew * (this->bufferTargetSeconds - minThreshold) / (this->bufferTargetSeconds - threshold); + gpNew = minThreshold / VpNew + this->utilityVector[i] * this->availableBitrates[0] / (this->availableBitrates[i] - this->availableBitrates[0]); + } + } + if (safetyGuarantee && (this->bufferTargetSeconds - this->segmentDuration) * VpNew / this->Vp < MINIMUM_BUFFER_LEVEL_SPACING) { + safetyGuarantee = false; + } + if (safetyGuarantee) { + this->Vp = VpNew; + this->gp = gpNew; + } + } + + Debug("BOLA New Parameters:\tVp: %f\tgp: %f\n",this->Vp, this->gp); + + // Capping of the virtual buffer (when using it) + this->bolaBufferMaxSeconds = this->Vp * (this->utilityVector[this->bitrateCount - 1] + this->gp); + Debug("BOLA Max Buffer Seconds:\t%f\n",this->bolaBufferMaxSeconds); + + this->virtualBuffer = 0.0; // Check if we should use either the virtualBuffer or the safetyGuarantee + + this->instantBw = 0; + this->averageBw = 0; + this->batchBw = 0; // Computed every THROUGHPUT_SAMPLES samples (average) + this->batchBwCount = 0; + + this->multimediaManager = NULL; + this->lastBufferFill = 0; // (?) + this->bufferEOS = false; + this->shouldAbort = false; + this->isCheckedForReceiver = false; + + this->representation = representations.at(0); + this->currentBitrate = (uint64_t) this->representation->GetBandwidth(); + + Debug("BOLA Init Params - \tAlpha: %f \t BufferTarget: %f\n",this->alphaRate, this->bufferTargetSeconds); + Debug("BOLA Init Current BitRate - %I64u\n",this->currentBitrate); + Debug("Buffer Adaptation BOLA: STARTED\n"); +} + +BolaAdaptation::~BolaAdaptation() +{ +} + +LogicType BolaAdaptation::getType() +{ + return adaptation::BufferBased; +} + +bool BolaAdaptation::isUserDependent() +{ + return false; +} + +bool BolaAdaptation::isRateBased() +{ + return true; +} +bool BolaAdaptation::isBufferBased() +{ + return true; +} + +void BolaAdaptation::setMultimediaManager(viper::managers::IMultimediaManagerBase *_mmManager) +{ + this->multimediaManager = _mmManager; +} + +void BolaAdaptation::notifyBitrateChange() +{ + if(this->multimediaManager) + if(this->multimediaManager->isStarted() && !this->multimediaManager->isStopping()) + if(this->isVideo) + this->multimediaManager->setVideoQuality(this->period, this->adaptationSet, this->representation); + else + this->multimediaManager->setAudioQuality(this->period, this->adaptationSet, this->representation); + //Should Abort is done here to avoid race condition with DASHReceiver::DoBuffering() + if(this->shouldAbort) + { + this->multimediaManager->shouldAbort(this->isVideo); + } + this->shouldAbort = false; +} + +uint64_t BolaAdaptation::getBitrate() +{ + return this->currentBitrate; +} + +int BolaAdaptation::getQualityFromThroughput(uint64_t bps) { + int q = 0; + for (int i = 0; i < this->availableBitrates.size(); ++i) { + if (this->availableBitrates[i] > bps) { + break; + } + q = i; + } + return q; +} + +int BolaAdaptation::getQualityFromBufferLevel(double bufferLevelSec) { + int quality = this->bitrateCount - 1; + double score = 0.0; + for (int i = 0; i < this->bitrateCount; ++i) { + double s = (this->utilityVector[i] + this->gp - bufferLevelSec / this->Vp) / this->availableBitrates[i]; + if (s > score) { + score = s; + quality = i; + } + } + return quality; +} + +void BolaAdaptation::setBitrate(uint32_t bufferFill) +{ + // *** NB *** Insert Log messages + + if(this->initState) + { + this->initState = false; + + if(this->bolaState != ONE_BITRATE) + { + if(this->batchBw != 0) // Check the current estimated throughput (batch mean) + this->currentQuality = getQualityFromThroughput(this->batchBw*SAFETY_FACTOR); + //else --> quality unchanged + } + //this->representation = this->availableBitrates[this->currentQuality]; + //this->currentBitrate = (uint64_t) this->representation->GetBandwidth(); + this->representation = this->adaptationSet->GetRepresentation().at(this->currentQuality); + this->currentBitrate = (uint64_t) this->availableBitrates[this->currentQuality]; + Debug("INIT - Current Bitrate:\t%I64u\n", this->currentBitrate); + Debug("ADAPTATION_LOGIC:\tFor %s:\tlast_buffer: %f\tbuffer_level: %f, instantaneousBw: %lu, AverageBW: %lu, choice: %d\n",isVideo ? "video" : "audio",(double)lastBufferFill/100 , (double)bufferFill/100, this->instantBw, this->averageBw , this->currentQuality); + this->lastBufferFill = bufferFill; + return; + } + + if(this->bolaState == ONE_BITRATE) { + this->currentQuality = 0; + //this->representation = this->availableBitrates[this->currentQuality]; + //this->currentBitrate = (uint64_t) this->representation->GetBandwidth(); + this->representation = this->adaptationSet->GetRepresentation().at(this->currentQuality); + this->currentBitrate = (uint64_t) this->availableBitrates[this->currentQuality]; + Debug("ONE BITRATE - Current Bitrate:\t%I64u\n", this->currentBitrate); + Debug("ADAPTATION_LOGIC:\tFor %s:\tlast_buffer: %f\tbuffer_level: %f, instantaneousBw: %lu, AverageBW: %lu, choice: %d\n",isVideo ? "video" : "audio",(double)lastBufferFill/100 , (double)bufferFill/100, this->instantBw, this->averageBw , this->currentQuality); + this->lastBufferFill = bufferFill; + return; + } + + // Obtain bufferFill in seconds; + double bufferLevelSeconds = (double)( (bufferFill * this->bufferMaxSizeSeconds) *1./100); + int bolaQuality = getQualityFromBufferLevel(bufferLevelSeconds); + + Debug("REGULAR - Buffer Level Seconds:\t%f; Bola Quality:\t%d\n", bufferLevelSeconds, bolaQuality); + + + if (bufferLevelSeconds <= 0.1) { + // rebuffering occurred, reset virtual buffer + this->virtualBuffer = 0.0; + } + + // We check if the safetyGuarantee should be used. if not, we use the virtual buffer + // STILL NOT COMPLETE; Find a way to retrieved time since the last download + if (!this->safetyGuarantee) // we can use virtualBuffer + { + // find out if there was delay because of lack of availability or because bolaBufferTarget > bufferTarget + // TODO + //double timeSinceLastDownload = getDelayFromLastFragmentInSeconds(); // Define function + double timeSinceLastDownload = this->currentDownloadTimeInstant - this->lastDownloadTimeInstant; + + Debug("VirtualBuffer - Time Since Last Download:\t%f\n", timeSinceLastDownload); + + if (timeSinceLastDownload > 0.0) { + this->virtualBuffer += timeSinceLastDownload; + } + if ( (bufferLevelSeconds + this->virtualBuffer) > this->bolaBufferMaxSeconds) { + this->virtualBuffer = this->bolaBufferMaxSeconds - bufferLevelSeconds; + } + if (this->virtualBuffer < 0.0) { + this->virtualBuffer = 0.0; + } + + Debug("VirtualBuffer - Virtual Buffer Value:\t%f\n", this->virtualBuffer); + + // Update currentDownloadTimeInstant + this->lastDownloadTimeInstant = this->currentDownloadTimeInstant; + + // Update bolaQuality using virtualBuffer: bufferLevel might be artificially low because of lack of availability + + int bolaQualityVirtual = getQualityFromBufferLevel(bufferLevelSeconds + this->virtualBuffer); + Debug("VirtualBuffer - Bola Quality Virtual:\t%d\n", bolaQualityVirtual); + if (bolaQualityVirtual > bolaQuality) { + // May use quality higher than that indicated by real buffer level. + // In this case, make sure there is enough throughput to download a fragment before real buffer runs out. + int maxQuality = bolaQuality; + while (maxQuality < bolaQualityVirtual && (this->availableBitrates[maxQuality + 1] * this->segmentDuration) / (this->currentBitrate * SAFETY_FACTOR) < bufferLevelSeconds) + { + ++maxQuality; + } + // TODO: maybe we can use a more conservative level here, but this should be OK + Debug("VirtualBuffer - Bola Quality Virtual HIGHER than Bola Quality - Max Quality:\t%d\n", maxQuality); + if (maxQuality > bolaQuality) + { + // We can (and will) download at a quality higher than that indicated by real buffer level. + if (bolaQualityVirtual <= maxQuality) { + // we can download fragment indicated by real+virtual buffer without rebuffering + bolaQuality = bolaQualityVirtual; + } else { + // downloading fragment indicated by real+virtual rebuffers, use lower quality + bolaQuality = maxQuality; + // deflate virtual buffer to match quality + double targetBufferLevel = this->Vp * (this->gp + this->utilityVector[bolaQuality]); + if (bufferLevelSeconds + this->virtualBuffer > targetBufferLevel) { + this->virtualBuffer = targetBufferLevel - bufferLevelSeconds; + if (this->virtualBuffer < 0.0) { // should be false + this->virtualBuffer = 0.0; + } + } + } + } + } + } + + + if (this->bolaState == STARTUP || this->bolaState == STARTUP_NO_INC) { + // in startup phase, use some throughput estimation + + int quality = getQualityFromThroughput(this->batchBw*SAFETY_FACTOR); + + if (this->batchBw <= 0.0) { + // something went wrong - go to steady state + this->bolaState = STEADY; + } + if (this->bolaState == STARTUP && quality < this->currentQuality) { + // Since the quality is decreasing during startup, it will not be allowed to increase again. + this->bolaState = STARTUP_NO_INC; + } + if (this->bolaState == STARTUP_NO_INC && quality > this->currentQuality) { + // In this state the quality is not allowed to increase until steady state. + quality = this->currentQuality; + } + if (quality <= bolaQuality) { + // Since the buffer is full enough for steady state operation to match startup operation, switch over to steady state. + this->bolaState = STEADY; + } + if (this->bolaState != STEADY) { + // still in startup mode + this->currentQuality = quality; + //this->representation = this->availableBitrates[this->currentQuality]; + //this->currentBitrate = (uint64_t) this->representation->GetBandwidth(); + this->representation = this->adaptationSet->GetRepresentation().at(this->currentQuality); + this->currentBitrate = (uint64_t) this->availableBitrates[this->currentQuality]; + Debug("STILL IN STARTUP - Current Bitrate:\t%I64u\n", this->currentBitrate); + Debug("ADAPTATION_LOGIC:\tFor %s:\tlast_buffer: %f\tbuffer_level: %f, instantaneousBw: %lu, AverageBW: %lu, choice: %d\n",isVideo ? "video" : "audio",(double)lastBufferFill/100 , (double)bufferFill/100, this->instantBw, this->averageBw , this->currentQuality); + this->lastBufferFill = bufferFill; + return; + } + } + + // Steady State + + // In order to avoid oscillation, the "BOLA-O" variant is implemented. + // When network bandwidth lies between two encoded bitrate levels, stick to the lowest one. + double delaySeconds = 0.0; + if (bolaQuality > this->currentQuality) { + Debug("STEADY -- BOLA QUALITY:\t%d - HIGHER than - CURRENT QUALITY:\t%I64u\n", bolaQuality, this->currentBitrate); + // do not multiply throughput by bandwidthSafetyFactor here; + // we are not using throughput estimation but capping bitrate to avoid oscillations + int quality = getQualityFromThroughput(this->batchBw); + if (bolaQuality > quality) { + // only intervene if we are trying to *increase* quality to an *unsustainable* level + if (quality < this->currentQuality) { + // The aim is only to avoid oscillations - do not drop below current quality + quality = this->currentQuality; + } else { + // We are dropping to an encoded bitrate which is a little less than the network bandwidth + // since bitrate levels are discrete. Quality 'quality' might lead to buffer inflation, + // so we deflate the buffer to the level that 'quality' gives positive utility. + double targetBufferLevel = this->Vp * (this->utilityVector[quality] + this->gp); + delaySeconds = bufferLevelSeconds - targetBufferLevel; + } + bolaQuality = quality; + } + } + + if (delaySeconds > 0.0) { + // first reduce virtual buffer + if (delaySeconds > this->virtualBuffer) { + delaySeconds -= this->virtualBuffer; + this->virtualBuffer = 0.0; + } else { + this->virtualBuffer -= delaySeconds; + delaySeconds = 0.0; + } + } + if (delaySeconds > 0.0) { + // TODO Check the scope of this function. Is it a delayed request? + // streamProcessor.getScheduleController().setTimeToLoadDelay(1000.0 * delaySeconds); + // NEED TO CHECK THIS + Debug("STEADY -- DELAY DOWNLOAD OF:\t%f\n", delaySeconds); + this->multimediaManager->setTargetDownloadingTime(this->isVideo, delaySeconds); + } + + this->currentQuality = bolaQuality; + //this->representation = this->availableBitrates[this->currentQuality]; + this->representation = this->adaptationSet->GetRepresentation().at(this->currentQuality); + this->currentBitrate = (uint64_t) this->availableBitrates[this->currentQuality]; + Debug("STEADY - Current Bitrate:\t%I64u\n", this->currentBitrate); + Debug("ADAPTATION_LOGIC:\tFor %s:\tlast_buffer: %f\tbuffer_level: %f, instantaneousBw: %lu, AverageBW: %lu, choice: %d\n",isVideo ? "video" : "audio",(double)lastBufferFill/100 , (double)bufferFill/100, this->instantBw, this->averageBw , this->currentQuality); + this->lastBufferFill = bufferFill; +} + +void BolaAdaptation::bitrateUpdate(uint64_t bps, uint32_t segNum) +{ + this->instantBw = bps; + + // Avg bandwidth estimate with EWMA + if(this->averageBw == 0) + { + this->averageBw = bps; + } + else + { + this->averageBw = this->alphaRate*this->averageBw + (1 - this->alphaRate)*bps; + } + + // Avg bandwidth estimate with batch mean of THROUGHPUT_SAMPLES sample + this->batchBwCount++; + this->batchBwSamples.push_back(bps); + + if(this->batchBwCount++ == THROUGHPUT_SAMPLES) + { + for(int i=0; ibatchBw += this->batchBwSamples[i]; + + this->batchBw /= THROUGHPUT_SAMPLES; + + Debug("BATCH BW:\t%I64u\n", this->batchBw); + + this->batchBwCount=0; + this->batchBwSamples.clear(); + } +} + +void BolaAdaptation::dLTimeUpdate(double time) +{ + auto m_now = std::chrono::system_clock::now(); + auto m_now_sec = std::chrono::time_point_cast(m_now); + + auto now_value = m_now_sec.time_since_epoch(); + double dl_instant = now_value.count(); + //this->lastSegmentDownloadTime = time; + //this->currentDownloadTimeInstant = std::chrono::duration_cast(system_clock::now()).count(); + this->currentDownloadTimeInstant = dl_instant; +} + +void BolaAdaptation::onEOS(bool value) +{ + this->bufferEOS = value; +} + +void BolaAdaptation::checkedByDASHReceiver() +{ + this->isCheckedForReceiver = false; +} +void BolaAdaptation::bufferUpdate(uint32_t bufferFill, int maxC) +{ + this->setBitrate(bufferFill); + this->notifyBitrateChange(); +} diff --git a/Adaptation/Bola.h b/Adaptation/Bola.h new file mode 100644 index 00000000..29011664 --- /dev/null +++ b/Adaptation/Bola.h @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LIBDASH_FRAMEWORK_ADAPTATION_BOLA_H_ +#define LIBDASH_FRAMEWORK_ADAPTATION_BOLA_H_ + +#include "AbstractAdaptationLogic.h" +#include "../MPD/AdaptationSetStream.h" +#include "../Input/IDASHReceiverObserver.h" + +namespace libdash +{ +namespace framework +{ +namespace adaptation +{ +class BolaAdaptation : public AbstractAdaptationLogic +{ +public: + BolaAdaptation (dash::mpd::IMPD *mpd, dash::mpd::IPeriod *period, dash::mpd::IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params); + virtual ~BolaAdaptation(); + + virtual LogicType getType(); + virtual bool isUserDependent(); + virtual bool isRateBased(); + virtual bool isBufferBased(); + virtual void bitrateUpdate(uint64_t bps, uint32_t segNum); + virtual void dLTimeUpdate(double time); + virtual void bufferUpdate(uint32_t bufferFill, int maxC); + void setBitrate(uint32_t bufferFill); + uint64_t getBitrate(); + virtual void setMultimediaManager(viper::managers::IMultimediaManagerBase *_mmManager); + void notifyBitrateChange(); + void onEOS(bool value); + void checkedByDASHReceiver(); + + int getQualityFromThroughput(uint64_t bps); + int getQualityFromBufferLevel(double bufferLevelSec); + +private: + enum BolaState + { + ONE_BITRATE, // If one bitrate (or init failed), always NO_CHANGE + STARTUP, // Download fragments at most recently measured throughput + STARTUP_NO_INC, // If quality increased then decreased during startup, then quality cannot be increased. + STEADY // The buffer is primed (should be above bufferTarget) + }; + + bool initState; + double bufferMaxSizeSeconds; // Usually set to 30s + double bufferTargetSeconds; // It is passed as an init parameter. + // It states the difference between STARTUP and STEADY + // 12s following dash.js implementation + + double bolaBufferTargetSeconds; // BOLA introduces a virtual buffer level in order to make quality decisions + // as it was filled (instead of the actual bufferTargetSeconds) + + double bolaBufferMaxSeconds; // When using the virtual buffer, it must be capped. + + uint32_t bufferTargetPerc; // Computed considering a bufferSize = 30s + double totalDuration; // Total video duration in seconds (taken from MPD) + double segmentDuration; // Segment duration in seconds + + std::vector availableBitrates; + std::vector utilityVector; + uint32_t bitrateCount; // Number of available bitrates + BolaState bolaState; // Keeps track of Bola state + + // Bola Vp and gp (multiplied by the segment duration 'p') + // They are dimensioned such that log utility would always prefer + // - the lowest bitrate when bufferLevel = segmentDuration + // - the highest bitrate when bufferLevel = bufferTarget + double Vp; + double gp; + + bool safetyGuarantee; + double maxRtt; + + double virtualBuffer; + + uint64_t currentBitrate; + int currentQuality; + uint64_t batchBw; + int batchBwCount; + std::vector batchBwSamples; + uint64_t instantBw; + uint64_t averageBw; + + double lastDownloadTimeInstant; + double currentDownloadTimeInstant; + double lastSegmentDownloadTime; + + uint32_t lastBufferFill; + bool bufferEOS; + bool shouldAbort; + double alphaRate; + bool isCheckedForReceiver; + + viper::managers::IMultimediaManagerBase *multimediaManager; + dash::mpd::IRepresentation *representation; +}; +} +} +} + +#endif /* LIBDASH_FRAMEWORK_ADAPTATION_BOLA_H_ */ diff --git a/Adaptation/BufferBasedAdaptation.cpp b/Adaptation/BufferBasedAdaptation.cpp new file mode 100644 index 00000000..18d4a592 --- /dev/null +++ b/Adaptation/BufferBasedAdaptation.cpp @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "BufferBasedAdaptation.h" +#include + + +using namespace dash::mpd; +using namespace libdash::framework::adaptation; +using namespace libdash::framework::input; +using namespace libdash::framework::mpd; + +BufferBasedAdaptation::BufferBasedAdaptation (IMPD *mpd, IPeriod *period, IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params) : + AbstractAdaptationLogic (mpd, period, adaptationSet, isVid) +{ + this->reservoirThreshold = params->BufferBased_reservoirThreshold; + this->maxThreshold = params->BufferBased_maxThreshold; + + std::vector representations = this->adaptationSet->GetRepresentation(); + + this->representation = this->adaptationSet->GetRepresentation().at(0); + this->multimediaManager = NULL; + this->lastBufferFill = 0; + this->bufferEOS = false; + this->shouldAbort = false; + Debug("BufferBasedParams:\t%f\t%f\n", (double)reservoirThreshold/100, (double)maxThreshold/100); + Debug("Buffer Adaptation: STARTED\n"); +} + +BufferBasedAdaptation::~BufferBasedAdaptation () +{ +} + +LogicType BufferBasedAdaptation::getType() +{ + return adaptation::BufferBased; +} + +bool BufferBasedAdaptation::isUserDependent() +{ + return false; +} + +bool BufferBasedAdaptation::isRateBased() +{ + return false; +} +bool BufferBasedAdaptation::isBufferBased() +{ + return true; +} + +void BufferBasedAdaptation::setMultimediaManager (viper::managers::IMultimediaManagerBase *_mmManager) +{ + this->multimediaManager = _mmManager; +} + +void BufferBasedAdaptation::notifyBitrateChange() +{ + if(this->multimediaManager) + if(this->multimediaManager->isStarted() && !this->multimediaManager->isStopping()) + if(this->isVideo) + this->multimediaManager->setVideoQuality(this->period, this->adaptationSet, this->representation); + else + this->multimediaManager->setAudioQuality(this->period, this->adaptationSet, this->representation); + + if(this->shouldAbort) + { + this->multimediaManager->shouldAbort(this->isVideo); + } + this->shouldAbort = false; +} + +uint64_t BufferBasedAdaptation::getBitrate() +{ + return this->currentBitrate; +} + +void BufferBasedAdaptation::setBitrate(uint32_t bufferFill) +{ + std::vector representations; + representations = this->adaptationSet->GetRepresentation(); + size_t i = 0; + + if(representations.size() == 1) + { + i = 0; + } + else + { + while(bufferFill > this->reservoirThreshold + i * (this->maxThreshold - this->reservoirThreshold)/(representations.size()-1)) + { + i++; + } + } + if((size_t)i >= (size_t)(representations.size())) + i = representations.size() - 1; + this->representation = representations.at(i); + if( 0 && !this->bufferEOS && this->lastBufferFill > this->reservoirThreshold && bufferFill <= this->reservoirThreshold) + { + this->shouldAbort = true; + } + Debug("ADAPTATION_LOGIC:\tFor %s:\tlast_buffer: %f\tbuffer_level: %f, choice: %lu, should_trigger_abort: %s\n",isVideo ? "video" : "audio",(double)lastBufferFill/100 , (double)bufferFill/100, i, this->shouldAbort ? "YES" : "NO"); + this->lastBufferFill = bufferFill; + +} + +void BufferBasedAdaptation::bitrateUpdate(uint64_t bps, uint32_t segNum) +{ +} + +void BufferBasedAdaptation::dLTimeUpdate(double time) +{ +} + +void BufferBasedAdaptation::onEOS(bool value) +{ + this->bufferEOS = value; +} + +void BufferBasedAdaptation::checkedByDASHReceiver() +{ +} + +void BufferBasedAdaptation::bufferUpdate(uint32_t bufferFill, int maxC) +{ + this->setBitrate(bufferFill); + this->notifyBitrateChange(); +} diff --git a/Adaptation/BufferBasedAdaptation.h b/Adaptation/BufferBasedAdaptation.h new file mode 100644 index 00000000..32ad8045 --- /dev/null +++ b/Adaptation/BufferBasedAdaptation.h @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LIBDASH_FRAMEWORK_ADAPTATION_BUFFERBASEDADAPTATION_H_ +#define LIBDASH_FRAMEWORK_ADAPTATION_BUFFERBASEDADAPTATION_H_ + +#include "AbstractAdaptationLogic.h" +#include "../MPD/AdaptationSetStream.h" +#include "../Input/IDASHReceiverObserver.h" + +namespace libdash +{ +namespace framework +{ +namespace adaptation +{ +class BufferBasedAdaptation : public AbstractAdaptationLogic +{ +public: + BufferBasedAdaptation(dash::mpd::IMPD *mpd, dash::mpd::IPeriod *period, dash::mpd::IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params); + virtual ~BufferBasedAdaptation(); + + virtual LogicType getType(); + virtual bool isUserDependent(); + virtual bool isRateBased(); + virtual bool isBufferBased(); + virtual void bitrateUpdate(uint64_t bps, uint32_t segNum); + virtual void bufferUpdate(uint32_t bufferFill, int maxC); + virtual void dLTimeUpdate(double time); + void setBitrate(uint32_t bufferFill); + uint64_t getBitrate(); + virtual void setMultimediaManager(viper::managers::IMultimediaManagerBase *_mmManager); + void notifyBitrateChange(); + void onEOS(bool value); + void checkedByDASHReceiver(); + +private: + uint64_t currentBitrate; + std::vector availableBitrates; + viper::managers::IMultimediaManagerBase *multimediaManager; + dash::mpd::IRepresentation *representation; + uint32_t reservoirThreshold; + uint32_t maxThreshold; + uint32_t lastBufferFill; + bool bufferEOS; + bool shouldAbort; +}; +} +} +} + +#endif /* LIBDASH_FRAMEWORK_ADAPTATION_BUFFERBASEDADAPTATION_H_ */ diff --git a/Adaptation/BufferBasedAdaptationWithRateBased.cpp b/Adaptation/BufferBasedAdaptationWithRateBased.cpp new file mode 100644 index 00000000..3a1895c0 --- /dev/null +++ b/Adaptation/BufferBasedAdaptationWithRateBased.cpp @@ -0,0 +1,206 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "BufferBasedAdaptationWithRateBased.h" +#include + +using namespace dash::mpd; +using namespace libdash::framework::adaptation; +using namespace libdash::framework::input; +using namespace libdash::framework::mpd; + +BufferBasedAdaptationWithRateBased::BufferBasedAdaptationWithRateBased(IMPD *mpd, IPeriod *period, IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params) : + AbstractAdaptationLogic(mpd, period, adaptationSet, isVid) +{ + this->alphaRate = params->Adaptech_Alpha; + this->reservoirThreshold = params->Adaptech_FirstThreshold; + this->maxThreshold = params->Adaptech_SecondThreshold; + this->switchUpThreshold = params->Adaptech_SwitchUpThreshold; + this->slackParam = params->Adaptech_SlackParameter; + + std::vector representations = this->adaptationSet->GetRepresentation(); + + this->m_count = 0; + this->instantBw = 0; + this->averageBw = 0; + this->representation = this->adaptationSet->GetRepresentation().at(0); + this->multimediaManager = NULL; + this->lastBufferFill = 0; + this->bufferEOS = false; + this->shouldAbort = false; + this->isCheckedForReceiver = false; + this->myQuality = 0; + Debug("BufferRateBasedParams:\talpha:%f\tfirst threshold: %f\tsecond threshold: %f\tswitch-up margin: %d\tSlack: %f\n",this->alphaRate, (double)reservoirThreshold/100, (double)maxThreshold/100, this->switchUpThreshold, this->slackParam); + Debug("Buffer Adaptation: STARTED\n"); +} +BufferBasedAdaptationWithRateBased::~BufferBasedAdaptationWithRateBased () +{ +} + +LogicType BufferBasedAdaptationWithRateBased::getType() +{ + return adaptation::BufferBased; +} + +bool BufferBasedAdaptationWithRateBased::isUserDependent() +{ + return false; +} + +bool BufferBasedAdaptationWithRateBased::isRateBased() +{ + return true; +} +bool BufferBasedAdaptationWithRateBased::isBufferBased() +{ + return true; +} + +void BufferBasedAdaptationWithRateBased::setMultimediaManager(viper::managers::IMultimediaManagerBase *_mmManager) +{ + this->multimediaManager = _mmManager; +} + +void BufferBasedAdaptationWithRateBased::notifyBitrateChange() +{ + if(this->multimediaManager) + if(this->multimediaManager->isStarted() && !this->multimediaManager->isStopping()) + if(this->isVideo) + this->multimediaManager->setVideoQuality(this->period, this->adaptationSet, this->representation); + else + this->multimediaManager->setAudioQuality(this->period, this->adaptationSet, this->representation); + //Should Abort is done here to avoid race condition with DASHReceiver::DoBuffering() + if(this->shouldAbort) + { + this->multimediaManager->shouldAbort(this->isVideo); + } + this->shouldAbort = false; +} + +uint64_t BufferBasedAdaptationWithRateBased::getBitrate() +{ + return this->currentBitrate; +} + +void BufferBasedAdaptationWithRateBased::setBitrate(uint32_t bufferFill) +{ + uint32_t phi1, phi2; + std::vector representations; + representations = this->adaptationSet->GetRepresentation(); + size_t i = 0; + + Debug("bufferlevel: %u, instant rate %lu, average rate %lu\n", bufferFill, this->instantBw, this->averageBw); + phi1 = 0; + phi2 = 0; + while(i < representations.size()) + { + if(phi1 == 0 && representations.at(i)->GetBandwidth() > slackParam * this->instantBw) + { + phi1 = representations.at((i == 0) ? i : i -1)->GetBandwidth(); + } + if(phi2 == 0 && representations.at(i)->GetBandwidth() > slackParam * this->averageBw) + { + phi2 = representations.at((i == 0) ? i : i -1)->GetBandwidth(); + } + i++; + } + + if(!phi1) + phi1 = representations.at(representations.size() - 1)->GetBandwidth(); + + if(!phi2) + phi2 = representations.at(representations.size() - 1)->GetBandwidth(); + + if(bufferFill < this->reservoirThreshold) + { + this->m_count = 0; + this->myQuality = 0; + } + else + { + if(bufferFill < this->maxThreshold) + { + this->m_count = 0; + if(this->currentBitrate > phi1) + { + if(this->myQuality > 0) + { + this->myQuality--; + } + } + else + { + if(this->currentBitrate < phi1) + { + if(this->myQuality < representations.size() - 1) + { + this->myQuality++; + } + } + } + } + else + { // bufferFill > this->maxThreshold + if(this->currentBitrate < phi2) + { + m_count++; + + if(m_count >= switchUpThreshold && this->myQuality < representations.size() - 1) + { + this->m_count = 0; + this->myQuality++; + } + } + } + } + this->representation = representations.at(this->myQuality); + this->currentBitrate = (uint64_t) this->representation->GetBandwidth(); + Debug("ADAPTATION_LOGIC:\tFor %s:\tlast_buffer: %f\tbuffer_level: %f, instantaneousBw: %lu, AverageBW: %lu, choice: %d\n",isVideo ? "video" : "audio",(double)lastBufferFill/100 , (double)bufferFill/100, this->instantBw, this->averageBw , this->myQuality); +} + +void BufferBasedAdaptationWithRateBased::bitrateUpdate(uint64_t bps, uint32_t segNum) +{ + Debug("rate estimation: %lu\n", bps); + this->instantBw = bps; + if(this->averageBw == 0) + { + this->averageBw = bps; + } + else + { + this->averageBw = this->alphaRate*this->averageBw + (1 - this->alphaRate)*bps; + } +} + +void BufferBasedAdaptationWithRateBased::onEOS(bool value) +{ + this->bufferEOS = value; +} + +void BufferBasedAdaptationWithRateBased::checkedByDASHReceiver() +{ + this->isCheckedForReceiver = false; +} +void BufferBasedAdaptationWithRateBased::bufferUpdate(uint32_t bufferFill, int maxC) +{ + Debug("buffer update: %u\n", bufferFill); + this->setBitrate(bufferFill); + this->notifyBitrateChange(); +} + +void BufferBasedAdaptationWithRateBased::dLTimeUpdate(double time) +{ +} + diff --git a/Adaptation/BufferBasedAdaptationWithRateBased.h b/Adaptation/BufferBasedAdaptationWithRateBased.h new file mode 100644 index 00000000..5c787d30 --- /dev/null +++ b/Adaptation/BufferBasedAdaptationWithRateBased.h @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LIBDASH_FRAMEWORK_ADAPTATION_BUFFERBASEDADAPTATIONRATE_H_ +#define LIBDASH_FRAMEWORK_ADAPTATION_BUFFERBASEDADAPTATIONRATE_H_ + +#include "AbstractAdaptationLogic.h" +#include "../MPD/AdaptationSetStream.h" +#include "../Input/IDASHReceiverObserver.h" + +namespace libdash +{ +namespace framework +{ +namespace adaptation +{ +class BufferBasedAdaptationWithRateBased : public AbstractAdaptationLogic +{ +public: + BufferBasedAdaptationWithRateBased(dash::mpd::IMPD *mpd, dash::mpd::IPeriod *period, dash::mpd::IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params); + virtual ~BufferBasedAdaptationWithRateBased(); + + virtual LogicType getType(); + virtual bool isUserDependent(); + virtual bool isRateBased(); + virtual bool isBufferBased(); + virtual void bitrateUpdate(uint64_t bps, uint32_t segNum); + virtual void bufferUpdate(uint32_t bufferFill, int maxC); + virtual void dLTimeUpdate(double time); + void setBitrate(uint32_t bufferFill); + uint64_t getBitrate(); + virtual void setMultimediaManager(viper::managers::IMultimediaManagerBase *_mmManager); + void notifyBitrateChange(); + void onEOS(bool value); + void checkedByDASHReceiver(); + +private: + uint64_t currentBitrate; + std::vector availableBitrates; + viper::managers::IMultimediaManagerBase *multimediaManager; + dash::mpd::IRepresentation *representation; + uint32_t reservoirThreshold; + uint32_t maxThreshold; + uint32_t lastBufferFill; + int m_count; + int switchUpThreshold; + bool bufferEOS; + bool shouldAbort; + double alphaRate; + uint64_t averageBw; + uint64_t instantBw; + int myQuality; + double slackParam; + bool isCheckedForReceiver; +}; +} +} +} + +#endif /* LIBDASH_FRAMEWORK_ADAPTATION_BUFFERBASEDADAPTATIONRATE_H_ */ diff --git a/Adaptation/BufferBasedThreeThresholdAdaptation.cpp b/Adaptation/BufferBasedThreeThresholdAdaptation.cpp new file mode 100644 index 00000000..021e7b7c --- /dev/null +++ b/Adaptation/BufferBasedThreeThresholdAdaptation.cpp @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "BufferBasedThreeThresholdAdaptation.h" +#include + +using namespace dash::mpd; +using namespace libdash::framework::adaptation; +using namespace libdash::framework::input; +using namespace libdash::framework::mpd; + +BufferBasedThreeThresholdAdaptation::BufferBasedThreeThresholdAdaptation(IMPD *mpd, IPeriod *period, IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params) : + AbstractAdaptationLogic(mpd, period, adaptationSet, isVid) +{ + this->firstThreshold = params->BufferThreeThreshold_FirstThreshold; + this->secondThreshold = params->BufferThreeThreshold_SecondThreshold; + this->thirdThreshold = params->BufferThreeThreshold_ThirdThreshold; + this->slackParam = params->BufferThreeThreshold_slackParameter; + std::vector representations = this->adaptationSet->GetRepresentation(); + this->representation = this->adaptationSet->GetRepresentation().at(0); + this->multimediaManager = NULL; + this->lastBufferFill = 0; + this->bufferEOS = false; + this->shouldAbort = false; + this->isCheckedForReceiver = false; + Debug("BufferRateBasedParams:\t%f\t%f\t%f\n",(double)this->firstThreshold/100, (double)secondThreshold/100, (double)thirdThreshold/100); + Debug("Buffer Adaptation: STARTED\n"); +} + +BufferBasedThreeThresholdAdaptation::~BufferBasedThreeThresholdAdaptation() +{ +} + +LogicType BufferBasedThreeThresholdAdaptation::getType() +{ + return adaptation::BufferBasedThreeThreshold; +} + +bool BufferBasedThreeThresholdAdaptation::isUserDependent() +{ + return false; +} + +bool BufferBasedThreeThresholdAdaptation::isRateBased() +{ + return true; +} + +bool BufferBasedThreeThresholdAdaptation::isBufferBased() +{ + return true; +} + +void BufferBasedThreeThresholdAdaptation::setMultimediaManager(viper::managers::IMultimediaManagerBase *_mmManager) +{ + this->multimediaManager = _mmManager; +} + +void BufferBasedThreeThresholdAdaptation::notifyBitrateChange() +{ + if(this->multimediaManager) + if(this->multimediaManager->isStarted() && !this->multimediaManager->isStopping()) + if(this->isVideo) + this->multimediaManager->setVideoQuality(this->period, this->adaptationSet, this->representation); + else + this->multimediaManager->setAudioQuality(this->period, this->adaptationSet, this->representation); + //Should Abort is done here to avoid race condition with DASHReceiver::DoBuffering() + if(this->shouldAbort) + { + this->multimediaManager->shouldAbort(this->isVideo); + } + this->shouldAbort = false; +} + +uint64_t BufferBasedThreeThresholdAdaptation::getBitrate() +{ + return this->currentBitrate; +} + +void BufferBasedThreeThresholdAdaptation::setBitrate(uint32_t bufferFill) +{ + uint32_t phi1, phi2; + std::vector representations; + representations = this->adaptationSet->GetRepresentation(); + size_t i = 0; + + if(this->isCheckedForReceiver) + { + return; + } + this->isCheckedForReceiver = true; + + + if(bufferFill < this->firstThreshold) + { + this->myQuality = 0; + } + else + { + if(bufferFill < this->secondThreshold) + { + if(this->currentBitrate >= this->instantBw) + { + if(this->myQuality > 0) + { + this->myQuality--; + } + } + } + else + { + if(bufferFill < this->thirdThreshold) + { + } + else + {// bufferLevel > thirdThreshold + if(this->currentBitrate <= this->instantBw) + { + if(this->myQuality < representations.size() - 1) + this->myQuality++; + } + } + } + } + this->representation = representations.at(this->myQuality); + this->currentBitrate = (uint64_t) this->representation->GetBandwidth(); + Debug("ADAPTATION_LOGIC:\tFor %s:\tlast_buffer: %f\tbuffer_level: %f, instantaneousBw: %lu, choice: %d\n",isVideo ? "video" : "audio",(double)lastBufferFill/100 , (double)bufferFill/100, this->instantBw, this->myQuality); +} + +void BufferBasedThreeThresholdAdaptation::bitrateUpdate(uint64_t bps, uint32_t segNum) +{ + this->instantBw = bps; +} + +void BufferBasedThreeThresholdAdaptation::onEOS(bool value) +{ + this->bufferEOS = value; +} + +void BufferBasedThreeThresholdAdaptation::checkedByDASHReceiver() +{ + this->isCheckedForReceiver = false; +} +void BufferBasedThreeThresholdAdaptation::bufferUpdate(uint32_t bufferFill, int maxC) +{ + this->setBitrate(bufferFill); + this->notifyBitrateChange(); +} + +void BufferBasedThreeThresholdAdaptation::dLTimeUpdate(double time) +{ +} + + diff --git a/Adaptation/BufferBasedThreeThresholdAdaptation.h b/Adaptation/BufferBasedThreeThresholdAdaptation.h new file mode 100644 index 00000000..62160bc3 --- /dev/null +++ b/Adaptation/BufferBasedThreeThresholdAdaptation.h @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LIBDASH_FRAMEWORK_ADAPTATION_BUFFERBASEDADAPTATIONTHREE_H_ +#define LIBDASH_FRAMEWORK_ADAPTATION_BUFFERBASEDADAPTATIONTHREE_H_ + +#include "AbstractAdaptationLogic.h" +#include "../MPD/AdaptationSetStream.h" +#include "../Input/IDASHReceiverObserver.h" + +namespace libdash +{ +namespace framework +{ +namespace adaptation +{ +class BufferBasedThreeThresholdAdaptation : public AbstractAdaptationLogic +{ +public: + BufferBasedThreeThresholdAdaptation(dash::mpd::IMPD *mpd, dash::mpd::IPeriod *period, dash::mpd::IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params); + virtual ~BufferBasedThreeThresholdAdaptation(); + + virtual LogicType getType(); + virtual bool isUserDependent(); + virtual bool isRateBased(); + virtual bool isBufferBased(); + virtual void bitrateUpdate(uint64_t bps, uint32_t segNum); + virtual void bufferUpdate(uint32_t bufferFill, int maxC); + virtual void dLTimeUpdate(double time); + void setBitrate(uint32_t bufferFill); + uint64_t getBitrate(); + virtual void setMultimediaManager(viper::managers::IMultimediaManagerBase *_mmManager); + void notifyBitrateChange(); + void onEOS(bool value); + void checkedByDASHReceiver(); + +private: + uint64_t currentBitrate; + std::vector availableBitrates; + viper::managers::IMultimediaManagerBase *multimediaManager; + dash::mpd::IRepresentation *representation; + uint32_t secondThreshold; + uint32_t thirdThreshold; + uint32_t lastBufferFill; + bool bufferEOS; + bool shouldAbort; + uint32_t firstThreshold; + uint64_t instantBw; + int myQuality; + double slackParam; + bool isCheckedForReceiver; +}; +} +} +} + +#endif /* LIBDASH_FRAMEWORK_ADAPTATION_BUFFERBASEDADAPTATIONTHREE_H_ */ diff --git a/Adaptation/IAdaptationLogic.h b/Adaptation/IAdaptationLogic.h new file mode 100644 index 00000000..bfe980c7 --- /dev/null +++ b/Adaptation/IAdaptationLogic.h @@ -0,0 +1,115 @@ +/* + * IAdaptationLogic.h + ***************************************************************************** + * Copyright (C) 2012, bitmovin Softwareentwicklung OG, All Rights Reserved + * + * Email: libdash-dev@vicky.bitmovin.net + * + * This source code and its use and distribution, is subject to the terms + * and conditions of the applicable license agreement. + *****************************************************************************/ + +#ifndef LIBDASH_FRAMEWORK_ADAPTATION_IADAPTATIONLOGIC_H_ +#define LIBDASH_FRAMEWORK_ADAPTATION_IADAPTATIONLOGIC_H_ +#include "../Input/MediaObject.h" +#include "../Input/DASHReceiver.h" +#include "IRepresentation.h" +#include "../Managers/IMultimediaManagerBase.h" + +namespace libdash +{ +namespace framework +{ +namespace input +{ +class DASHReceiver; +} +namespace adaptation +{ +//#define START __LINE__ +//ADAPTATIONLOGIC Count is an hack to have the number of adaptation logic that we can use +#define FOREACH_ADAPTATIONLOGIC(ADAPTATIONLOGIC) \ + ADAPTATIONLOGIC(AlwaysLowest) \ + ADAPTATIONLOGIC(RateBased) \ + ADAPTATIONLOGIC(BufferBased) \ + ADAPTATIONLOGIC(BufferRateBased) \ + ADAPTATIONLOGIC(BufferBasedThreeThreshold) \ + ADAPTATIONLOGIC(Panda) \ + ADAPTATIONLOGIC(Bola) \ + ADAPTATIONLOGIC(Count) \ + + +#define GENERATE_ENUM(ENUM) ENUM, +#define GENERATE_STRING(STRING) #STRING, + +enum LogicType { + FOREACH_ADAPTATIONLOGIC(GENERATE_ENUM) +}; + +static const char *LogicType_string[] = { + FOREACH_ADAPTATIONLOGIC(GENERATE_STRING) +}; + +class IAdaptationLogic +{ +public: + virtual ~IAdaptationLogic() {} + + virtual uint32_t getPosition() = 0; + virtual void setPosition(uint32_t segmentNumber) = 0; + virtual dash::mpd::IRepresentation* getRepresentation() = 0; + virtual void setRepresentation(dash::mpd::IPeriod *period, + dash::mpd::IAdaptationSet *adaptationSet, + dash::mpd::IRepresentation *representation)= 0; + virtual LogicType getType() = 0; + virtual bool isUserDependent()= 0; + virtual void bitrateUpdate(uint64_t bps, uint32_t segNum) = 0; + virtual void dLTimeUpdate(double time) = 0; + virtual void bufferUpdate(uint32_t bufferfillstate, int maxC) = 0; + virtual bool isRateBased() = 0; + virtual bool isBufferBased() = 0; + virtual void setMultimediaManager(viper::managers::IMultimediaManagerBase *mmManager)= 0; + virtual void onEOS(bool value) = 0; + virtual void checkedByDASHReceiver() = 0; +}; + +struct AdaptationParameters +{ + int segmentBufferSize; + double segmentDuration; + + //RATE BASED + double Rate_Alpha; + + //BUFFER BASED + int BufferBased_reservoirThreshold; + int BufferBased_maxThreshold; + + //BOLA + double Bola_Alpha; + double Bola_bufferTargetSeconds; + + //ADAPTECH + double Adaptech_Alpha; + int Adaptech_FirstThreshold; + int Adaptech_SecondThreshold; + int Adaptech_SwitchUpThreshold; + double Adaptech_SlackParameter; + + //BUFFER THREE THRESHOLDS + int BufferThreeThreshold_FirstThreshold; + int BufferThreeThreshold_SecondThreshold; + int BufferThreeThreshold_ThirdThreshold; + double BufferThreeThreshold_slackParameter; + //PANDA + double Panda_Alpha; + double Panda_Beta; + double Panda_Bmin; + double Panda_K; + double Panda_W; + double Panda_Epsilon; +}; +} +} +} +#endif /* LIBDASH_FRAMEWORK_ADAPTATION_IADAPTATIONLOGIC_H_ */ diff --git a/Adaptation/Panda.cpp b/Adaptation/Panda.cpp new file mode 100644 index 00000000..cb2ec660 --- /dev/null +++ b/Adaptation/Panda.cpp @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "Panda.h" +#include + + +using namespace dash::mpd; +using namespace libdash::framework::adaptation; +using namespace libdash::framework::input; +using namespace libdash::framework::mpd; + +PandaAdaptation::PandaAdaptation(IMPD *mpd, IPeriod *period, IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params) : + AbstractAdaptationLogic (mpd, period, adaptationSet, isVid) +{ + this->param_Alpha = params->Panda_Alpha; + this->param_Beta = params->Panda_Beta; + this->param_Bmin = params->Panda_Bmin; + this->param_K = params->Panda_K; + this->param_W = params->Panda_W; + this->param_Epsilon = params->Panda_Epsilon; + + this->segmentDuration = params->segmentDuration; + this->bufferMaxSizeSeconds = params->segmentBufferSize * this->segmentDuration; + this->targetBw = 0; + this->targetInterTime = 0.0; + + this->averageBw = 0; + this->smoothBw = 0; + this->instantBw = 0; + this->targetBw = 0; + + this->targetInterTime = 0.0; + this->interTime = 0.0; + + this->alpha_ewma = 0.8; + + this->bufferLevel = 0; + this->bufferLevelSeconds = 0.0; + + this->downloadTime = 0.0; + + this->isVideo = isVid; + this->mpd = mpd; + this->adaptationSet = adaptationSet; + this->period = period; + this->multimediaManager = NULL; + this->representation = NULL; + this->currentBitrate = 0; + this->current = 0; + + // Retrieve the available bitrates + std::vector representations = this->adaptationSet->GetRepresentation(); + + this->availableBitrates.clear(); + Debug("PANDA Available Bitrates...\n"); + for(size_t i = 0; i < representations.size(); i++) + { + this->availableBitrates.push_back((uint64_t)(representations.at(i)->GetBandwidth())); + Debug("%d - %I64u bps\n", i+1, this->availableBitrates[i]); + } + + this->representation = this->adaptationSet->GetRepresentation().at(0); + this->currentBitrate = (uint64_t) this->representation->GetBandwidth(); + + Debug("Panda parameters: K= %f, Bmin = %f, alpha = %f, beta = %f, W = %f\n", param_K, param_Bmin, param_Alpha, param_Beta, param_W); +} + +PandaAdaptation::~PandaAdaptation() { +} + +LogicType PandaAdaptation::getType() +{ + return adaptation::Panda; +} + +bool PandaAdaptation::isUserDependent() +{ + return false; +} + +bool PandaAdaptation::isRateBased() +{ + return true; +} + +bool PandaAdaptation::isBufferBased() +{ + return true; +} + +void PandaAdaptation::setMultimediaManager (viper::managers::IMultimediaManagerBase *_mmManager) +{ + this->multimediaManager = _mmManager; +} + +void PandaAdaptation::notifyBitrateChange() +{ + if(this->multimediaManager->isStarted() && !this->multimediaManager->isStopping()) + if(this->isVideo) + this->multimediaManager->setVideoQuality(this->period, this->adaptationSet, this->representation); + else + this->multimediaManager->setAudioQuality(this->period, this->adaptationSet, this->representation); +} + +uint64_t PandaAdaptation::getBitrate() +{ + return this->currentBitrate; +} + +void PandaAdaptation::quantizer() +{ + this->deltaUp = this->param_Epsilon * (double)this->smoothBw; + this->deltaDown = 0.0; + + Debug("** DELTA UP:\t%f\n", this->deltaUp); + + uint64_t smoothBw_UP = this->smoothBw - this->deltaUp; + uint64_t smoothBw_DOWN = this->smoothBw - this->deltaDown; + + Debug("** Smooth-BW UP:\t%d\t Smooth-BW DOWN:\t%d\n", smoothBw_UP, smoothBw_DOWN); + + std::vector representations; + representations = this->adaptationSet->GetRepresentation(); + uint32_t numQualLevels = representations.size(); + + // We have to find bitrateMin and bitrateMax + uint64_t bitrateDown, bitrateUp; + + // DOWN + uint32_t iDown = 0; + uint32_t i_d,i_u; + for (i_d = 0; i_d < this->availableBitrates.size(); ++i_d) { + if (this->availableBitrates[i_d] > smoothBw_DOWN) { + break; + } + } + if(i_d > 0) + iDown = i_d-1; + else + iDown = 0; + + bitrateDown = (uint64_t) representations.at(iDown)->GetBandwidth(); + Debug("** Bitrate DOWN:\t%d\t at Quality:\t%d\n", bitrateDown, iDown); + + // UP + uint32_t iUp = 0; + for (i_u = 0; i_u < this->availableBitrates.size(); ++i_u) { + if (this->availableBitrates[i_u] > smoothBw_UP) { + break; + } + } + if(i_u > 0) + iUp = i_u-1; + else + iUp = 0; + + bitrateUp = (uint64_t) representations.at(iUp)->GetBandwidth(); + Debug("** Bitrate UP:\t%d\t at Quality:\t%d\n", bitrateUp, iUp); + + Debug("** Current RATE:\t%d\n Current QUALITY:\t%d\n", this->currentBitrate, this->current); + + + // Next bitrate computation + if(this->currentBitrate < bitrateUp) + { + this->currentBitrate = bitrateUp; + this->current = iUp; + } + else if(this->currentBitrate <= bitrateDown && this->currentBitrate >= bitrateUp) + { + Debug("** CURRENT UNCHANGED **\n"); + } + else + { + this->currentBitrate = bitrateDown; + this->current = iDown; + } + this->representation = this->adaptationSet->GetRepresentation().at(this->current); +} + +void PandaAdaptation::setBitrate(uint64_t bps) +{ + + // 1. Calculating the targetBW + if(this->targetBw) + { + //this->targetBw = this->targetBw + param_K * this->interTime * (param_W - ((this->targetBw - bps + this->param_W) > 0 ? this->targetBw - bps + this->param_W: 0)); + if ((double)this->targetBw - (double)bps + this->param_W > 0) + this->targetBw = this->targetBw + (uint64_t)(param_K * this->interTime * (param_W - ((double)this->targetBw - (double)bps + this->param_W))); + else + this->targetBw = this->targetBw + (uint64_t)(param_K * this->interTime * param_W); + } + else + this->targetBw = bps; + + Debug("** INSTANTANEOUS BW:\t%d\n", bps); + Debug("** CLASSIC EWMA BW:\t%d\n", this->averageBw); + Debug("** PANDA TARGET BW:\t%d\n", this->targetBw); + + // 2. Calculating the smoothBW + if(this->interTime) + this->smoothBw = (uint64_t)((double)this->smoothBw - this->param_Alpha * this->interTime * ((double)this->smoothBw - (double)this->targetBw)); + else + this->smoothBw = this->targetBw; + + Debug("** PANDA SMOOTH BW:\t%d\n", this->smoothBw); + + // 3. Quantization + this->quantizer(); + Debug("ADAPTATION_LOGIC:\tFor %s:\tlast_buffer: %f\tbuffer_level: %f, instantaneousBw: %lu, AverageBW: %lu, choice: %d\n",isVideo ? "video" : "audio",(double)lastBufferLevel/100 , (double)bufferLevel/100, this->instantBw, this->averageBw , this->current); + this->lastBufferLevel = this->bufferLevel; + + // 4. Computing the "actual inter time" + this->bufferLevelSeconds = (double)((this->bufferLevel * this->bufferMaxSizeSeconds) *1./100); + this->targetInterTime = ((double)this->currentBitrate * segmentDuration) * 1./this->smoothBw + param_Beta * (this->bufferLevelSeconds - param_Bmin); + Debug("** TARGET INTER TIME:\t%f\n", this->targetInterTime); + Debug("** DOWNLOAD TIME:\t%f\n", this->downloadTime); + this->targetInterTime = (this->targetInterTime > 0) ? this->targetInterTime : 0.0; + this->interTime = this->targetInterTime > this->downloadTime ? this->targetInterTime : this->downloadTime; + this->interTime = this->interTime > 3 ? 3 : this->interTime; + + Debug("** ACTUAL INTER TIME:\t%f\n", this->interTime); + this->multimediaManager->setTargetDownloadingTime(this->isVideo, interTime); +} + +void PandaAdaptation::bitrateUpdate(uint64_t bps, uint32_t segNum) +{ + this->instantBw = bps; + + // Avg bandwidth estimate with EWMA + if(this->averageBw == 0) + { + this->averageBw = bps; + } + else + { + this->averageBw = this->alpha_ewma*this->averageBw + (1 - this->alpha_ewma)*bps; + } + + this->setBitrate(bps); + this->notifyBitrateChange(); +} + +void PandaAdaptation::dLTimeUpdate(double time) +{ + this->downloadTime = time; +} + +void PandaAdaptation::bufferUpdate(uint32_t bufferfill, int maxC) +{ + Debug("bufferlvl: %d\n", bufferfill); + this->bufferLevel = bufferfill; +} + +void PandaAdaptation::onEOS(bool value) +{ +} + +void PandaAdaptation::checkedByDASHReceiver() +{ +} diff --git a/Adaptation/Panda.h b/Adaptation/Panda.h new file mode 100644 index 00000000..000131a1 --- /dev/null +++ b/Adaptation/Panda.h @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LIBDASH_FRAMEWORK_ADAPTATION_PANDA_H_ +#define LIBDASH_FRAMEWORK_ADAPTATION_PANDA_H_ + +#include "AbstractAdaptationLogic.h" +#include "../MPD/AdaptationSetStream.h" +#include "../Input/IDASHReceiverObserver.h" + +namespace libdash +{ +namespace framework +{ +namespace adaptation +{ +class PandaAdaptation : public AbstractAdaptationLogic +{ +public: + PandaAdaptation(dash::mpd::IMPD *mpd, dash::mpd::IPeriod *period, dash::mpd::IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params); + virtual ~PandaAdaptation(); + + virtual LogicType getType(); + virtual bool isUserDependent(); + virtual bool isRateBased(); + virtual bool isBufferBased(); + virtual void bitrateUpdate(uint64_t bps, uint32_t segNum); + virtual void dLTimeUpdate(double time); + virtual void bufferUpdate(uint32_t bufferFill, int maxC); + void setBitrate(uint64_t bufferFill); + uint64_t getBitrate(); + virtual void setMultimediaManager(viper::managers::IMultimediaManagerBase *_mmManager); + void notifyBitrateChange(); + void onEOS(bool value); + void checkedByDASHReceiver(); + + void quantizer(); +private: + uint64_t currentBitrate; + + std::vector availableBitrates; + viper::managers::IMultimediaManagerBase *multimediaManager; + dash::mpd::IRepresentation *representation; + + uint64_t averageBw; // Classic EWMA + uint64_t instantBw; + uint64_t smoothBw; // Panda paper smoothed y[n] + uint64_t targetBw; // Panda paper x[n] bw estimation + + double param_Alpha; + double alpha_ewma; + double param_Epsilon; + double param_K; + double param_W; + double param_Beta; + double param_Bmin; + + double interTime; // Actual inter time + double targetInterTime; // Target inter time + double downloadTime; + + uint32_t bufferLevel; + uint32_t lastBufferLevel; + double bufferMaxSizeSeconds; // Usually set to 60s + double bufferLevelSeconds; // Current buffer level [s] + + double segmentDuration; + double deltaUp; + double deltaDown; + size_t current; +}; + +} /* namespace adaptation */ +} /* namespace framework */ +} /* namespace libdash */ + +#endif /* LIBDASH_FRAMEWORK_ADAPTATION_PANDA_H_ */ diff --git a/Adaptation/RateBasedAdaptation.cpp b/Adaptation/RateBasedAdaptation.cpp new file mode 100644 index 00000000..73d4ee9b --- /dev/null +++ b/Adaptation/RateBasedAdaptation.cpp @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "RateBasedAdaptation.h" +#include +using namespace dash::mpd; +using namespace libdash::framework::adaptation; +using namespace libdash::framework::input; +using namespace libdash::framework::mpd; + +RateBasedAdaptation::RateBasedAdaptation(IMPD *mpd, IPeriod *period, IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params) : + AbstractAdaptationLogic(mpd, period, adaptationSet, isVid) +{ + std::vector representations = this->adaptationSet->GetRepresentation(); + + this->availableBitrates.clear(); + for(size_t i = 0; i < representations.size(); i++) + { + this->availableBitrates.push_back((uint64_t)(representations.at(i)->GetBandwidth())); + } + this->currentBitrate = this->availableBitrates.at(0); + this->representation = representations.at(0); + this->multimediaManager = NULL; + this->alpha = params->Rate_Alpha; + Debug("RateBasedParams:\t%f\n",alpha); + this->averageBw = 0; +} + +RateBasedAdaptation::~RateBasedAdaptation() +{ +} + +LogicType RateBasedAdaptation::getType() +{ + return adaptation::RateBased; +} + +bool RateBasedAdaptation::isUserDependent() +{ + return false; +} + +bool RateBasedAdaptation::isRateBased() +{ + return true; +} + +bool RateBasedAdaptation::isBufferBased() +{ + return false; +} + +void RateBasedAdaptation::setMultimediaManager(viper::managers::IMultimediaManagerBase *_mmManager) +{ + this->multimediaManager = _mmManager; +} + +void RateBasedAdaptation::notifyBitrateChange() +{ + if(this->multimediaManager->isStarted() && !this->multimediaManager->isStopping()) + if(this->isVideo) + this->multimediaManager->setVideoQuality(this->period, this->adaptationSet, this->representation); + else + this->multimediaManager->setAudioQuality(this->period, this->adaptationSet, this->representation); +} + +uint64_t RateBasedAdaptation::getBitrate() +{ + return this->currentBitrate; +} + +void RateBasedAdaptation::setBitrate(uint64_t bps) +{ + std::vector representations; + representations = this->adaptationSet->GetRepresentation(); + size_t i = 0; + this->ewma(bps); + for(i = 0;i < representations.size();i++) + { + if(representations.at(i)->GetBandwidth() > this->averageBw) + { + if(i > 0) + i--; + break; + } + } + if((size_t)i == (size_t)(representations.size())) + i = i-1; + + Debug("ADAPTATION_LOGIC:\tFor %s:\tBW_estimation(ewma): %lu, choice: %lu\n", (this->isVideo ? "video" : "audio"), this->averageBw, i); + this->representation = representations.at(i); + this->currentBitrate = this->representation->GetBandwidth(); +} + +void RateBasedAdaptation::bitrateUpdate(uint64_t bps, uint32_t segNum) +{ + Debug("Rate Based adaptation: speed received: %lu\n", bps); + this->setBitrate(bps); + this->notifyBitrateChange(); +} + +void RateBasedAdaptation::ewma(uint64_t bps) +{ + if(averageBw) + { + averageBw = alpha*averageBw + (1-alpha)*bps; + } + else + { + averageBw = bps; + } +} + +void RateBasedAdaptation::onEOS(bool value) +{ +} + +void RateBasedAdaptation::checkedByDASHReceiver() +{ +} + +void RateBasedAdaptation::bufferUpdate(uint32_t bufferfill, int maxC) +{ +} + +void RateBasedAdaptation::dLTimeUpdate(double time) +{ +} diff --git a/Adaptation/RateBasedAdaptation.h b/Adaptation/RateBasedAdaptation.h new file mode 100644 index 00000000..cbf7471c --- /dev/null +++ b/Adaptation/RateBasedAdaptation.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LIBDASH_FRAMEWORK_ADAPTATION_RATEBASEDADAPTATION_H_ +#define LIBDASH_FRAMEWORK_ADAPTATION_RATEBASEDADAPTATION_H_ + +#include "AbstractAdaptationLogic.h" +#include "../MPD/AdaptationSetStream.h" +#include "../Input/IDASHReceiverObserver.h" + +namespace libdash +{ +namespace framework +{ +namespace adaptation +{ +class RateBasedAdaptation : public AbstractAdaptationLogic +{ +public: + RateBasedAdaptation(dash::mpd::IMPD *mpd, dash::mpd::IPeriod *period, dash::mpd::IAdaptationSet *adaptationSet, bool isVid, struct AdaptationParameters *params); + virtual ~RateBasedAdaptation(); + + virtual LogicType getType(); + virtual bool isUserDependent(); + virtual bool isRateBased(); + virtual bool isBufferBased(); + virtual void bitrateUpdate(uint64_t bps, uint32_t segNum); + virtual void bufferUpdate(uint32_t bufferfill, int maxC); + virtual void dLTimeUpdate(double time); + void setBitrate(uint64_t bps); + uint64_t getBitrate(); + virtual void setMultimediaManager(viper::managers::IMultimediaManagerBase *_mmManager); + void notifyBitrateChange(); + void onEOS(bool value); + void ewma(uint64_t bps); + void checkedByDASHReceiver(); +private: + uint64_t currentBitrate; + std::vector availableBitrates; + viper::managers::IMultimediaManagerBase *multimediaManager; + dash::mpd::IRepresentation *representation; + double alpha; + uint64_t averageBw; +}; +} +} +} + +#endif /* LIBDASH_FRAMEWORK_ADAPTATION_RATEBASEDADAPTATION_H_ */ -- cgit 1.2.3-korg