tdtf.h

Go to the documentation of this file.

// ##########################################################################
// ####                                                                  ####
// ####                    Master Thesis Implementation                  ####
// ####  Management of Layered Variable Bitrate Multimedia Streams over  ####
// ####                  DiffServ with A Priori Knowledge                ####
// ####                                                                  ####
// #### ================================================================ ####
// ####                                                                  ####
// ####                                                                  ####
// #### Thomas Dreibholz's Trace File (TDTF)                             ####
// ####                                                                  ####
// #### 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 TDTF_H
#define TDTF_H


#include "system.h"


namespace Coral {


enum UtilityFunctions
{
   UF_Linear = 0x0000,

   UF_Exponential1 = 0x0010,

   UF_Exponential2 = 0x0011,

   UF_Undefined = 0xffff
};



struct TDTFPrefixExtensionHeader
{
   char ExtID[4];

   card32 ExtLength;
};



struct TDTFPrefix
{
   const static card32 CurrentVersion = 0x74660000;

   const static cardinal MaxTitleLength = 64;

   const static cardinal MaxCopyrightLength = 64;

   const static cardinal MaxCommentLength = 64;

   const static cardinal MaxURLLength = 128;


   char TDTF_ID[4];

   card32 Version;

   card64 TraceTimeStamp;

   card64 UtilizationTimeStamp;

   card16 MediaType;

   enum MediaTypes {
      MT_Unknown = 0x00,
      MT_MPEG    = 0x01,
      MT_H263    = 0x02,
      MT_MP3     = 0x03
   };

   card16 MediaSubtype;

   card32 pad01;

   card64 pad02;

   char Title[MaxTitleLength];

   char Copyright[MaxCopyrightLength];

   char Comment[MaxCommentLength];

   char URL[MaxURLLength];
};



struct TDTFSuffix
{
   card64 TraceTimeStamp;

   card64 UtilizationTimeStamp;

   card32 ResourceUtilizationStart; 

   card32 ResourceUtilizationIndex;

   card32 MainIndex;

   card32 TraceStart;

   char TDTF_ID[4];
};



struct EmpiricalEnvelopePair
{
   card16 Interval;

   card32 Sum;
};


struct EmpiricalEnvelope
{
   card16 Pairs;

   EmpiricalEnvelopePair Pair[0];


   // ====== Calculations ===================================================
   static inline cardinal getSize(const cardinal eePairs);

   cardinal getConstraint(const cardinal bufferDelay) const;
};



struct FrameDescription
{
   card32 ID;

   card32 Size;
};



struct TraceHeader
{
   card64 FrameRate;

   card32 Frames;

   card8 Layers;

   card8 pad01;

   card16 pad02;

   FrameDescription Frame[0];
};



struct UtilizationHeader
{
   card16 Type;

   card8 MaxConstants;

   card8 Constants;

   card64 Weight;

   card64 Constant[0];


   // ====== Calculation methods ============================================
   static inline cardinal getUtilizationSize(const cardinal maxConstants);
};


struct ResourceUtilizationEntry
{
   card32 Utilization;

   card64 FrameRate;

   card32 Bandwidth[0];
};



struct ResourceUtilizationHeader
{
   card16 Entries;

   card8 Layers;

   card8 Flags;

   card32 Position;

   ResourceUtilizationEntry Entry[0];


   // ====== Calculation methods ============================================
   static inline cardinal getResourceUtilizationSize(
                             const cardinal layers,
                             const cardinal maxConstants);
};



struct IntervalHeader
{
   card32 Position;

   card32 Length;

   card8 Layers;

   card8 Flags;

   card16 pad;

   card32 IntervalDescriptionSize;

   card32 Offset[0];
   /*
     ====================================================================
     IMPORTANT NOTICE:
     Changes in offset mapping require change in getIntervalHeaderSize()
     and/or get*Offset() methods!!!
     ====================================================================
   */


   // ====== Offset calculation methods =====================================
   static inline cardinal getIntervalHeaderSize(const cardinal layers);

   static const cardinal offsetUH = 0;

   inline cardinal getOffsetLH(const cardinal layer) const;

   inline cardinal getOffsetEEBR(const cardinal layer) const;

   inline cardinal getOffsetEEFC(const cardinal layer) const;
};



struct LayerHeader
{
   card32 FrameSizeUtilizationOffset;

   card32 Scalability;
   
   card8 Flags;
   
   card8 pad;
};



struct PositionLengthIntervalIndexEntry
{
   card32 Position;

   card32 Length;

   card32 Interval;
};



struct PositionLengthIntervalIndexHeader
{
   card32 Entries;

   PositionLengthIntervalIndexEntry Entry[0];
};


struct ResourceUtilizationListIndexEntry
{
   card32 Position;

   card32 Length;

   card32 List;
};


struct ResourceUtilizationListIndexHeader
{
   card32 Entries;

   ResourceUtilizationListIndexEntry Entry[0];
};


struct MainIndexEntry
{
   card64 FrameRate;

   card32 Trace;

   card32 Intervals;
};



struct MainIndexHeader
{
   card32 Entries;

   MainIndexEntry Entry[0];
};


}


#include "tdtf.icc"


#endif