179 lines
7.6 KiB
C++
179 lines
7.6 KiB
C++
#pragma once
|
|
#include "dtsc.h"
|
|
#include "h264.h"
|
|
#include "h265.h"
|
|
#include "json.h"
|
|
#include "mp4.h"
|
|
#include "mp4_generic.h"
|
|
#include "socket.h"
|
|
#include "util.h"
|
|
#include <algorithm>
|
|
#include <cstdio>
|
|
#include <deque>
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include <set>
|
|
#include <sstream>
|
|
#include <stdint.h>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace SDP{
|
|
class Track;
|
|
};
|
|
|
|
/// This namespace holds all RTP-parsing and sending related functionality.
|
|
namespace RTP{
|
|
|
|
extern unsigned int MAX_SEND;
|
|
|
|
/// This class is used to make RTP packets. Currently, H264, and AAC are supported. RTP
|
|
/// mechanisms, like increasing sequence numbers and setting timestamps are all taken care of in
|
|
/// here.
|
|
class Packet{
|
|
private:
|
|
bool managed;
|
|
char *data; ///< The actual RTP packet that is being sent
|
|
uint32_t maxDataLen; ///< Amount of reserved bytes for the packet(s)
|
|
int sentPackets;
|
|
int sentBytes; // Because ugly is beautiful
|
|
public:
|
|
static double startRTCP;
|
|
unsigned int getHsize() const;
|
|
unsigned int getPayloadSize() const;
|
|
char *getPayload() const;
|
|
unsigned int getVersion() const;
|
|
unsigned int getPadding() const;
|
|
unsigned int getExtension() const;
|
|
unsigned int getContribCount() const;
|
|
unsigned int getMarker() const;
|
|
unsigned int getPayloadType() const;
|
|
unsigned int getSequence() const;
|
|
uint32_t getTimeStamp() const;
|
|
void setSequence(unsigned int seq);
|
|
unsigned int getSSRC() const;
|
|
void setSSRC(unsigned long ssrc);
|
|
|
|
void setTimestamp(uint32_t t);
|
|
void increaseSequence();
|
|
void sendH264(void *socket, void callBack(void *, char *, unsigned int, unsigned int),
|
|
const char *payload, unsigned int payloadlen, unsigned int channel, bool lastOfAccesUnit);
|
|
void sendVP8(void *socket, void callBack(void *, char *, unsigned int, unsigned int),
|
|
const char *payload, unsigned int payloadlen, unsigned int channel);
|
|
void sendH265(void *socket, void callBack(void *, char *, unsigned int, unsigned int),
|
|
const char *payload, unsigned int payloadlen, unsigned int channel);
|
|
void sendMPEG2(void *socket, void callBack(void *, char *, unsigned int, unsigned int),
|
|
const char *payload, unsigned int payloadlen, unsigned int channel);
|
|
void sendData(void *socket, void callBack(void *, char *, unsigned int, unsigned int),
|
|
const char *payload, unsigned int payloadlen, unsigned int channel, std::string codec);
|
|
void sendRTCP_SR(long long &connectedAt, void *socket, unsigned int tid, DTSC::Meta &metadata,
|
|
void callBack(void *, char *, unsigned int, unsigned int));
|
|
void sendRTCP_RR(long long &connectedAt, SDP::Track &sTrk, unsigned int tid,
|
|
DTSC::Meta &metadata, void callBack(void *, char *, unsigned int, unsigned int));
|
|
|
|
Packet();
|
|
Packet(unsigned int pt, unsigned int seq, unsigned int ts, unsigned int ssr, unsigned int csrcCount = 0);
|
|
Packet(const Packet &o);
|
|
void operator=(const Packet &o);
|
|
~Packet();
|
|
Packet(const char *dat, unsigned int len);
|
|
char *getData();
|
|
char *ptr() const{return data;}
|
|
};
|
|
|
|
/// Sorts RTP packets, outputting them through a callback in correct order.
|
|
/// Also keeps track of statistics, which it expects to be read/reset externally (for now).
|
|
/// Optionally can be inherited from with the outPacket function overridden to not use a callback.
|
|
class Sorter{
|
|
public:
|
|
Sorter(uint64_t trackId = 0, void (*callback)(const uint64_t track, const Packet &p) = 0);
|
|
bool wantSeq(uint16_t seq) const;
|
|
void addPacket(const char *dat, unsigned int len);
|
|
void addPacket(const Packet &pack);
|
|
// By default, calls the callback function, if set.
|
|
virtual void outPacket(const uint64_t track, const Packet &p){
|
|
if (callback){callback(track, p);}
|
|
}
|
|
void setCallback(uint64_t track, void (*callback)(const uint64_t track, const Packet &p));
|
|
uint16_t rtpSeq;
|
|
int32_t lostTotal, lostCurrent;
|
|
uint32_t packTotal, packCurrent;
|
|
|
|
private:
|
|
uint64_t packTrack;
|
|
std::map<uint16_t, Packet> packBuffer;
|
|
std::map<uint16_t, Packet> packetHistory;
|
|
void (*callback)(const uint64_t track, const Packet &p);
|
|
};
|
|
|
|
class MPEGVideoHeader{
|
|
public:
|
|
MPEGVideoHeader(char *d);
|
|
void clear();
|
|
uint16_t getTotalLen() const;
|
|
std::string toString() const;
|
|
void setTempRef(uint16_t ref);
|
|
void setPictureType(uint8_t pType);
|
|
void setSequence();
|
|
void setBegin();
|
|
void setEnd();
|
|
|
|
private:
|
|
char *data;
|
|
};
|
|
|
|
/// Converts (sorted) RTP packets into DTSC packets.
|
|
/// Outputs DTSC packets through a callback function or overridden virtual function.
|
|
/// Updates init data through a callback function or overridden virtual function.
|
|
class toDTSC{
|
|
public:
|
|
toDTSC();
|
|
void setProperties(const uint64_t track, const std::string &codec, const std::string &type,
|
|
const std::string &init, const double multiplier);
|
|
void setProperties(const DTSC::Track &Trk);
|
|
void setCallbacks(void (*cbPack)(const DTSC::Packet &pkt),
|
|
void (*cbInit)(const uint64_t track, const std::string &initData));
|
|
void addRTP(const RTP::Packet &rPkt);
|
|
virtual void outPacket(const DTSC::Packet &pkt){
|
|
if (cbPack){cbPack(pkt);}
|
|
}
|
|
virtual void outInit(const uint64_t track, const std::string &initData){
|
|
if (cbInit){cbInit(track, initData);}
|
|
}
|
|
|
|
public:
|
|
uint64_t trackId;
|
|
double multiplier; ///< Multiplier to convert from millis to RTP time
|
|
std::string codec; ///< Codec of this track
|
|
std::string type; ///< Type of this track
|
|
std::string init; ///< Init data of this track
|
|
unsigned int lastSeq; ///< Last sequence number seen
|
|
uint64_t packCount; ///< Amount of DTSC packets outputted, for H264/HEVC
|
|
double fps; ///< Framerate, for H264, HEVC
|
|
uint32_t wrapArounds; ///< Counter for RTP timestamp wrapArounds
|
|
bool recentWrap; ///< True if a wraparound happened recently.
|
|
uint32_t prevTime;
|
|
uint64_t firstTime;
|
|
void (*cbPack)(const DTSC::Packet &pkt);
|
|
void (*cbInit)(const uint64_t track, const std::string &initData);
|
|
// Codec-specific handlers
|
|
void handleAAC(uint64_t msTime, char *pl, uint32_t plSize);
|
|
void handleMP2(uint64_t msTime, char *pl, uint32_t plSize);
|
|
void handleMPEG2(uint64_t msTime, char *pl, uint32_t plSize);
|
|
void handleHEVC(uint64_t msTime, char *pl, uint32_t plSize, bool missed);
|
|
void handleHEVCSingle(uint64_t ts, const char *buffer, const uint32_t len, bool isKey);
|
|
h265::initData hevcInfo; ///< For HEVC init parsing
|
|
Util::ResizeablePointer fuaBuffer; ///< For H264/HEVC FU-A packets
|
|
Util::ResizeablePointer packBuffer; ///< For H264/HEVC regular and STAP packets
|
|
void handleH264(uint64_t msTime, char *pl, uint32_t plSize, bool missed, bool hasPadding);
|
|
void handleH264Single(uint64_t ts, const char *buffer, const uint32_t len, bool isKey);
|
|
void handleH264Multi(uint64_t ts, char *buffer, const uint32_t len);
|
|
std::string spsData; ///< SPS for H264
|
|
std::string ppsData; ///< PPS for H264
|
|
void handleVP8(uint64_t msTime, const char *buffer, const uint32_t len, bool missed, bool hasPadding);
|
|
Util::ResizeablePointer vp8FrameBuffer; ///< Stores successive VP8 payload data. We always start with the first
|
|
///< partition; but we might be missing other partitions when they were
|
|
///< lost. (a partition is basically what's called a slice in H264).
|
|
bool vp8BufferHasKeyframe;
|
|
};
|
|
}// namespace RTP
|