rtpsink.h

rtsp协议的主要实现代码.对开发流媒体

// RTPSink.h: interface for the RTPSink class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_RTPSINK_H__B79AFAC3_0433_4E4C_B10B_037955B447E6__INCLUDED_)
#define AFX_RTPSINK_H__B79AFAC3_0433_4E4C_B10B_037955B447E6__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "winsock.h"

#include "Type.h"
#include "FramedSource.h"
#include "RTPInterface.h"
#include "mmsystem.h"

class OutPacketBuffer;

class RTPSink  
{
public:
	RTPSink(unsigned char rtpPayloadType,unsigned rtpTimestampFrequency,
			unsigned numChannels);
	virtual ~RTPSink();
	void buildAndSendPacket(Boolean isFirstPacket);
	void packFrame();
	void setPacketSizes(unsigned preferredPacketSize,unsigned maxPacketSize);
	u_int16_t currentSeqNo() const { return fSeqNo; }
	u_int32_t currentTimestamp() const { return fCurrentTimestamp; }
	Boolean startPlaying(FramedSource* fMediaSource);
	unsigned short GetServerPort()
	{
		return fRTPInterface->GetBindPort();
	}
	Boolean continuePlaying();
	
	static void afterGettingFrame(void* clientData,
		unsigned numBytesRead, unsigned numTruncatedBytes,
		struct timeval presentationTime,
		unsigned durationInMicroseconds);
	void afterGettingFrame1(unsigned numBytesRead, unsigned numTruncatedBytes,
		struct timeval presentationTime,
		unsigned durationInMicroseconds);
	void sendPacketIfNecessary();
    Boolean isFirstFrameInPacket() const { return fNumFramesUsedSoFar == 0; }
	virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
		unsigned char* frameStart,
		unsigned numBytesInFrame,
		struct timeval frameTimestamp,
		unsigned numRemainingBytes);

	void setTimestamp(struct timeval timestamp);
	u_int32_t convertToRTPTimestamp(struct timeval tv);
	u_int32_t timevalToTimestamp(struct timeval tv) const;
private:
	unsigned frameSpecificHeaderSize() const;
public:
	RTPInterface * fRTPInterface;
private:
	FramedSource * fSource;
	unsigned fTimestampPosition;
	OutPacketBuffer * fOutBuf;
	Boolean fNoFramesLeft;
	unsigned fNumFramesUsedSoFar;
	unsigned fCurFragmentationOffset;
	Boolean fPreviousFrameEndedFragmentation;
	
	Boolean fIsFirstPacket;
	struct timeval fNextSendTime;
	unsigned fSpecialHeaderPosition;
	unsigned fSpecialHeaderSize; // size in bytes of any special header used
	unsigned fCurFrameSpecificHeaderPosition;
	unsigned fCurFrameSpecificHeaderSize; // size in bytes of cur frame-specific header
	unsigned fTotalFrameSpecificHeaderSizes; // size of all frame-specific hdrs in pkt

	Boolean fHaveComputedFirstTimestamp;
	//rtp
	unsigned fRTPPayloadType;
	unsigned fSeqNo;
	unsigned fSSRC;
	unsigned fTimestampBase;
	unsigned fCurrentTimestamp;
	unsigned fTimestampFrequency;

	//rtcp
	unsigned fPacketCount;
	unsigned fTotalOctetCount;
	unsigned fOctetCount;

	MMRESULT m_timeID;

};

// A data structure that a sink may use for an output packet:
class OutPacketBuffer {
public:
	OutPacketBuffer(unsigned preferredPacketSize, unsigned maxPacketSize);
	~OutPacketBuffer();
	
	static unsigned maxSize;
	
	unsigned char* curPtr() const {return &fBuf[fPacketStart + fCurOffset];}
	unsigned totalBytesAvailable() const {
		return fLimit - (fPacketStart + fCurOffset);
	}
	unsigned totalBufferSize() const { return fLimit; }
	unsigned char* packet() const {return &fBuf[fPacketStart];}
	unsigned curPacketSize() const {return fCurOffset;}
	
	void increment(unsigned numBytes) {fCurOffset += numBytes;}
	
	void enqueue(unsigned char const* from, unsigned numBytes);
	void enqueueWord(unsigned word);
	void insert(unsigned char const* from, unsigned numBytes, unsigned toPosition);
	void insertWord(unsigned word, unsigned toPosition);
	void extract(unsigned char* to, unsigned numBytes, unsigned fromPosition);
	unsigned extractWord(unsigned fromPosition);
	
	void skipBytes(unsigned numBytes);
	
	Boolean isPreferredSize() const {return fCurOffset >= fPreferred;}
	Boolean wouldOverflow(unsigned numBytes) const {
		return (fCurOffset+numBytes) > fMax;
	}
	unsigned numOverflowBytes(unsigned numBytes) const {
		return (fCurOffset+numBytes) - fMax;
	}
	Boolean isTooBigForAPacket(unsigned numBytes) const {
		return numBytes > fMax;
	}
	
	void setOverflowData(unsigned overflowDataOffset,
		unsigned overflowDataSize,
		struct timeval const& presentationTime,
		unsigned durationInMicroseconds);
	unsigned overflowDataSize() const {return fOverflowDataSize;}
	struct timeval overflowPresentationTime() const {return fOverflowPresentationTime;}
	unsigned overflowDurationInMicroseconds() const {return fOverflowDurationInMicroseconds;}
	Boolean haveOverflowData() const {return fOverflowDataSize > 0;}
	void useOverflowData();
	
	void adjustPacketStart(unsigned numBytes);
	void resetPacketStart();
	void resetOffset() { fCurOffset = 0; }
	void resetOverflowData() { fOverflowDataOffset = fOverflowDataSize = 0; }
	
	private:
		unsigned fPacketStart, fCurOffset, fPreferred, fMax, fLimit;
		unsigned char* fBuf;
		
		unsigned fOverflowDataOffset, fOverflowDataSize;
		struct timeval fOverflowPresentationTime;
		unsigned fOverflowDurationInMicroseconds;
};
#endif // !defined(AFX_RTPSINK_H__B79AFAC3_0433_4E4C_B10B_037955B447E6__INCLUDED_)