From 9e5babf9db52e64bdae60137be7696e56241fca6 Mon Sep 17 00:00:00 2001
From: xingzilong <xingzilong@454eff88-639b-444f-9e54-f578c98de674>
Date: 星期五, 18 八月 2017 18:12:17 +0800
Subject: [PATCH] H264 NALU解析 并在RTSPServer判断
---
VisitFace/RtspNativeCodec/app/libs/live555/include/liveMedia/RTCP.hh | 233 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 233 insertions(+), 0 deletions(-)
diff --git a/VisitFace/RtspNativeCodec/app/libs/live555/include/liveMedia/RTCP.hh b/VisitFace/RtspNativeCodec/app/libs/live555/include/liveMedia/RTCP.hh
new file mode 100644
index 0000000..6a52bd6
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/live555/include/liveMedia/RTCP.hh
@@ -0,0 +1,233 @@
+/**********
+This library is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation; either version 3 of the License, or (at your
+option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
+
+This library is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+**********/
+// "liveMedia"
+// Copyright (c) 1996-2017 Live Networks, Inc. All rights reserved.
+// RTCP
+// C++ header
+
+#ifndef _RTCP_HH
+#define _RTCP_HH
+
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+#ifndef _RTP_SOURCE_HH
+#include "RTPSource.hh"
+#endif
+
+class SDESItem {
+public:
+ SDESItem(unsigned char tag, unsigned char const* value);
+
+ unsigned char const* data() const {return fData;}
+ unsigned totalSize() const;
+
+private:
+ unsigned char fData[2 + 0xFF]; // first 2 bytes are tag and length
+};
+
+typedef void RTCPAppHandlerFunc(void* clientData,
+ u_int8_t subtype, u_int32_t nameBytes/*big-endian order*/,
+ u_int8_t* appDependentData, unsigned appDependentDataSize);
+
+class RTCPMemberDatabase; // forward
+
+class RTCPInstance: public Medium {
+public:
+ static RTCPInstance* createNew(UsageEnvironment& env, Groupsock* RTCPgs,
+ unsigned totSessionBW, /* in kbps */
+ unsigned char const* cname,
+ RTPSink* sink,
+ RTPSource* source,
+ Boolean isSSMSource = False);
+
+ static Boolean lookupByName(UsageEnvironment& env, char const* instanceName,
+ RTCPInstance*& resultInstance);
+
+ unsigned numMembers() const;
+ unsigned totSessionBW() const { return fTotSessionBW; }
+
+ void setByeHandler(TaskFunc* handlerTask, void* clientData,
+ Boolean handleActiveParticipantsOnly = True);
+ // Assigns a handler routine to be called if a "BYE" arrives.
+ // The handler is called once only; for subsequent "BYE"s,
+ // "setByeHandler()" would need to be called again.
+ // If "handleActiveParticipantsOnly" is True, then the handler is called
+ // only if the SSRC is for a known sender (if we have a "RTPSource"),
+ // or if the SSRC is for a known receiver (if we have a "RTPSink").
+ // This prevents (for example) the handler for a multicast receiver being
+ // called if some other multicast receiver happens to exit.
+ // If "handleActiveParticipantsOnly" is False, then the handler is called
+ // for any incoming RTCP "BYE".
+ // (To remove an existing "BYE" handler, call "setByeHandler()" again, with a "handlerTask" of NULL.)
+ void setSRHandler(TaskFunc* handlerTask, void* clientData);
+ void setRRHandler(TaskFunc* handlerTask, void* clientData);
+ // Assigns a handler routine to be called if a "SR" or "RR" packet
+ // (respectively) arrives. Unlike "setByeHandler()", the handler will
+ // be called once for each incoming "SR" or "RR". (To turn off handling,
+ // call the function again with "handlerTask" (and "clientData") as NULL.)
+ void setSpecificRRHandler(netAddressBits fromAddress, Port fromPort,
+ TaskFunc* handlerTask, void* clientData);
+ // Like "setRRHandler()", but applies only to "RR" packets that come from
+ // a specific source address and port. (Note that if both a specific
+ // and a general "RR" handler function is set, then both will be called.)
+ void unsetSpecificRRHandler(netAddressBits fromAddress, Port fromPort); // equivalent to setSpecificRRHandler(..., NULL, NULL);
+ void setAppHandler(RTCPAppHandlerFunc* handlerTask, void* clientData);
+ // Assigns a handler routine to be called whenever an "APP" packet arrives. (To turn off
+ // handling, call the function again with "handlerTask" (and "clientData") as NULL.)
+ void sendAppPacket(u_int8_t subtype, char const* name,
+ u_int8_t* appDependentData, unsigned appDependentDataSize);
+ // Sends a custom RTCP "APP" packet to the peer(s). The parameters correspond to their
+ // respective fields as described in the RTP/RTCP definition (RFC 3550).
+ // Note that only the low-order 5 bits of "subtype" are used, and only the first 4 bytes
+ // of "name" are used. (If "name" has fewer than 4 bytes, or is NULL,
+ // then the remaining bytes are '\0'.)
+
+ Groupsock* RTCPgs() const { return fRTCPInterface.gs(); }
+
+ void setStreamSocket(int sockNum, unsigned char streamChannelId);
+ void addStreamSocket(int sockNum, unsigned char streamChannelId);
+ void removeStreamSocket(int sockNum, unsigned char streamChannelId) {
+ fRTCPInterface.removeStreamSocket(sockNum, streamChannelId);
+ }
+ // hacks to allow sending RTP over TCP (RFC 2236, section 10.12)
+
+ void setAuxilliaryReadHandler(AuxHandlerFunc* handlerFunc,
+ void* handlerClientData) {
+ fRTCPInterface.setAuxilliaryReadHandler(handlerFunc,
+ handlerClientData);
+ }
+
+ void injectReport(u_int8_t const* packet, unsigned packetSize, struct sockaddr_in const& fromAddress);
+ // Allows an outside party to inject an RTCP report (from other than the network interface)
+
+protected:
+ RTCPInstance(UsageEnvironment& env, Groupsock* RTPgs, unsigned totSessionBW,
+ unsigned char const* cname,
+ RTPSink* sink, RTPSource* source,
+ Boolean isSSMSource);
+ // called only by createNew()
+ virtual ~RTCPInstance();
+
+ virtual void noteArrivingRR(struct sockaddr_in const& fromAddressAndPort,
+ int tcpSocketNum, unsigned char tcpStreamChannelId);
+
+ void incomingReportHandler1();
+
+private:
+ // redefined virtual functions:
+ virtual Boolean isRTCPInstance() const;
+
+private:
+ Boolean addReport(Boolean alwaysAdd = False);
+ void addSR();
+ void addRR();
+ void enqueueCommonReportPrefix(unsigned char packetType, u_int32_t SSRC,
+ unsigned numExtraWords = 0);
+ void enqueueCommonReportSuffix();
+ void enqueueReportBlock(RTPReceptionStats* receptionStats);
+ void addSDES();
+ void addBYE();
+
+ void sendBuiltPacket();
+
+ static void onExpire(RTCPInstance* instance);
+ void onExpire1();
+
+ static void incomingReportHandler(RTCPInstance* instance, int /*mask*/);
+ void processIncomingReport(unsigned packetSize, struct sockaddr_in const& fromAddressAndPort,
+ int tcpSocketNum, unsigned char tcpStreamChannelId);
+ void onReceive(int typeOfPacket, int totPacketSize, u_int32_t ssrc);
+
+private:
+ u_int8_t* fInBuf;
+ unsigned fNumBytesAlreadyRead;
+ OutPacketBuffer* fOutBuf;
+ RTPInterface fRTCPInterface;
+ unsigned fTotSessionBW;
+ RTPSink* fSink;
+ RTPSource* fSource;
+ Boolean fIsSSMSource;
+
+ SDESItem fCNAME;
+ RTCPMemberDatabase* fKnownMembers;
+ unsigned fOutgoingReportCount; // used for SSRC member aging
+
+ double fAveRTCPSize;
+ int fIsInitial;
+ double fPrevReportTime;
+ double fNextReportTime;
+ int fPrevNumMembers;
+
+ int fLastSentSize;
+ int fLastReceivedSize;
+ u_int32_t fLastReceivedSSRC;
+ int fTypeOfEvent;
+ int fTypeOfPacket;
+ Boolean fHaveJustSentPacket;
+ unsigned fLastPacketSentSize;
+
+ TaskFunc* fByeHandlerTask;
+ void* fByeHandlerClientData;
+ Boolean fByeHandleActiveParticipantsOnly;
+ TaskFunc* fSRHandlerTask;
+ void* fSRHandlerClientData;
+ TaskFunc* fRRHandlerTask;
+ void* fRRHandlerClientData;
+ AddressPortLookupTable* fSpecificRRHandlerTable;
+ RTCPAppHandlerFunc* fAppHandlerTask;
+ void* fAppHandlerClientData;
+
+public: // because this stuff is used by an external "C" function
+ void schedule(double nextTime);
+ void reschedule(double nextTime);
+ void sendReport();
+ void sendBYE();
+ int typeOfEvent() {return fTypeOfEvent;}
+ int sentPacketSize() {return fLastSentSize;}
+ int packetType() {return fTypeOfPacket;}
+ int receivedPacketSize() {return fLastReceivedSize;}
+ int checkNewSSRC();
+ void removeLastReceivedSSRC();
+ void removeSSRC(u_int32_t ssrc, Boolean alsoRemoveStats);
+};
+
+// RTCP packet types:
+const unsigned char RTCP_PT_SR = 200;
+const unsigned char RTCP_PT_RR = 201;
+const unsigned char RTCP_PT_SDES = 202;
+const unsigned char RTCP_PT_BYE = 203;
+const unsigned char RTCP_PT_APP = 204;
+const unsigned char RTCP_PT_RTPFB = 205; // Generic RTP Feedback [RFC4585]
+const unsigned char RTCP_PT_PSFB = 206; // Payload-specific [RFC4585]
+const unsigned char RTCP_PT_XR = 207; // extended report [RFC3611]
+const unsigned char RTCP_PT_AVB = 208; // AVB RTCP packet ["Standard for Layer 3 Transport Protocol for Time Sensitive Applications in Local Area Networks." Work in progress.]
+const unsigned char RTCP_PT_RSI = 209; // Receiver Summary Information [RFC5760]
+const unsigned char RTCP_PT_TOKEN = 210; // Port Mapping [RFC6284]
+const unsigned char RTCP_PT_IDMS = 211; // IDMS Settings [RFC7272]
+
+// SDES tags:
+const unsigned char RTCP_SDES_END = 0;
+const unsigned char RTCP_SDES_CNAME = 1;
+const unsigned char RTCP_SDES_NAME = 2;
+const unsigned char RTCP_SDES_EMAIL = 3;
+const unsigned char RTCP_SDES_PHONE = 4;
+const unsigned char RTCP_SDES_LOC = 5;
+const unsigned char RTCP_SDES_TOOL = 6;
+const unsigned char RTCP_SDES_NOTE = 7;
+const unsigned char RTCP_SDES_PRIV = 8;
+
+#endif
--
Gitblit v1.8.0