FFmpeg
rtpdec_qt.c
Go to the documentation of this file.
1 /*
2  * RTP/Quicktime support.
3  * Copyright (c) 2009 Ronald S. Bultje
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * @brief Quicktime-style RTP support
25  * @author Ronald S. Bultje <rbultje@ronald.bitfreak.net>
26  */
27 
28 #include "avformat.h"
29 #include "internal.h"
30 #include "avio_internal.h"
31 #include "rtp.h"
32 #include "rtpdec.h"
33 #include "isom.h"
34 #include "libavcodec/get_bits.h"
35 
36 struct PayloadContext {
39  uint32_t timestamp;
40 };
41 
43  AVStream *st, AVPacket *pkt,
44  uint32_t *timestamp, const uint8_t *buf,
45  int len, uint16_t seq, int flags)
46 {
47  AVIOContext pb;
48  GetBitContext gb;
49  int packing_scheme, has_payload_desc, has_packet_info, alen,
50  has_marker_bit = flags & RTP_FLAG_MARKER,
51  keyframe, ret;
52 
53  if (qt->remaining) {
54  int num = qt->pkt.size / qt->bytes_per_frame;
55 
56  if ((ret = av_new_packet(pkt, qt->bytes_per_frame)) < 0)
57  return ret;
58  pkt->stream_index = st->index;
59  pkt->flags = qt->pkt.flags;
60  memcpy(pkt->data,
61  &qt->pkt.data[(num - qt->remaining) * qt->bytes_per_frame],
62  qt->bytes_per_frame);
63  if (--qt->remaining == 0) {
64  av_freep(&qt->pkt.data);
65  qt->pkt.size = 0;
66  }
67  return qt->remaining > 0;
68  }
69 
70  /**
71  * The RTP payload is described in:
72  * http://developer.apple.com/quicktime/icefloe/dispatch026.html
73  */
74  init_get_bits(&gb, buf, len << 3);
75  ffio_init_context(&pb, (uint8_t*)buf, len, 0, NULL, NULL, NULL, NULL);
76 
77  if (len < 4)
78  return AVERROR_INVALIDDATA;
79 
80  skip_bits(&gb, 4); // version
81  if ((packing_scheme = get_bits(&gb, 2)) == 0)
82  return AVERROR_INVALIDDATA;
83  keyframe = get_bits1(&gb);
84  has_payload_desc = get_bits1(&gb);
85  has_packet_info = get_bits1(&gb);
86  skip_bits(&gb, 23); // reserved:7, cache payload info:1, payload ID:15
87 
88  if (has_payload_desc) {
89  int data_len, pos, is_start, is_finish;
90  uint32_t tag;
91 
92  pos = get_bits_count(&gb) >> 3;
93  if (pos + 12 > len)
94  return AVERROR_INVALIDDATA;
95 
96  skip_bits(&gb, 2); // has non-I-frames:1, is sparse:1
97  is_start = get_bits1(&gb);
98  is_finish = get_bits1(&gb);
99  if (!is_start || !is_finish) {
100  avpriv_request_sample(s, "RTP-X-QT with payload description "
101  "split over several packets");
102  return AVERROR_PATCHWELCOME;
103  }
104  skip_bits(&gb, 12); // reserved
105  data_len = get_bits(&gb, 16);
106 
107  avio_seek(&pb, pos + 4, SEEK_SET);
108  tag = avio_rl32(&pb);
109  if ((st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
110  tag != MKTAG('v','i','d','e')) ||
112  tag != MKTAG('s','o','u','n')))
113  return AVERROR_INVALIDDATA;
114  avpriv_set_pts_info(st, 32, 1, avio_rb32(&pb));
115 
116  if (pos + data_len > len)
117  return AVERROR_INVALIDDATA;
118  /* TLVs */
119  while (avio_tell(&pb) + 4 < pos + data_len) {
120  int tlv_len = avio_rb16(&pb);
121  tag = avio_rl16(&pb);
122  if (avio_tell(&pb) + tlv_len > pos + data_len)
123  return AVERROR_INVALIDDATA;
124 
125 #define MKTAG16(a,b) MKTAG(a,b,0,0)
126  switch (tag) {
127  case MKTAG16('s','d'): {
128  MOVStreamContext *msc;
129  void *priv_data = st->priv_data;
130  int nb_streams = s->nb_streams;
131  MOVContext *mc = av_mallocz(sizeof(*mc));
132  if (!mc)
133  return AVERROR(ENOMEM);
134  mc->fc = s;
135  st->priv_data = msc = av_mallocz(sizeof(MOVStreamContext));
136  if (!msc) {
137  av_free(mc);
138  st->priv_data = priv_data;
139  return AVERROR(ENOMEM);
140  }
141  /* ff_mov_read_stsd_entries updates stream s->nb_streams-1,
142  * so set it temporarily to indicate which stream to update. */
143  s->nb_streams = st->index + 1;
144  ff_mov_read_stsd_entries(mc, &pb, 1);
145  qt->bytes_per_frame = msc->bytes_per_frame;
146  av_free(msc);
147  av_free(mc);
148  st->priv_data = priv_data;
149  s->nb_streams = nb_streams;
150  break;
151  }
152  default:
153  avio_skip(&pb, tlv_len);
154  break;
155  }
156  }
157 
158  /* 32-bit alignment */
159  avio_skip(&pb, ((avio_tell(&pb) + 3) & ~3) - avio_tell(&pb));
160  } else
161  avio_seek(&pb, 4, SEEK_SET);
162 
163  if (has_packet_info) {
164  avpriv_request_sample(s, "RTP-X-QT with packet-specific info");
165  return AVERROR_PATCHWELCOME;
166  }
167 
168  alen = len - avio_tell(&pb);
169  if (alen <= 0)
170  return AVERROR_INVALIDDATA;
171 
172  switch (packing_scheme) {
173  case 3: /* one data packet spread over 1 or multiple RTP packets */
174  if (qt->pkt.size > 0 && qt->timestamp == *timestamp) {
175  int err;
176  if ((err = av_reallocp(&qt->pkt.data, qt->pkt.size + alen +
178  qt->pkt.size = 0;
179  return err;
180  }
181  } else {
182  av_freep(&qt->pkt.data);
183  av_init_packet(&qt->pkt);
185  if (!qt->pkt.data)
186  return AVERROR(ENOMEM);
187  qt->pkt.size = 0;
188  qt->timestamp = *timestamp;
189  }
190  memcpy(qt->pkt.data + qt->pkt.size, buf + avio_tell(&pb), alen);
191  qt->pkt.size += alen;
192  if (has_marker_bit) {
193  int ret = av_packet_from_data(pkt, qt->pkt.data, qt->pkt.size);
194  if (ret < 0)
195  return ret;
196 
197  qt->pkt.size = 0;
198  qt->pkt.data = NULL;
199  pkt->flags = keyframe ? AV_PKT_FLAG_KEY : 0;
200  pkt->stream_index = st->index;
201  memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
202  return 0;
203  }
204  return AVERROR(EAGAIN);
205 
206  case 1: /* constant packet size, multiple packets per RTP packet */
207  if (qt->bytes_per_frame == 0 ||
208  alen % qt->bytes_per_frame != 0)
209  return AVERROR_INVALIDDATA; /* wrongly padded */
210  qt->remaining = (alen / qt->bytes_per_frame) - 1;
211  if ((ret = av_new_packet(pkt, qt->bytes_per_frame)) < 0)
212  return ret;
213  memcpy(pkt->data, buf + avio_tell(&pb), qt->bytes_per_frame);
214  pkt->flags = keyframe ? AV_PKT_FLAG_KEY : 0;
215  pkt->stream_index = st->index;
216  if (qt->remaining > 0) {
217  av_freep(&qt->pkt.data);
218  qt->pkt.data = av_realloc(NULL, qt->remaining * qt->bytes_per_frame);
219  if (!qt->pkt.data) {
221  return AVERROR(ENOMEM);
222  }
223  qt->pkt.size = qt->remaining * qt->bytes_per_frame;
224  memcpy(qt->pkt.data,
225  buf + avio_tell(&pb) + qt->bytes_per_frame,
226  qt->remaining * qt->bytes_per_frame);
227  qt->pkt.flags = pkt->flags;
228  return 1;
229  }
230  return 0;
231 
232  default: /* unimplemented */
233  avpriv_request_sample(NULL, "RTP-X-QT with packing scheme 2");
234  return AVERROR_PATCHWELCOME;
235  }
236 }
237 
238 static void qt_rtp_close(PayloadContext *qt)
239 {
240  av_freep(&qt->pkt.data);
241 }
242 
243 #define RTP_QT_HANDLER(m, n, s, t) \
244 RTPDynamicProtocolHandler ff_ ## m ## _rtp_ ## n ## _handler = { \
245  .enc_name = s, \
246  .codec_type = t, \
247  .codec_id = AV_CODEC_ID_NONE, \
248  .priv_data_size = sizeof(PayloadContext), \
249  .close = qt_rtp_close, \
250  .parse_packet = qt_rtp_parse_packet, \
251 }
252 
253 RTP_QT_HANDLER(qt, vid, "X-QT", AVMEDIA_TYPE_VIDEO);
255 RTP_QT_HANDLER(quicktime, vid, "X-QUICKTIME", AVMEDIA_TYPE_VIDEO);
256 RTP_QT_HANDLER(quicktime, aud, "X-QUICKTIME", AVMEDIA_TYPE_AUDIO);
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:605
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVStream::priv_data
void * priv_data
Definition: avformat.h:880
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:406
PayloadContext::pkt
AVPacket pkt
Definition: rtpdec_qt.c:37
MOVStreamContext
Definition: isom.h:158
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
RTP_FLAG_MARKER
#define RTP_FLAG_MARKER
RTP marker bit was set for this packet.
Definition: rtpdec.h:93
AVPacket::data
uint8_t * data
Definition: packet.h:355
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:388
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
PayloadContext::timestamp
uint32_t timestamp
current frame timestamp
Definition: rtpdec_ac3.c:31
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
GetBitContext
Definition: get_bits.h:61
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
MOVContext
Definition: isom.h:246
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:731
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:778
s
#define s(width, name)
Definition: cbs_vp9.c:257
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:88
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
PayloadContext::bytes_per_frame
int bytes_per_frame
Definition: rtpdec_qt.c:38
get_bits.h
nb_streams
static int nb_streams
Definition: ffprobe.c:282
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1012
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
isom.h
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
rtpdec.h
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:1006
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:747
av_packet_from_data
int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size)
Initialize a reference-counted packet from av_malloc()ed data.
Definition: avpacket.c:155
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
ffio_init_context
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:76
AVPacket::size
int size
Definition: packet.h:356
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4948
av_reallocp
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:161
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:361
rtp.h
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
RTP_QT_HANDLER
#define RTP_QT_HANDLER(m, n, s, t)
Definition: rtpdec_qt.c:243
MOVStreamContext::bytes_per_frame
unsigned int bytes_per_frame
Definition: isom.h:196
avio_internal.h
uint8_t
uint8_t
Definition: audio_convert.c:194
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
len
int len
Definition: vorbis_enc_data.h:452
tag
uint32_t tag
Definition: movenc.c:1532
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:865
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:763
qt_rtp_close
static void qt_rtp_close(PayloadContext *qt)
Definition: rtpdec_qt.c:238
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:866
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
PayloadContext::remaining
int remaining
Definition: rtpdec_qt.c:38
AVPacket::stream_index
int stream_index
Definition: packet.h:357
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
MKTAG16
#define MKTAG16(a, b)
AVPacket
This structure stores compressed data.
Definition: packet.h:332
ff_mov_read_stsd_entries
int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
Definition: mov.c:2483
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
qt_rtp_parse_packet
static int qt_rtp_parse_packet(AVFormatContext *s, PayloadContext *qt, AVStream *st, AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len, uint16_t seq, int flags)
Definition: rtpdec_qt.c:42
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
PayloadContext
RTP/JPEG specific private data.
Definition: rdt.c:83
av_init_packet
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
mc
#define mc
Definition: vf_colormatrix.c:102