/*
* RTP H264 Protocol (RFC3984)
- * Copyright (c) 2006 Ryan Martell.
+ * Copyright (c) 2006 Ryan Martell
*
* This file is part of FFmpeg.
*
*/
/**
-* @file rtp_h264.c
+* @file libavformat/rtp_h264.c
* @brief H.264 / RTP Code (RFC3984)
* @author Ryan Martell <rdm4@martellventures.com>
*
*
*/
+#include "libavutil/base64.h"
+#include "libavutil/avstring.h"
+#include "libavcodec/bitstream.h"
#include "avformat.h"
#include "mpegts.h"
-#include "bitstream.h"
#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
+#include "network.h"
#include <assert.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include "rtp_internal.h"
+#include "rtpdec.h"
#include "rtp_h264.h"
-#include "base64.h"
/**
RTP/H264 specific private data.
*/
-typedef struct h264_rtp_extra_data {
+struct PayloadContext {
unsigned long cookie; ///< sanity check, to make sure we get the pointer we're expecting.
//sdp setup parameters
#ifdef DEBUG
int packet_types_received[32];
#endif
-} h264_rtp_extra_data;
+};
#define MAGIC_COOKIE (0xdeadbeef) ///< Cookie for the extradata; to verify we are what we think we are, and that we haven't been freed.
#define DEAD_COOKIE (0xdeaddead) ///< Cookie for the extradata; once it is freed.
/* ---------------- private code */
static void sdp_parse_fmtp_config_h264(AVStream * stream,
- h264_rtp_extra_data * h264_data,
+ PayloadContext * h264_data,
char *attr, char *value)
{
AVCodecContext *codec = stream->codec;
assert(h264_data != NULL);
if (!strcmp(attr, "packetization-mode")) {
- av_log(NULL, AV_LOG_DEBUG, "H.264/RTP Packetization Mode: %d\n", atoi(attr));
- h264_data->packetization_mode = atoi(attr);
+ av_log(NULL, AV_LOG_DEBUG, "H.264/RTP Packetization Mode: %d\n", atoi(value));
+ h264_data->packetization_mode = atoi(value);
/*
Packetization Mode:
0 or not present: Single NAL mode (Only nals from 1-23 are allowed)
}
// return 0 on packet, no more left, 1 on packet, 1 on partial packet...
-static int h264_handle_packet(RTPDemuxContext * s,
+static int h264_handle_packet(AVFormatContext *ctx,
+ PayloadContext *data,
+ AVStream *st,
AVPacket * pkt,
uint32_t * timestamp,
const uint8_t * buf,
- int len)
+ int len, int flags)
{
-// h264_rtp_extra_data *data = s->dynamic_protocol_context;
uint8_t nal = buf[0];
uint8_t type = (nal & 0x1f);
int result= 0;
uint8_t start_sequence[]= {0, 0, 1};
+#ifdef DEBUG
assert(data);
assert(data->cookie == MAGIC_COOKIE);
+#endif
assert(buf);
if (type >= 1 && type <= 23)
int src_len= len;
do {
- uint16_t nal_size = BE_16(src); // this going to be a problem if unaligned (can it be?)
+ uint16_t nal_size = AV_RB16(src); // this going to be a problem if unaligned (can it be?)
// consume the length of the aggregate...
src += 2;
// these are the same as above, we just redo them here for clarity...
uint8_t fu_indicator = nal;
uint8_t fu_header = *buf; // read the fu_header.
- uint8_t start_bit = (fu_header & 0x80) >> 7;
+ uint8_t start_bit = fu_header >> 7;
// uint8_t end_bit = (fu_header & 0x40) >> 6;
uint8_t nal_type = (fu_header & 0x1f);
uint8_t reconstructed_nal;
// reconstruct this packet's true nal; only the data follows..
reconstructed_nal = fu_indicator & (0xe0); // the original nal forbidden bit and NRI are stored in this packet's nal;
- reconstructed_nal |= (nal_type & 0x1f);
+ reconstructed_nal |= nal_type;
// skip the fu_header...
buf++;
#ifdef DEBUG
if (start_bit)
- data->packet_types_received[nal_type & 0x1f]++;
+ data->packet_types_received[nal_type]++;
#endif
if(start_bit) {
// copy in the start sequence, and the reconstructed nal....
}
/* ---------------- public code */
-static void *h264_new_extradata()
+static PayloadContext *h264_new_extradata(void)
{
- h264_rtp_extra_data *data =
- av_mallocz(sizeof(h264_rtp_extra_data) +
+ PayloadContext *data =
+ av_mallocz(sizeof(PayloadContext) +
FF_INPUT_BUFFER_PADDING_SIZE);
if (data) {
return data;
}
-static void h264_free_extradata(void *d)
+static void h264_free_extradata(PayloadContext *data)
{
- h264_rtp_extra_data *data = (h264_rtp_extra_data *) d;
#ifdef DEBUG
int ii;
av_free(data);
}
-static int parse_h264_sdp_line(AVStream * stream, void *data,
- const char *line)
+static int parse_h264_sdp_line(AVFormatContext *s, int st_index,
+ PayloadContext *h264_data, const char *line)
{
+ AVStream *stream = s->streams[st_index];
AVCodecContext *codec = stream->codec;
- h264_rtp_extra_data *h264_data = (h264_rtp_extra_data *) data;
const char *p = line;
assert(h264_data->cookie == MAGIC_COOKIE);
- if (strstart(p, "framesize:", &p)) {
+ if (av_strstart(p, "framesize:", &p)) {
char buf1[50];
char *dst = buf1;
codec->width = atoi(buf1);
codec->height = atoi(p + 1); // skip the -
codec->pix_fmt = PIX_FMT_YUV420P;
- } else if (strstart(p, "fmtp:", &p)) {
+ } else if (av_strstart(p, "fmtp:", &p)) {
char attr[256];
char value[4096];
/* grab the codec extra_data from the config parameter of the fmtp line */
sdp_parse_fmtp_config_h264(stream, h264_data, attr, value);
}
- } else if (strstart(p, "cliprect:", &p)) {
+ } else if (av_strstart(p, "cliprect:", &p)) {
// could use this if we wanted.
}