abstractlayerdescription.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 Layer 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 ABSTRACTLAYERDESCRIPTION_H
#define ABSTRACTLAYERDESCRIPTION_H


#include "system.h"
#include "framesizescalabilityinterface.h"
#include "internetflow.h"


namespace Coral {


class AbstractLayerDescription : virtual public FrameSizeScalabilityInterface
{
   // ====== Constructor/Destructor =========================================
   public:
   AbstractLayerDescription();

   virtual ~AbstractLayerDescription();

   inline void initLayer(const cardinal pktHeaderSize,
                         const cardinal pktMaxSize,
                         const double   maxTransferDelay,
                         const cardinal maxBufferDelay,
                         const double   maxLossRate,
                         const double   maxJitter,
                         const cardinal flags);


   // ====== Bandwidth and bandwidth quality methods ========================
   inline card64 getBandwidth() const;

   inline bool setBandwidth(const double frameRate,
                            const card64 bandwidth);

   virtual cardinal getPacketRate(const double frameRate) const;

   static inline card64 frameSizeToBandwidth(const double   frameRate,
                                             const cardinal frameSize);

   static inline cardinal bandwidthToFrameSize(const double frameRate,
                                               const card64 bandwidth);


   inline card64 bandwidthToBandwidth(const card64   bandwidth,
                                      const double   frameRate,
                                      const cardinal bufferDelay,
                                      const cardinal newBufferDelay) const;


   card64 payloadBandwidthToBandwidth(const card64   bandwidth,
                                      const double   frameRate,
                                      const cardinal bufferDelay,
                                      const cardinal newBufferDelay) const;


   virtual cardinal frameSizeToPacketRate(const double   frameRate,
                                          const cardinal frameSize) const;

   inline double getMaxTransferDelay() const;

   inline void setMaxTransferDelay(const double maxDelay);

   inline double getMaxLossRate() const;

   inline void setMaxLossRate(const double maxLossRate);

   inline double getMaxJitter() const;

   inline void setMaxJitter(const double maxJitter);


   // ====== Frame size methods =============================================
   inline bool isValidFrameSize(const double   frameRate,
                                const cardinal bufferDelay,
                                const cardinal size) const;

   inline cardinal getNearestValidFrameSize(const double   frameRate,
                                            const cardinal bufferDelay,
                                            const cardinal size) const;

   virtual cardinal payloadToRaw(const double   frameRate,
                                 const cardinal payload,
                                 const cardinal bufferDelay) const;

   virtual cardinal rawToPayload(const double   frameRate,
                                 const cardinal raw,
                                 const cardinal bufferDelay) const;


   // ====== Scaling and utilization methods, for current buffer delay ======
   inline cardinal getMinFrameSize(const double frameRate) const;

   inline cardinal getMaxFrameSize(const double frameRate) const;

   inline cardinal getPeakFrameSizeForSize(const double   frameRate,
                                           const cardinal frameSize) const;

   inline cardinal getPacketCountForSize(const double   frameRate,
                                         const cardinal frameSize) const;

   inline double getPrevFrameSizeForSize(const double   frameRate,
                                         const cardinal frameSize) const;

   inline double getNextFrameSizeForSize(const double   frameRate,
                                         const cardinal frameSize) const;

   inline double getFrameSizeScaleFactorForSize(const double   frameRate,
                                                const cardinal frameSize) const;

   inline double getFrameSizeUtilizationForSize(const double   frameRate,
                                                const cardinal frameSize) const;


   // ====== Scaling and utilization methods, for given buffer delay ========
   inline cardinal getMinFrameSizeForDelay(const double   frameRate,
                                           const cardinal bufferDelay) const;

   inline cardinal getMaxFrameSizeForDelay(const double   frameRate,
                                           const cardinal bufferDelay) const;

   inline cardinal getPeakFrameSizeForDelayAndSize(const double   frameRate,
                                                   const cardinal bufferDelay,
                                                   const cardinal frameSize) const;

   inline cardinal getPacketCountForDelayAndSize(const double   frameRate,
                                                 const cardinal bufferDelay,
                                                 const cardinal frameSize) const;

   inline double getPrevFrameSizeForDelayAndSize(const double   frameRate,
                                                 const cardinal bufferDelay,
                                                 const cardinal frameSize) const;
   inline double getNextFrameSizeForDelayAndSize(const double   frameRate,
                                                 const cardinal bufferDelay,
                                                 const cardinal frameSize) const;

   inline double getFrameSizeScaleFactorForDelayAndSize(const double   frameRate,
                                                        const cardinal bufferDelay,
                                                        const cardinal frameSize) const;

   inline double getFrameSizeUtilizationForDelayAndSize(const double   frameRate,
                                                        const cardinal bufferDelay,
                                                        const cardinal frameSize) const;


   // ====== Buffer delay methods ===========================================
   inline cardinal getBufferDelay() const;

   inline cardinal setBufferDelay(const cardinal bufferDelay);

   inline cardinal getPrevBufferDelay(const double frameRate) const;

   inline cardinal getNextBufferDelay(const double frameRate) const;


   // ====== Source and destination address methods =========================
   inline InternetAddress getSource() const;

   inline InternetFlow getDestination() const;

   inline void setSource(const InternetAddress& source);

   inline void setDestination(const InternetFlow& destination);


   // ====== Flags ==========================================================
   inline cardinal getFlags() const;

   inline void setFlags(const cardinal flags);

   enum LayerFlags {
      LF_BaseLayer      = 0,
      LF_ExtensionLayer = (1 << 0)
   };


   // ====== Protected data =================================================
   protected:
   cardinal        PktHeaderSize;
   cardinal        PktMaxSize;

   card64          Bandwidth;

   double          MaxTransferDelay;
   double          MaxLossRate;
   double          MaxJitter;

   cardinal        BufferDelay;
   cardinal        MaxBufferDelay;
   cardinal        Flags;

   InternetAddress Source;
   InternetFlow    Destination;
};


}


#include "abstractlayerdescription.icc"


#endif