dtsc.h

Go to the documentation of this file.

#pragma once
#include <vector>
#include <iostream>
#include <stdint.h> //for uint64_t
#include <string>
#include <deque>
#include <set>
#include <stdio.h> //for FILE
#include "json.h"
#include "socket.h"
#include "timing.h"

#define DTSC_INT 0x01
#define DTSC_STR 0x02
#define DTSC_OBJ 0xE0
#define DTSC_ARR 0x0A
#define DTSC_CON 0xFF

namespace DTSC {

  enum datatype {
    AUDIO, 
    VIDEO, 
    META, 
    PAUSEMARK, 
    MODIFIEDHEADER, 
    INVALID 
  };

  extern char Magic_Header[]; 
  extern char Magic_Packet[]; 
  extern char Magic_Packet2[]; 

  struct seekPos {
    bool operator < (const seekPos & rhs) const {
      if (seekTime < rhs.seekTime) {
        return true;
      } else {
        if (seekTime == rhs.seekTime) {
          if (trackID < rhs.trackID) {
            return true;
          }
        }
      }
      return false;
    }
    long long unsigned int seekTime;
    long long unsigned int bytePos;
    unsigned int trackID;
  };

  enum packType {
    DTSC_INVALID,
    DTSC_HEAD,
    DTSC_V1,
    DTSC_V2
  };

  class Scan {
    public:
      Scan();
      Scan(char * pointer, size_t len);
      operator bool() const;
      std::string toPrettyString(unsigned int indent = 0);
      bool hasMember(std::string indice);
      bool hasMember(const char * indice, const unsigned int ind_len);
      Scan getMember(std::string indice);
      Scan getMember(const char * indice);
      Scan getMember(const char * indice, const unsigned int ind_len);
      Scan getIndice(unsigned int num);
      std::string getIndiceName(unsigned int num);
      unsigned int getSize();

      char getType();
      bool asBool();
      long long asInt();
      std::string asString();
      void getString(char *& result, unsigned int & len);
      JSON::Value asJSON();
    private:
      char * p;
      size_t len;
  };

  class Packet {
    public:
      Packet();
      Packet(const Packet & rhs);
      Packet(const char * data_, unsigned int len, bool noCopy = false);
      ~Packet();
      void null();
      void operator = (const Packet & rhs);
      operator bool() const;
      packType getVersion() const;
      void reInit(const char * data_, unsigned int len, bool noCopy = false);
      void genericFill(long long packTime, long long packOffset, long long packTrack, const char * packData, long long packDataSize, long long packBytePos, bool isKeyframe);
      void getString(const char * identifier, char *& result, unsigned int & len) const;
      void getString(const char * identifier, std::string & result) const;
      void getInt(const char * identifier, int & result) const;
      int getInt(const char * identifier) const;
      void getFlag(const char * identifier, bool & result) const;
      bool getFlag(const char * identifier) const;
      bool hasMember(const char * identifier) const;
      long long unsigned int getTime() const;
      long int getTrackId() const;
      char * getData() const;
      int getDataLen() const;
      int getPayloadLen() const;
      JSON::Value toJSON() const;
      Scan getScan() const;
    protected:
      bool master;
      packType version;
      void resize(unsigned int size);
      char * data;
      unsigned int bufferLen;
      unsigned int dataLen;
  };

  struct livePos {
    livePos() {
      seekTime = 0;
      trackID = 0;
    }
    livePos(const livePos & rhs) {
      seekTime = rhs.seekTime;
      trackID = rhs.trackID;
    }
    void operator = (const livePos & rhs) {
      seekTime = rhs.seekTime;
      trackID = rhs.trackID;
    }
    bool operator == (const livePos & rhs) {
      return seekTime == rhs.seekTime && trackID == rhs.trackID;
    }
    bool operator != (const livePos & rhs) {
      return seekTime != rhs.seekTime || trackID != rhs.trackID;
    }
    bool operator < (const livePos & rhs) const {
      if (seekTime < rhs.seekTime) {
        return true;
      } else {
        if (seekTime > rhs.seekTime) {
          return false;
        }
      }
      return (trackID < rhs.trackID);
    }
    long long unsigned int seekTime;
    unsigned int trackID;
  };

  /*LTS-START*/
  class Ivec {
    public:
      Ivec();
      Ivec(long long int iVec);
      void setIvec(long long int iVec);
      void setIvec(std::string iVec);
      void setIvec(const char * iVec, int len);
      long long int asInt();
      char * getData();
    private:
      char data[8];
  };
  /*LTS-END*/

  class Part {
    public:
      long getSize();
      void setSize(long newSize);
      short getDuration();
      void setDuration(short newDuration);
      long getOffset();
      void setOffset(long newOffset);
      char * getData();
      void toPrettyString(std::ostream & str, int indent = 0);
    private:
      char data[9];
  };

  class Key {
    public:
      unsigned long long getBpos();
      void setBpos(unsigned long long newBpos);
      unsigned long getLength();
      void setLength(unsigned long newLength);
      unsigned long getNumber();
      void setNumber(unsigned long newNumber);
      unsigned short getParts();
      void setParts(unsigned short newParts);
      unsigned long long getTime();
      void setTime(unsigned long long newTime);
      char * getData();
      void toPrettyString(std::ostream & str, int indent = 0);
    private:
#ifdef BIGMETA
#define PACKED_KEY_SIZE 25
#else
#define PACKED_KEY_SIZE 16
#endif
      char data[PACKED_KEY_SIZE];
  };

