abstractqosdescription.h

Go to the documentation of this file.

// ##########################################################################
// ####                                                                  ####
// ####                   Master Thesis Implementation                   ####
// ####  Management of Layered Variable Bitrate Multimedia Streams over  ####
// ####                 DiffServ with A Priori Knowledge                 ####
// ####                                                                  ####
// #### ================================================================ ####
// ####                                                                  ####
// ####                                                                  ####
// #### Abstract QoS Description Inlines                                 ####
// ####                                                                  ####
// ####           Copyright (C) 1999-2012 by Thomas Dreibholz            ####
// ####                                                                  ####
// #### Contact:                                                         ####
// ####    EMail: dreibh@iem.uni-due.de                                  ####
// ####    WWW:   https://www.nntb.no/~dreibh/rtpaudio                ####
// ####                                                                  ####
// #### ---------------------------------------------------------------- ####
// ####                                                                  ####
// #### This program is free software: you can redistribute it and/or    ####
// #### modify it under the terms of the GNU General Public License as   ####
// #### published by the Free Software Foundation, either version 3 of   ####
// #### the License, or (at your option) any later version.              ####
// ####                                                                  ####
// #### This program is distributed in the hope that it will be useful,  ####
// #### but WITHOUT ANY WARRANTY; without even the implied warranty of   ####
// #### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    ####
// #### GNU General Public License for more details.                     ####
// ####                                                                  ####
// #### You should have received a copy of the GNU General Public        ####
// #### License along with this program.  If not, see                    ####
// #### <http://www.gnu.org/licenses/>.                                  ####
// ####                                                                  ####
// ##########################################################################
// $Id: abstractqosdescription.h 1308 2011-12-22 07:43:26Z dreibh $


#ifndef ABSTRACTQOSDESCRIPTION_H
#define ABSTRACTQOSDESCRIPTION_H


#include "tdsystem.h"
#include "frameratescalabilityinterface.h"
#include "abstractlayerdescription.h"
#include "rtppacket.h"
#include "resourceutilizationpoint.h"


class AbstractQoSDescription : virtual public FrameRateScalabilityInterface
{
   // ====== Constructor/Destructor =========================================
   public:
   AbstractQoSDescription();

   virtual ~AbstractQoSDescription();


   // ====== Initialization/update ==========================================
   inline void initDescription(const double frameRate);

   virtual void updateDescription(const cardinal pktHeaderSize,
                                  const cardinal pktMaxSize) = 0;


   // ====== Frame rate methods =============================================
   inline double getFrameRate() const;

   inline double setFrameRate(const double frameRate);

   inline double getNextFrameRate() const;

   inline double getPrevFrameRate() const;

   inline double getFrameRateScaleFactor() const;


   // ====== Total bandwidth methods ========================================
   card64 getMinBandwidth() const;

   card64 getMaxBandwidth() const;


   // ====== Position =======================================================
   inline card64 getPosition() const;

   inline void setPosition(const card64 position);


   // ====== Abstract layer methods =========================================
   virtual cardinal getLayers() const = 0;

   virtual AbstractLayerDescription* getLayer(const cardinal layer) const = 0;


   // ====== Get/set resources, calculate utilization for bandwidths ========
   double getResources(ResourceUtilizationPoint& rup) const;

   double setResources(const ResourceUtilizationPoint& rup);

   virtual double calculateUtilizationForLayerBandwidths(
                     const double    frameRate,
                     const cardinal  layers,
                     const card64*   bandwidth) const;


   // ====== Resource/Utilization calculation ===============================
   virtual cardinal getPrecomputedResourceUtilizationList(
                       ResourceUtilizationPoint* rup,
                       const card64              bwThreshold,
                       const double              utThreshold,
                       const cardinal            maxPoints) const = 0;

   virtual cardinal calculateResourceUtilizationList(
                       ResourceUtilizationPoint* rup,
                       const card64              bwThreshold,
                       const double              utThreshold,
                       const cardinal            maxPoints) const;

   inline double calculateMaxUtilizationForBandwidth(
                    const card64              totalBandwidth,
                    ResourceUtilizationPoint& rup) const;

   virtual void calculateMaxUtilizationForBandwidthArray(
                   const card64*             totalBandwidthArray,
                   ResourceUtilizationPoint* rupArray,
                   const cardinal            points) const;


   // ====== Wanted quality settings ========================================
   inline double getWantedUtilization() const;

   inline void setWantedUtilization(const double utilization);

   card64 getMinWantedBandwidth() const;

   card64 getMaxWantedBandwidth() const;

   void setMinWantedBandwidth(const card64 bandwidth);

   void setMaxWantedBandwidth(const card64 bandwidth);

   inline int8 getStreamPriority() const;

   inline void setStreamPriority(const int8 priority);

   inline int8 getSessionPriority() const;

   inline void setSessionPriority(const int8 priority);


   // ====== Protected data =================================================
   protected:
   double   WantedUtilization;
   card64   MinWantedBandwidth;
   card64   MaxWantedBandwidth;
   double   FrameRate;
   card64   Position;
   cardinal PktHeaderSize;
   cardinal PktMaxSize;
   int8     StreamPriority;
   int8     SessionPriority;


   // ====== Private data ===================================================
   private:
   void doResourceUtilizationIteration(
           ResourceUtilizationPoint* rup,
           const card64              bwThreshold,
           const double              utThreshold,
           double*                   utilizationCache,
           card64*                   bandwidthCache,
           const cardinal            maxPoints,
           const cardinal            maxCachePoints,
           const cardinal            start,
           const cardinal            end,
           const card64              startBandwidth,
           const card64              endBandwidth,
           const cardinal            level,
           const cardinal            maxLevel,
           cardinal&                 count) const;

   void calculateBandwidthInfo(const cardinal layer,
                               BandwidthInfo& bandwidthInfo) const;
};


std::ostream& operator<<(std::ostream& os, const AbstractQoSDescription& aqd);


#include "abstractqosdescription.icc"


#endif