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 {
48  GetBitContext gb;
49  int packing_scheme, has_payload_desc, has_packet_info, alen,
50  has_marker_bit = flags & RTP_FLAG_MARKER,
51  keyframe;
52 
53  if (qt->remaining) {
54  int num = qt->pkt.size / qt->bytes_per_frame;
55 
56  if (av_new_packet(pkt, qt->bytes_per_frame))
57  return AVERROR(ENOMEM);
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 (av_new_packet(pkt, qt->bytes_per_frame))
212  return AVERROR(ENOMEM);
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) {
220  av_packet_unref(pkt);
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);
AVPacket pkt
Definition: rtpdec_qt.c:37
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:135
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
int bytes_per_frame
Definition: rtpdec_qt.c:38
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:4929
RTP/JPEG specific private data.
Definition: rdt.c:83
#define avpriv_request_sample(...)
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
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1481
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
void * priv_data
Definition: avformat.h:896
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:334
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:788
#define MKTAG16(a, b)
Format I/O context.
Definition: avformat.h:1358
uint8_t
static int nb_streams
Definition: ffprobe.c:280
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:803
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:152
uint8_t * data
Definition: avcodec.h:1480
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
uint32_t tag
Definition: movenc.c:1531
bitstream reader API header.
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:86
uint32_t timestamp
current frame timestamp
Definition: rtpdec_ac3.c:31
#define RTP_FLAG_MARKER
RTP marker bit was set for this packet.
Definition: rtpdec.h:93
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:772
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
AVFormatContext * fc
Definition: isom.h:247
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
static void qt_rtp_close(PayloadContext *qt)
Definition: rtpdec_qt.c:238
#define s(width, name)
Definition: cbs_vp9.c:257
#define RTP_QT_HANDLER(m, n, s, t)
Definition: rtpdec_qt.c:243
#define mc
Stream structure.
Definition: avformat.h:881
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
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:163
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
uint8_t * buf
the temporary storage buffer
Definition: rtpdec_asf.c:183
int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
Definition: mov.c:2462
#define flags(name, subs,...)
Definition: cbs_av1.c:561
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:756
Main libavformat public API header.
unsigned int bytes_per_frame
Definition: isom.h:195
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:81
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:793
#define av_free(p)
#define av_freep(p)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
int stream_index
Definition: avcodec.h:1482
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
#define MKTAG(a, b, c, d)
Definition: common.h:366
AVIOContext pb
Definition: rtpdec_asf.c:182
This structure stores compressed data.
Definition: avcodec.h:1457