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                                 ####
// ####                                                                  ####
// #### Version 1.00  --  February 19, 2001                              ####
// ####                                                                  ####
// #### Copyright (C) 2000/2001 Thomas Dreibholz                         ####
// #### University of Bonn, Department of Computer Science IV            ####
// #### EMail: dreibh@iem.uni-due.de                                     ####
// #### WWW:   https://www.uni-due.de/~be0001/diplom/index.html          ####
// ####                                                                  ####
// ##########################################################################


#ifndef ABSTRACTQOSDESCRIPTION_H
#define ABSTRACTQOSDESCRIPTION_H


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


namespace Coral {


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;
};


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


}


#include "abstractqosdescription.icc"


#endif