Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * RTP demuxer definitions
  3.  * Copyright (c) 2002 Fabrice Bellard
  4.  * Copyright (c) 2006 Ryan Martell <rdm4@martellventures.com>
  5.  *
  6.  * This file is part of FFmpeg.
  7.  *
  8.  * FFmpeg is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Lesser General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2.1 of the License, or (at your option) any later version.
  12.  *
  13.  * FFmpeg is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Lesser General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public
  19.  * License along with FFmpeg; if not, write to the Free Software
  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21.  */
  22.  
  23. #ifndef AVFORMAT_RTPDEC_H
  24. #define AVFORMAT_RTPDEC_H
  25.  
  26. #include "libavcodec/avcodec.h"
  27. #include "avformat.h"
  28. #include "rtp.h"
  29. #include "url.h"
  30. #include "srtp.h"
  31.  
  32. typedef struct PayloadContext PayloadContext;
  33. typedef struct RTPDynamicProtocolHandler RTPDynamicProtocolHandler;
  34.  
  35. #define RTP_MIN_PACKET_LENGTH 12
  36. #define RTP_MAX_PACKET_LENGTH 8192
  37.  
  38. #define RTP_REORDER_QUEUE_DEFAULT_SIZE 10
  39.  
  40. #define RTP_NOTS_VALUE ((uint32_t)-1)
  41.  
  42. typedef struct RTPDemuxContext RTPDemuxContext;
  43. RTPDemuxContext *ff_rtp_parse_open(AVFormatContext *s1, AVStream *st,
  44.                                    int payload_type, int queue_size);
  45. void ff_rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
  46.                                        RTPDynamicProtocolHandler *handler);
  47. void ff_rtp_parse_set_crypto(RTPDemuxContext *s, const char *suite,
  48.                              const char *params);
  49. int ff_rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
  50.                         uint8_t **buf, int len);
  51. void ff_rtp_parse_close(RTPDemuxContext *s);
  52. int64_t ff_rtp_queued_packet_time(RTPDemuxContext *s);
  53. void ff_rtp_reset_packet_queue(RTPDemuxContext *s);
  54.  
  55. /**
  56.  * Send a dummy packet on both port pairs to set up the connection
  57.  * state in potential NAT routers, so that we're able to receive
  58.  * packets.
  59.  *
  60.  * Note, this only works if the NAT router doesn't remap ports. This
  61.  * isn't a standardized procedure, but it works in many cases in practice.
  62.  *
  63.  * The same routine is used with RDT too, even if RDT doesn't use normal
  64.  * RTP packets otherwise.
  65.  */
  66. void ff_rtp_send_punch_packets(URLContext* rtp_handle);
  67.  
  68. /**
  69.  * some rtp servers assume client is dead if they don't hear from them...
  70.  * so we send a Receiver Report to the provided URLContext or AVIOContext
  71.  * (we don't have access to the rtcp handle from here)
  72.  */
  73. int ff_rtp_check_and_send_back_rr(RTPDemuxContext *s, URLContext *fd,
  74.                                   AVIOContext *avio, int count);
  75. int ff_rtp_send_rtcp_feedback(RTPDemuxContext *s, URLContext *fd,
  76.                               AVIOContext *avio);
  77.  
  78. // these statistics are used for rtcp receiver reports...
  79. typedef struct RTPStatistics {
  80.     uint16_t max_seq;           ///< highest sequence number seen
  81.     uint32_t cycles;            ///< shifted count of sequence number cycles
  82.     uint32_t base_seq;          ///< base sequence number
  83.     uint32_t bad_seq;           ///< last bad sequence number + 1
  84.     int probation;              ///< sequence packets till source is valid
  85.     uint32_t received;          ///< packets received
  86.     uint32_t expected_prior;    ///< packets expected in last interval
  87.     uint32_t received_prior;    ///< packets received in last interval
  88.     uint32_t transit;           ///< relative transit time for previous packet
  89.     uint32_t jitter;            ///< estimated jitter.
  90. } RTPStatistics;
  91.  
  92. #define RTP_FLAG_KEY    0x1 ///< RTP packet contains a keyframe
  93. #define RTP_FLAG_MARKER 0x2 ///< RTP marker bit was set for this packet
  94. /**
  95.  * Packet parsing for "private" payloads in the RTP specs.
  96.  *
  97.  * @param ctx RTSP demuxer context
  98.  * @param s stream context
  99.  * @param st stream that this packet belongs to
  100.  * @param pkt packet in which to write the parsed data
  101.  * @param timestamp pointer to the RTP timestamp of the input data, can be
  102.  *                  updated by the function if returning older, buffered data
  103.  * @param buf pointer to raw RTP packet data
  104.  * @param len length of buf
  105.  * @param seq RTP sequence number of the packet
  106.  * @param flags flags from the RTP packet header (RTP_FLAG_*)
  107.  */
  108. typedef int (*DynamicPayloadPacketHandlerProc)(AVFormatContext *ctx,
  109.                                                PayloadContext *s,
  110.                                                AVStream *st, AVPacket *pkt,
  111.                                                uint32_t *timestamp,
  112.                                                const uint8_t * buf,
  113.                                                int len, uint16_t seq, int flags);
  114.  
  115. struct RTPDynamicProtocolHandler {
  116.     const char enc_name[50];
  117.     enum AVMediaType codec_type;
  118.     enum AVCodecID codec_id;
  119.     int static_payload_id; /* 0 means no payload id is set. 0 is a valid
  120.                             * payload ID (PCMU), too, but that format doesn't
  121.                             * require any custom depacketization code. */
  122.  
  123.     /** Initialize dynamic protocol handler, called after the full rtpmap line is parsed, may be null */
  124.     int (*init)(AVFormatContext *s, int st_index, PayloadContext *priv_data);
  125.     /** Parse the a= line from the sdp field */
  126.     int (*parse_sdp_a_line)(AVFormatContext *s, int st_index,
  127.                             PayloadContext *priv_data, const char *line);
  128.     /** Allocate any data needed by the rtp parsing for this dynamic data. */
  129.     PayloadContext *(*alloc)(void);
  130.     /** Free any data needed by the rtp parsing for this dynamic data. */
  131.     void (*free)(PayloadContext *protocol_data);
  132.     /** Parse handler for this dynamic packet */
  133.     DynamicPayloadPacketHandlerProc parse_packet;
  134.     int (*need_keyframe)(PayloadContext *context);
  135.  
  136.     struct RTPDynamicProtocolHandler *next;
  137. };
  138.  
  139. typedef struct RTPPacket {
  140.     uint16_t seq;
  141.     uint8_t *buf;
  142.     int len;
  143.     int64_t recvtime;
  144.     struct RTPPacket *next;
  145. } RTPPacket;
  146.  
  147. struct RTPDemuxContext {
  148.     AVFormatContext *ic;
  149.     AVStream *st;
  150.     int payload_type;
  151.     uint32_t ssrc;
  152.     uint16_t seq;
  153.     uint32_t timestamp;
  154.     uint32_t base_timestamp;
  155.     uint32_t cur_timestamp;
  156.     int64_t  unwrapped_timestamp;
  157.     int64_t  range_start_offset;
  158.     int max_payload_size;
  159.     /* used to send back RTCP RR */
  160.     char hostname[256];
  161.  
  162.     int srtp_enabled;
  163.     struct SRTPContext srtp;
  164.  
  165.     /** Statistics for this stream (used by RTCP receiver reports) */
  166.     RTPStatistics statistics;
  167.  
  168.     /** Fields for packet reordering @{ */
  169.     int prev_ret;     ///< The return value of the actual parsing of the previous packet
  170.     RTPPacket* queue; ///< A sorted queue of buffered packets not yet returned
  171.     int queue_len;    ///< The number of packets in queue
  172.     int queue_size;   ///< The size of queue, or 0 if reordering is disabled
  173.     /*@}*/
  174.  
  175.     /* rtcp sender statistics receive */
  176.     int64_t last_rtcp_ntp_time;
  177.     int64_t last_rtcp_reception_time;
  178.     int64_t first_rtcp_ntp_time;
  179.     uint32_t last_rtcp_timestamp;
  180.     int64_t rtcp_ts_offset;
  181.  
  182.     /* rtcp sender statistics */
  183.     unsigned int packet_count;
  184.     unsigned int octet_count;
  185.     unsigned int last_octet_count;
  186.     int64_t last_feedback_time;
  187.  
  188.     /* dynamic payload stuff */
  189.     const RTPDynamicProtocolHandler *handler;
  190.     PayloadContext *dynamic_protocol_context;
  191. };
  192.  
  193. void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler);
  194. RTPDynamicProtocolHandler *ff_rtp_handler_find_by_name(const char *name,
  195.                                                   enum AVMediaType codec_type);
  196. RTPDynamicProtocolHandler *ff_rtp_handler_find_by_id(int id,
  197.                                                 enum AVMediaType codec_type);
  198.  
  199. /* from rtsp.c, but used by rtp dynamic protocol handlers. */
  200. int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
  201.                                 char *value, int value_size);
  202.  
  203. int ff_parse_fmtp(AVStream *stream, PayloadContext *data, const char *p,
  204.                   int (*parse_fmtp)(AVStream *stream,
  205.                                     PayloadContext *data,
  206.                                     char *attr, char *value));
  207.  
  208. void av_register_rtp_dynamic_payload_handlers(void);
  209.  
  210. /**
  211.  * Close the dynamic buffer and make a packet from it.
  212.  */
  213. int ff_rtp_finalize_packet(AVPacket *pkt, AVIOContext **dyn_buf, int stream_idx);
  214.  
  215. #endif /* AVFORMAT_RTPDEC_H */
  216.