  class Fragment {
    public:
      unsigned long getDuration();
      void setDuration(unsigned long newDuration);
      char getLength();
      void setLength(char newLength);
      unsigned long getNumber();
      void setNumber(unsigned long newNumber);
      unsigned long getSize();
      void setSize(unsigned long newSize);
      char * getData();
      void toPrettyString(std::ostream & str, int indent = 0);
    private:
#ifdef BIGMETA
#define PACKED_FRAGMENT_SIZE 13
#else
#define PACKED_FRAGMENT_SIZE 11
#endif
      char data[PACKED_FRAGMENT_SIZE];
  };

  class Track {
    public:
      Track();      
      Track(JSON::Value & trackRef);
      Track(Scan & trackRef);
            
      inline operator bool() const {
        return (parts.size() && keySizes.size() && (keySizes.size() == keys.size()));
      }
      /*
      void update(long long packTime, long long packOffset, long long packDataSize, long long packBytePos, bool isKeyframe, long long packSendSize, unsigned long segment_size = 5000);
      */
      void update(long long packTime, long long packOffset, long long packDataSize, long long packBytePos, bool isKeyframe, long long packSendSize, unsigned long segment_size = 5000, const char * iVec = 0);
      int getSendLen();
      void send(Socket::Connection & conn);
      void writeTo(char *& p);
      JSON::Value toJSON(bool skipBinary = false);
      std::deque<Fragment> fragments;
      std::deque<Key> keys;
      std::deque<unsigned long> keySizes;
      std::deque<Part> parts;
      std::deque<Ivec> ivecs; /*LTS*/
      Key & getKey(unsigned int keyNum);
      unsigned int timeToKeynum(unsigned int timestamp);
      unsigned int timeToFragnum(unsigned int timestamp);
      void reset();
      void toPrettyString(std::ostream & str, int indent = 0, int verbosity = 0);
      void finalize();
      
      std::string getIdentifier();
      std::string getWritableIdentifier();
      unsigned int trackID;
      unsigned long long firstms;
      unsigned long long lastms;
      int bps;
      int missedFrags;
      std::string init;
      std::string codec;
      std::string type;
      //audio only
      int rate;
      int size;
      int channels;
      //video only
      int width;
      int height;
      int fpks;
    private:
      std::string cachedIdent;
  };

  class Meta{
    public:
      Meta();
      Meta(const DTSC::Packet & source);
      Meta(JSON::Value & meta);

      inline operator bool() const { //returns if the object contains valid meta data BY LOOKING AT vod/live FLAGS
        return vod || live;
      }
      void reinit(const DTSC::Packet & source);
      void update(DTSC::Packet & pack, unsigned long segment_size = 5000);
      void updatePosOverride(DTSC::Packet & pack, unsigned long bpos);
      void update(JSON::Value & pack, unsigned long segment_size = 5000);
      /*LTS
      void update(long long packTime, long long packOffset, long long packTrack, long long packDataSize, long long packBytePos, bool isKeyframe, long long packSendSize = 0, unsigned long segment_size = 5000);
      LTS*/
      void update(long long packTime, long long packOffset, long long packTrack, long long packDataSize, long long packBytePos, bool isKeyframe, long long packSendSize = 0, unsigned long segment_size = 5000, const char * iVec = 0);
      unsigned int getSendLen();
      void send(Socket::Connection & conn);
      void writeTo(char * p);
      JSON::Value toJSON();
      void reset();
      void toPrettyString(std::ostream & str, int indent = 0, int verbosity = 0);
      //members:
      std::map<unsigned int, Track> tracks;
      bool vod;
      bool live;
      bool merged;
      long long int moreheader;
      long long int bufferWindow;
  };

  class File {
    public:
      File();
      File(const File & rhs);
      File(std::string filename, bool create = false);
      File & operator = (const File & rhs);
      operator bool() const;
      ~File();
      Meta & getMeta();
      long long int getLastReadPos();
      bool writeHeader(std::string & header, bool force = false);
      long long int addHeader(std::string & header);
      long int getBytePosEOF();
      long int getBytePos();
      bool reachedEOF();
      void seekNext();
      void parseNext();
      DTSC::Packet & getPacket();
      bool seek_time(unsigned int ms);
      bool seek_time(unsigned int ms, unsigned int trackNo, bool forceSeek = false);
      bool seek_bpos(int bpos);
      void rewritePacket(std::string & newPacket, int bytePos);
      void writePacket(std::string & newPacket);
      void writePacket(JSON::Value & newPacket);
      bool atKeyframe();
      void selectTracks(std::set<unsigned long> & tracks);
    private:
      long int endPos;
      void readHeader(int pos);
      DTSC::Packet myPack;
      JSON::Value metaStorage;
      Meta metadata;
      std::map<unsigned int, std::string> trackMapping;
      long long int currtime;
      long long int lastreadpos;
      int currframe;
      FILE * F;
      unsigned long headerSize;
      void * buffer;
      bool created;
      std::set<seekPos> currentPositions;
      std::set<unsigned long> selectedTracks;
  };
  //FileWriter

}