traceclient.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 Client                                                     ####
// ####                                                                  ####
// #### 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 TRACECLIENT_H
#define TRACECLIENT_H


#include "tracedecoderinterface.h"
#include "tracedecoderrepository.h"
#include "mediainfo.h"
#include "rtcpsender.h"
#include "rtpreceiver.h"
#include "internetaddress.h"
#include "socket.h"
#include "strings.h"


#include "traceclientapppacket.h"


#include <multimap.h>
#include <algo.h>


namespace Coral {


class TraceClient
{
   // ====== Constructor/Destructor =========================================
   public:
   TraceClient(const char* receiverName);

   ~TraceClient();


   // ====== Player functions ===============================================
   public:
   bool play(const char*  server,
             const char*  mediaName,
             const card32 sessionDescriptor = 0);

   void change(const char* mediaName);

   void stop();


   // ====== Settings =======================================================
   card64 getPosition();

   inline card64 getMaxPosition() const;

   MediaInfo getMediaInfo() const;


   inline card8 getErrorCode() const;

   inline const char* getEncoding() const;

   inline card64 getMinWantedBandwidth() const;

   inline card64 getMaxWantedBandwidth() const;

   inline double getMaxTransferDelay() const;

   inline double getWantedUtilization() const;

   inline int8 getStreamPriority() const;

   inline int8 getSessionPriority() const;


   // ====== Transmission information =======================================
   inline Range<card64> getBandwidth() const;

   inline double getFrameRate() const;

   inline double getUtilization() const;

   inline card32 getFlags() const;

   inline cardinal getLayers() const;

   card8 getIPVersion() const;

   inline bool playing() const;

   String getServerAddressString(InternetAddress::PrintFormat format = InternetAddress::PF_Address) const;

   String getOurAddressString(InternetAddress::PrintFormat format = InternetAddress::PF_Address) const;

   inline card64 getBytesReceived(const cardinal layer = 0) const;

   inline card64 getPacketsReceived(const cardinal layer = 0) const;

   inline InternetFlow getInternetFlow(const cardinal layer = 0) const;

   inline card32 getFlowLabel(const cardinal layer = 0) const;

   inline card8 getTrafficClass(const cardinal layer = 0) const;

   card32 getServerSSRC(const cardinal layer = 0) const;

   inline card32 getOurSSRC() const;

   card64 getPacketsLost(const cardinal layer = 0) const;

   double getFractionLost(const cardinal layer = 0) const;

   double getJitter(const cardinal layer = 0) const;


   const char* getEncodingName(const cardinal index);


   inline void setPosition(const card64 position);

   void setPause(const bool on);

   inline void setWantedUtilization(const double utilization);

   inline void setFlags(const card32 priority);

   inline void setMinWantedBandwidth(const card64 bandwidth);

   inline void setMaxWantedBandwidth(const card64 bandwidth);

   inline void setMaxTransferDelay(const double delay);

   inline void setStreamPriority(const int8 priority);

   inline void setSessionPriority(const int8 priority);

   void setEncoding(const cardinal index);


   // ====== Private data ===================================================
   private:
   void sendCommand(const bool updateRestartPosition = true);


   // Update of RestartPosition has to be delayed after change() call to
   // ensure that there are no more packets of the old file on the network
   // which change the restart position back to the old value.
   static const card64 RestartPositionUpdateDelay = 5000000;


   RTPReceiver*                                    Receiver;
   RTCPSender*                                     Sender;
   Socket                                          SenderSocket;
   Socket                                          ReceiverSocket;
   InternetFlow                                    Flow;
   InternetAddress                                 ServerAddress;
   InternetAddress                                 OurAddress;
   card32                                          OurSSRC;
   InternetAddress                                 ReceiverAddress;

   multimap<const cardinal,TraceDecoderInterface*> DecoderSet;
   TraceDecoderRepository                          Decoders;

   TraceClientAppPacket                            Status;
   card64                                          OldPosition;
   card64                                          ChangeTimeStamp;
   bool                                            IsPlaying;
};


}


#include "traceclient.icc"


#endif