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(FFIOContext *pb, uint8_t *buf, int len)
91 {
93 
94  /* this "fills" the buffer with its current content */
95  pb->pub.pos = len;
96  pb->pub.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  FFIOContext pb;
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.pub;
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.pub.buffer);
142  return ret;
143  }
144  av_dict_copy(&s->metadata, rt->asf_ctx->metadata, 0);
145  rt->asf_pb_pos = avio_tell(&pb.pub);
146  av_free(pb.pub.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  ffstream(s->streams[stream_index])->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 {
183  uint8_t *buf;
184 };
185 
186 /**
187  * @return 0 when a packet was written into /p pkt, and no more data is left;
188  * 1 when a packet was written into /p pkt, and more packets might be left;
189  * <0 when not enough data was provided to return a full packet, or on error.
190  */
192  AVStream *st, AVPacket *pkt,
193  uint32_t *timestamp,
194  const uint8_t *buf, int len, uint16_t seq,
195  int flags)
196 {
197  FFIOContext *const pb0 = &asf->pb;
198  AVIOContext *const pb = &pb0->pub;
199  int res, mflags, len_off;
200  RTSPState *rt = s->priv_data;
201 
202  if (!rt->asf_ctx)
203  return -1;
204 
205  if (len > 0) {
206  int off, out_len = 0;
207 
208  if (len < 4)
209  return -1;
210 
211  av_freep(&asf->buf);
212 
213  ffio_init_context(pb0, (uint8_t *)buf, len, 0, NULL, NULL, NULL, NULL);
214 
215  while (avio_tell(pb) + 4 < len) {
216  int start_off = avio_tell(pb);
217 
218  mflags = avio_r8(pb);
219  len_off = avio_rb24(pb);
220  if (mflags & 0x20) /**< relative timestamp */
221  avio_skip(pb, 4);
222  if (mflags & 0x10) /**< has duration */
223  avio_skip(pb, 4);
224  if (mflags & 0x8) /**< has location ID */
225  avio_skip(pb, 4);
226  off = avio_tell(pb);
227 
228  if (!(mflags & 0x40)) {
229  /**
230  * If 0x40 is not set, the len_off field specifies an offset
231  * of this packet's payload data in the complete (reassembled)
232  * ASF packet. This is used to spread one ASF packet over
233  * multiple RTP packets.
234  */
235  if (asf->pktbuf && len_off != avio_tell(asf->pktbuf)) {
236  ffio_free_dyn_buf(&asf->pktbuf);
237  }
238  if (!len_off && !asf->pktbuf &&
239  (res = avio_open_dyn_buf(&asf->pktbuf)) < 0)
240  return res;
241  if (!asf->pktbuf)
242  return AVERROR(EIO);
243 
244  avio_write(asf->pktbuf, buf + off, len - off);
245  avio_skip(pb, len - off);
246  if (!(flags & RTP_FLAG_MARKER))
247  return -1;
248  out_len = avio_close_dyn_buf(asf->pktbuf, &asf->buf);
249  asf->pktbuf = NULL;
250  } else {
251  /**
252  * If 0x40 is set, the len_off field specifies the length of
253  * the next ASF packet that can be read from this payload
254  * data alone. This is commonly the same as the payload size,
255  * but could be less in case of packet splitting (i.e.
256  * multiple ASF packets in one RTP packet).
257  */
258 
259  int cur_len = start_off + len_off - off;
260  int prev_len = out_len;
261  out_len += cur_len;
262  if (FFMIN(cur_len, len - off) < 0)
263  return -1;
264  if ((res = av_reallocp(&asf->buf, out_len)) < 0)
265  return res;
266  memcpy(asf->buf + prev_len, buf + off,
267  FFMIN(cur_len, len - off));
268  avio_skip(pb, cur_len);
269  }
270  }
271 
272  init_packetizer(pb0, asf->buf, out_len);
273  pb->pos += rt->asf_pb_pos;
274  pb->eof_reached = 0;
275  rt->asf_ctx->pb = pb;
276  }
277 
278  for (;;) {
279  int i;
280 
281  res = ff_read_packet(rt->asf_ctx, pkt);
282  rt->asf_pb_pos = avio_tell(pb);
283  if (res != 0)
284  break;
285  for (i = 0; i < s->nb_streams; i++) {
286  if (s->streams[i]->id == rt->asf_ctx->streams[pkt->stream_index]->id) {
287  pkt->stream_index = i;
288  return 1; // FIXME: return 0 if last packet
289  }
290  }
292  }
293 
294  return res == 1 ? -1 : res;
295 }
296 
298 {
299  ffio_free_dyn_buf(&asf->pktbuf);
300  av_freep(&asf->buf);
301 }
302 
303 #define RTP_ASF_HANDLER(n, s, t) \
304 const RTPDynamicProtocolHandler ff_ms_rtp_ ## n ## _handler = { \
305  .enc_name = s, \
306  .codec_type = t, \
307  .codec_id = AV_CODEC_ID_NONE, \
308  .priv_data_size = sizeof(PayloadContext), \
309  .parse_sdp_a_line = asfrtp_parse_sdp_line, \
310  .close = asfrtp_close_context, \
311  .parse_packet = asfrtp_parse_packet, \
312 }
313 
314 RTP_ASF_HANDLER(asf_pfv, "x-asf-pf", AVMEDIA_TYPE_VIDEO);
315 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:417
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:297
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1177
RTP_FLAG_MARKER
#define RTP_FLAG_MARKER
RTP marker bit was set for this packet.
Definition: rtpdec.h:94
AVDictionary
Definition: dict.c:30
FFIOContext
Definition: avio_internal.h:29
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: demux.c:355
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:429
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:486
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:1470
PayloadContext::pktbuf
AVIOContext * pktbuf
Definition: rtpdec_asf.c:182
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:1338
AVInputFormat
Definition: avformat.h:638
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: demux.c:207
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1425
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
RTP_ASF_HANDLER
#define RTP_ASF_HANDLER(n, s, t)
Definition: rtpdec_asf.c:303
PayloadContext::pb
FFIOContext pb
Definition: rtpdec_asf.c:181
AVERROR_DEMUXER_NOT_FOUND
#define AVERROR_DEMUXER_NOT_FOUND
Demuxer not found.
Definition: error.h:55
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:402
AVFormatContext
Format I/O context.
Definition: avformat.h:1109
internal.h
opts
AVDictionary * opts
Definition: movenc.c:50
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1004
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:1151
init_packetizer
static void init_packetizer(FFIOContext *pb, uint8_t *buf, int len)
Definition: rtpdec_asf.c:90
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:1165
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
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:766
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:154
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
FFIOContext::pub
AVIOContext pub
Definition: avio_internal.h:30
RTSPState
Private data for the RTSP demuxer.
Definition: rtsp.h:227
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:114
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:185
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:616
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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
avio_internal.h
ff_read_packet
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: demux.c:524
ffio_init_context
void ffio_init_context(FFIOContext *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:80
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:263
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:1498
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:864
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:857
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:183
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
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, 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:1146
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:333
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:191