FFmpeg
rtpdec_asf.c
Go to the documentation of this file.
1 /*
2  * Microsoft RTP/ASF support.
3  * Copyright (c) 2008 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 Microsoft RTP/ASF support
25  * @author Ronald S. Bultje <rbultje@ronald.bitfreak.net>
26  */
27 
28 #include "libavutil/base64.h"
29 #include "libavutil/avstring.h"
30 #include "libavutil/intreadwrite.h"
31 #include "rtp.h"
32 #include "rtpdec_formats.h"
33 #include "rtsp.h"
34 #include "asf.h"
35 #include "avio_internal.h"
36 #include "internal.h"
37 
38 /**
39  * From MSDN 2.2.1.4, we learn that ASF data packets over RTP should not
40  * contain any padding. Unfortunately, the header min/max_pktsize are not
41  * updated (thus making min_pktsize invalid). Here, we "fix" these faulty
42  * min_pktsize values in the ASF file header.
43  * @return 0 on success, <0 on failure (currently -1).
44  */
45 static int rtp_asf_fix_header(uint8_t *buf, int len)
46 {
47  uint8_t *p = buf, *end = buf + len;
48 
49  if (len < sizeof(ff_asf_guid) * 2 + 22 ||
50  memcmp(p, ff_asf_header, sizeof(ff_asf_guid))) {
51  return -1;
52  }
53  p += sizeof(ff_asf_guid) + 14;
54  do {
55  uint64_t chunksize = AV_RL64(p + sizeof(ff_asf_guid));
56  int skip = 6 * 8 + 3 * 4 + sizeof(ff_asf_guid) * 2;
57  if (memcmp(p, ff_asf_file_header, sizeof(ff_asf_guid))) {
58  if (chunksize > end - p)
59  return -1;
60  p += chunksize;
61  continue;
62  }
63 
64  if (end - p < 8 + skip)
65  break;
66  /* skip most of the file header, to min_pktsize */
67  p += skip;
68  if (AV_RL32(p) == AV_RL32(p + 4)) {
69  /* and set that to zero */
70  AV_WL32(p, 0);
71  return 0;
72  }
73  break;
74  } while (end - p >= sizeof(ff_asf_guid) + 8);
75 
76  return -1;
77 }
78 
79 /**
80  * The following code is basically a buffered AVIOContext,
81  * with the added benefit of returning -EAGAIN (instead of 0)
82  * on packet boundaries, such that the ASF demuxer can return
83  * safely and resume business at the next packet.
84  */
85 static int packetizer_read(void *opaque, uint8_t *buf, int buf_size)
86 {
87  return AVERROR(EAGAIN);
88 }
89 
90 static void init_packetizer(AVIOContext *pb, uint8_t *buf, int len)
91 {
93 
94  /* this "fills" the buffer with its current content */
95  pb->pos = len;
96  pb->buf_end = buf + len;
97 }
98 
100 {
101  int ret = 0;
102  if (av_strstart(p, "pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,", &p)) {
103  AVIOContext pb = { 0 };
104  RTSPState *rt = s->priv_data;
106  int len = strlen(p) * 6 / 8;
107  char *buf = av_mallocz(len);
108  const AVInputFormat *iformat;
109 
110  if (!buf)
111  return AVERROR(ENOMEM);
112  av_base64_decode(buf, p, len);
113 
114  if (rtp_asf_fix_header(buf, len) < 0)
116  "Failed to fix invalid RTSP-MS/ASF min_pktsize\n");
117  init_packetizer(&pb, buf, len);
118  if (rt->asf_ctx) {
120  }
121 
122  if (!(iformat = av_find_input_format("asf")))
124 
126  if (!rt->asf_ctx) {
127  av_free(buf);
128  return AVERROR(ENOMEM);
129  }
130  rt->asf_ctx->pb = &pb;
131  av_dict_set(&opts, "no_resync_search", "1", 0);
132 
133  if ((ret = ff_copy_whiteblacklists(rt->asf_ctx, s)) < 0) {
134  av_dict_free(&opts);
135  return ret;
136  }
137 
138  ret = avformat_open_input(&rt->asf_ctx, "", iformat, &opts);
139  av_dict_free(&opts);
140  if (ret < 0) {
141  av_free(pb.buffer);
142  return ret;
143  }
144  av_dict_copy(&s->metadata, rt->asf_ctx->metadata, 0);
145  rt->asf_pb_pos = avio_tell(&pb);
146  av_free(pb.buffer);
147  rt->asf_ctx->pb = NULL;
148  }
149  return ret;
150 }
151 
152 static int asfrtp_parse_sdp_line(AVFormatContext *s, int stream_index,
153  PayloadContext *asf, const char *line)
154 {
155  if (stream_index < 0)
156  return 0;
157  if (av_strstart(line, "stream:", &line)) {
158  RTSPState *rt = s->priv_data;
159 
160  s->streams[stream_index]->id = strtol(line, NULL, 10);
161 
162  if (rt->asf_ctx) {
163  int i;
164 
165  for (i = 0; i < rt->asf_ctx->nb_streams; i++) {
166  if (s->streams[stream_index]->id == rt->asf_ctx->streams[i]->id) {
167  avcodec_parameters_copy(s->streams[stream_index]->codecpar,
168  rt->asf_ctx->streams[i]->codecpar);
169  s->streams[stream_index]->internal->need_parsing =
171  avpriv_set_pts_info(s->streams[stream_index], 32, 1, 1000);
172  }
173  }
174  }
175  }
176 
177  return 0;
178 }
179 
180 struct PayloadContext {
182  uint8_t *buf;
183 };
184 
185 /**
186  * @return 0 when a packet was written into /p pkt, and no more data is left;
187  * 1 when a packet was written into /p pkt, and more packets might be left;
188  * <0 when not enough data was provided to return a full packet, or on error.
189  */
191  AVStream *st, AVPacket *pkt,
192  uint32_t *timestamp,
193  const uint8_t *buf, int len, uint16_t seq,
194  int flags)
195 {
196  AVIOContext *pb = &asf->pb;
197  int res, mflags, len_off;
198  RTSPState *rt = s->priv_data;
199 
200  if (!rt->asf_ctx)
201  return -1;
202 
203  if (len > 0) {
204  int off, out_len = 0;
205 
206  if (len < 4)
207  return -1;
208 
209  av_freep(&asf->buf);
210 
211  ffio_init_context(pb, (uint8_t *)buf, len, 0, NULL, NULL, NULL, NULL);
212 
213  while (avio_tell(pb) + 4 < len) {
214  int start_off = avio_tell(pb);
215 
216  mflags = avio_r8(pb);
217  len_off = avio_rb24(pb);
218  if (mflags & 0x20) /**< relative timestamp */
219  avio_skip(pb, 4);
220  if (mflags & 0x10) /**< has duration */
221  avio_skip(pb, 4);
222  if (mflags & 0x8) /**< has location ID */
223  avio_skip(pb, 4);
224  off = avio_tell(pb);
225 
226  if (!(mflags & 0x40)) {
227  /**
228  * If 0x40 is not set, the len_off field specifies an offset
229  * of this packet's payload data in the complete (reassembled)
230  * ASF packet. This is used to spread one ASF packet over
231  * multiple RTP packets.
232  */
233  if (asf->pktbuf && len_off != avio_tell(asf->pktbuf)) {
234  ffio_free_dyn_buf(&asf->pktbuf);
235  }
236  if (!len_off && !asf->pktbuf &&
237  (res = avio_open_dyn_buf(&asf->pktbuf)) < 0)
238  return res;
239  if (!asf->pktbuf)
240  return AVERROR(EIO);
241 
242  avio_write(asf->pktbuf, buf + off, len - off);
243  avio_skip(pb, len - off);
244  if (!(flags & RTP_FLAG_MARKER))
245  return -1;
246  out_len = avio_close_dyn_buf(asf->pktbuf, &asf->buf);
247  asf->pktbuf = NULL;
248  } else {
249  /**
250  * If 0x40 is set, the len_off field specifies the length of
251  * the next ASF packet that can be read from this payload
252  * data alone. This is commonly the same as the payload size,
253  * but could be less in case of packet splitting (i.e.
254  * multiple ASF packets in one RTP packet).
255  */
256 
257  int cur_len = start_off + len_off - off;
258  int prev_len = out_len;
259  out_len += cur_len;
260  if (FFMIN(cur_len, len - off) < 0)
261  return -1;
262  if ((res = av_reallocp(&asf->buf, out_len)) < 0)
263  return res;
264  memcpy(asf->buf + prev_len, buf + off,
265  FFMIN(cur_len, len - off));
266  avio_skip(pb, cur_len);
267  }
268  }
269 
270  init_packetizer(pb, asf->buf, out_len);
271  pb->pos += rt->asf_pb_pos;
272  pb->eof_reached = 0;
273  rt->asf_ctx->pb = pb;
274  }
275 
276  for (;;) {
277  int i;
278 
279  res = ff_read_packet(rt->asf_ctx, pkt);
280  rt->asf_pb_pos = avio_tell(pb);
281  if (res != 0)
282  break;
283  for (i = 0; i < s->nb_streams; i++) {
284  if (s->streams[i]->id == rt->asf_ctx->streams[pkt->stream_index]->id) {
285  pkt->stream_index = i;
286  return 1; // FIXME: return 0 if last packet
287  }
288  }
290  }
291 
292  return res == 1 ? -1 : res;
293 }
294 
296 {
297  ffio_free_dyn_buf(&asf->pktbuf);
298  av_freep(&asf->buf);
299 }
300 
301 #define RTP_ASF_HANDLER(n, s, t) \
302 const RTPDynamicProtocolHandler ff_ms_rtp_ ## n ## _handler = { \
303  .enc_name = s, \
304  .codec_type = t, \
305  .codec_id = AV_CODEC_ID_NONE, \
306  .priv_data_size = sizeof(PayloadContext), \
307  .parse_sdp_a_line = asfrtp_parse_sdp_line, \
308  .close = asfrtp_close_context, \
309  .parse_packet = asfrtp_parse_packet, \
310 }
311 
312 RTP_ASF_HANDLER(asf_pfv, "x-asf-pf", AVMEDIA_TYPE_VIDEO);
313 RTP_ASF_HANDLER(asf_pfa, "x-asf-pf", AVMEDIA_TYPE_AUDIO);
packetizer_read
static int packetizer_read(void *opaque, uint8_t *buf, int buf_size)
The following code is basically a buffered AVIOContext, with the added benefit of returning -EAGAIN (...
Definition: rtpdec_asf.c:85
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:404
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
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
rtpdec_formats.h
asfrtp_close_context
static void asfrtp_close_context(PayloadContext *asf)
Definition: rtpdec_asf.c:295
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1175
RTP_FLAG_MARKER
#define RTP_FLAG_MARKER
RTP marker bit was set for this packet.
Definition: rtpdec.h:94
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1009
AVDictionary
Definition: dict.c:30
RTSPState::asf_ctx
AVFormatContext * asf_ctx
The following are used for RTP/ASF streams.
Definition: rtsp.h:316
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4347
AVIOContext::pos
int64_t pos
position in the file of the current buffer
Definition: avio.h:238
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:538
ff_read_packet
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: utils.c:769
rtsp.h
avio_close_dyn_buf
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1407
PayloadContext::pktbuf
AVIOContext * pktbuf
Definition: rtpdec_asf.c:181
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1336
AVInputFormat
Definition: avformat.h:626
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:483
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1362
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
init_packetizer
static void init_packetizer(AVIOContext *pb, uint8_t *buf, int len)
Definition: rtpdec_asf.c:90
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
RTP_ASF_HANDLER
#define RTP_ASF_HANDLER(n, s, t)
Definition: rtpdec_asf.c:301
AVERROR_DEMUXER_NOT_FOUND
#define AVERROR_DEMUXER_NOT_FOUND
Demuxer not found.
Definition: error.h:55
AVFormatContext
Format I/O context.
Definition: avformat.h:1107
internal.h
opts
AVDictionary * opts
Definition: movenc.c:50
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:994
NULL
#define NULL
Definition: coverity.c:32
RTSPState::asf_pb_pos
uint64_t asf_pb_pos
cache for position of the asf demuxer, since we load a new data packet in the bytecontext for each in...
Definition: rtsp.h:320
ff_asf_guid
uint8_t ff_asf_guid[16]
Definition: riff.h:95
ff_asf_header
const ff_asf_guid ff_asf_header
Definition: asf.c:25
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1149
av_base64_decode
int av_base64_decode(uint8_t *out, const char *in_str, int out_size)
Decode a base64-encoded string.
Definition: base64.c:79
base64.h
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1163
asfrtp_parse_sdp_line
static int asfrtp_parse_sdp_line(AVFormatContext *s, int stream_index, PayloadContext *asf, const char *line)
Definition: rtpdec_asf.c:152
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:78
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:757
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:166
AVIOContext::buf_end
unsigned char * buf_end
End of the data, may be less than buffer+buffer_size if the read function returned less data than req...
Definition: avio.h:229
RTSPState
Private data for the RTSP demuxer.
Definition: rtsp.h:227
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:4800
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:146
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:167
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:215
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:607
line
Definition: graph2dot.c:48
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:34
rtp.h
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:266
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:72
i
int i
Definition: input.c:406
avio_internal.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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:243
len
int len
Definition: vorbis_enc_data.h:426
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1437
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:854
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:847
AVStreamInternal::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:384
ff_wms_parse_sdp_a_line
int ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p)
Parse a Windows Media Server-specific SDP line.
Definition: rtpdec_asf.c:99
asf.h
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
PayloadContext::buf
uint8_t * buf
the temporary storage buffer
Definition: rtpdec_asf.c:182
PayloadContext::pb
AVIOContext pb
Definition: rtpdec_asf.c:181
rtp_asf_fix_header
static int rtp_asf_fix_header(uint8_t *buf, int len)
From MSDN 2.2.1.4, we learn that ASF data packets over RTP should not contain any padding.
Definition: rtpdec_asf.c:45
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
av_find_input_format
const AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:118
AVPacket::stream_index
int stream_index
Definition: packet.h:375
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:327
ff_asf_file_header
const ff_asf_guid ff_asf_file_header
Definition: asf.c:29
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVIOContext::buffer
unsigned char * buffer
Start of the buffer.
Definition: avio.h:226
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVPacket
This structure stores compressed data.
Definition: packet.h:350
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
avstring.h
PayloadContext
RTP/JPEG specific private data.
Definition: rdt.c:83
asfrtp_parse_packet
static int asfrtp_parse_packet(AVFormatContext *s, PayloadContext *asf, AVStream *st, AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len, uint16_t seq, int flags)
Definition: rtpdec_asf.c:190