tracearray.h

Go to the documentation of this file.

// ##########################################################################
// ####                                                                  ####
// ####                    Master Thesis Implementation                  ####
// ####  Management of Layered Variable Bitrate Multimedia Streams over  ####
// ####                  DiffServ with A Priori Knowledge                ####
// ####                                                                  ####
// #### ================================================================ ####
// ####                                                                  ####
// ####                                                                  ####
// #### Trace Array                                                      ####
// ####                                                                  ####
// #### 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 TRACEARRAY_H
#define TRACEARRAY_H


#include "system.h"
#include "traceconfiguration.h"


namespace Coral {


class TraceArray
{
   // ====== Constructor/Destructor =========================================
   public:
   TraceArray(const TraceConfiguration& config);

   virtual ~TraceArray();


   // ====== Initialize =====================================================
   void init(const cardinal maxLayers,
             const cardinal maxFrames);


   // ====== Calculations ===================================================
   void calculateEmpiricalEnvelope(const cardinal     layer,
                                   const cardinal     start,
                                   const cardinal     end,
                                   const cardinal     traceStart,
                                   const cardinal     traceEnd,
                                   EmpiricalEnvelope* ee,
                                   const bool         frameCount = false) const;

   void calculateOptimalIntervals(
           double*   costArray,
           cardinal* lengthArray,
           const cardinal  minLength,
           const cardinal  maxLength) const;

   double TraceArray::calculateTrafficCost(
                         EmpiricalEnvelope** ee,
                         const cardinal      position,
                         const cardinal      length) const;

   inline double TraceArray::calculateNextTrafficCost(
                                EmpiricalEnvelope** ee,
                                const cardinal      position,
                                const cardinal      length) const;


   // ====== Frame rate decrement ===========================================
   virtual TraceArray* decreaseFrameRate() const;


   // ====== Public data ====================================================
   public:
   cardinal Layers;
   cardinal Frames;
   cardinal MaxLayers;
   cardinal MaxFrames;
   double   FrameRate;

   struct Trace {
      cardinal         Frames;
      FrameDescription Frame[0];
   }** LayerTrace;



   // ====== Empirical envelope initialization ==============================
   EmpiricalEnvelope* TraceArray::initEmpiricalEnvelope(
                                     char*          buffer,
                                     const cardinal eePairs,
                                     const bool     frameCount = false) const;


   // ====== Protected data =================================================
   protected:
   TraceConfiguration Config;


   // ====== Private data ===================================================
   private:
   cardinal calculateEmpiricalEnvelopePoint(const cardinal layer,
                                            const cardinal start,
                                            const cardinal end,
                                            const cardinal traceStart,
                                            const cardinal traceEnd,
                                            const cardinal delay,
                                            const bool     frameCount = false) const;
};


ostream& operator<<(ostream& os, const TraceArray& traceArray);


}


#include "tracearray.icc"


#endif