FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 "libavutil/mem.h"
32 #include "rtpdec_formats.h"
33 #include "rtsp.h"
34 #include "asf.h"
35 #include "avio_internal.h"
36 #include "demux.h"
37 #include "internal.h"
38 
39 /**
40  * From MSDN 2.2.1.4, we learn that ASF data packets over RTP should not
41  * contain any padding. Unfortunately, the header min/max_pktsize are not
42  * updated (thus making min_pktsize invalid). Here, we "fix" these faulty
43  * min_pktsize values in the ASF file header.
44  * @return 0 on success, <0 on failure (currently -1).
45  */
46 static int rtp_asf_fix_header(uint8_t *buf, int len)
47 {
48  uint8_t *p = buf, *end = buf + len;
49 
50  if (len < sizeof(ff_asf_guid) * 2 + 22 ||
51  memcmp(p, ff_asf_header, sizeof(ff_asf_guid))) {
52  return -1;
53  }
54  p += sizeof(ff_asf_guid) + 14;
55  do {
56  uint64_t chunksize = AV_RL64(p + sizeof(ff_asf_guid));
57  int skip = 6 * 8 + 3 * 4 + sizeof(ff_asf_guid) * 2;
58  if (memcmp(p, ff_asf_file_header, sizeof(ff_asf_guid))) {
59  if (chunksize > end - p)
60  return -1;
61  p += chunksize;
62  continue;
63  }
64 
65  if (end - p < 8 + skip)
66  break;
67  /* skip most of the file header, to min_pktsize */
68  p += skip;
69  if (AV_RL32(p) == AV_RL32(p + 4)) {
70  /* and set that to zero */
71  AV_WL32(p, 0);
72  return 0;
73  }
74  break;
75  } while (end - p >= sizeof(ff_asf_guid) + 8);
76 
77  return -1;
78 }
79 
80 /**
81  * The following code is basically a buffered AVIOContext,
82  * with the added benefit of returning -EAGAIN (instead of 0)
83  * on packet boundaries, such that the ASF demuxer can return
84  * safely and resume business at the next packet.
85  */
86 static int packetizer_read(void *opaque, uint8_t *buf, int buf_size)
87 {
88  return AVERROR(EAGAIN);
89 }
90 
91 static void init_packetizer(FFIOContext *pb, uint8_t *buf, int len)
92 {
94 
95  /* this "fills" the buffer with its current content */
96  pb->pub.pos = len;
97  pb->pub.buf_end = buf + len;
98 }
99 
101 {
102  int ret = 0;
103  if (av_strstart(p, "pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,", &p)) {
104  FFIOContext pb;
105  RTSPState *rt = s->priv_data;
107  int len = strlen(p) * 6 / 8;
108  char *buf = av_mallocz(len);
109  const AVInputFormat *iformat;
110 
111  if (!buf)
112  return AVERROR(ENOMEM);
113  av_base64_decode(buf, p, len);
114 
115  if (rtp_asf_fix_header(buf, len) < 0)
117  "Failed to fix invalid RTSP-MS/ASF min_pktsize\n");
118  init_packetizer(&pb, buf, len);
119  if (rt->asf_ctx) {
121  }
122 
123  if (!(iformat = av_find_input_format("asf"))) {
124  av_free(buf);
126  }
127 
129  if (!rt->asf_ctx) {
130  av_free(buf);
131  return AVERROR(ENOMEM);
132  }
133  rt->asf_ctx->pb = &pb.pub;
134  av_dict_set(&opts, "no_resync_search", "1", 0);
135 
136  if ((ret = ff_copy_whiteblacklists(rt->asf_ctx, s)) < 0) {
137  av_dict_free(&opts);
138  return ret;
139  }
140 
141  ret = avformat_open_input(&rt->asf_ctx, "", iformat, &opts);
142  av_dict_free(&opts);
143  if (ret < 0) {
144  av_free(pb.pub.buffer);
145  return ret;
146  }
147  av_dict_copy(&s->metadata, rt->asf_ctx->metadata, 0);
148  rt->asf_pb_pos = avio_tell(&pb.pub);
149  av_free(pb.pub.buffer);
150  rt->asf_ctx->pb = NULL;
151  }
152  return ret;
153 }
154 
155 static int asfrtp_parse_sdp_line(AVFormatContext *s, int stream_index,
156  PayloadContext *asf, const char *line)
157 {
158  if (stream_index < 0)
159  return 0;
160  if (av_strstart(line, "stream:", &line)) {
161  RTSPState *rt = s->priv_data;
162 
163  s->streams[stream_index]->id = strtol(line, NULL, 10);
164 
165  if (rt->asf_ctx) {
166  int i;
167 
168  for (i = 0; i < rt->asf_ctx->nb_streams; i++) {
169  if (s->streams[stream_index]->id == rt->asf_ctx->streams[i]->id) {
170  avcodec_parameters_copy(s->streams[stream_index]->codecpar,
171  rt->asf_ctx->streams[i]->codecpar);
172  ffstream(s->streams[stream_index])->need_parsing =
174  avpriv_set_pts_info(s->streams[stream_index], 32, 1, 1000);
175  }
176  }
177  }
178  }
179 
180  return 0;
181 }
182 
183 struct PayloadContext {
186  uint8_t *buf;
187 };
188 
189 /**
190  * @return 0 when a packet was written into /p pkt, and no more data is left;
191  * 1 when a packet was written into /p pkt, and more packets might be left;
192  * <0 when not enough data was provided to return a full packet, or on error.
193  */
195  AVStream *st, AVPacket *pkt,
196  uint32_t *timestamp,
197  const uint8_t *buf, int len, uint16_t seq,
198  int flags)
199 {
200  FFIOContext *const pb0 = &asf->pb;
201  AVIOContext *const pb = &pb0->pub;
202  int res, mflags, len_off;
203  RTSPState *rt = s->priv_data;
204 
205  if (!rt->asf_ctx)
206  return -1;
207 
208  if (len > 0) {
209  int off, out_len = 0;
210 
211  if (len < 4)
212  return -1;
213 
214  av_freep(&asf->buf);
215 
216  ffio_init_read_context(pb0, buf, len);
217 
218  while (avio_tell(pb) + 4 < len) {
219  int start_off = avio_tell(pb);
220 
221  mflags = avio_r8(pb);
222  len_off = avio_rb24(pb);
223  if (mflags & 0x20) /**< relative timestamp */
224  avio_skip(pb, 4);
225  if (mflags & 0x10) /**< has duration */
226  avio_skip(pb, 4);
227  if (mflags & 0x8) /**< has location ID */
228  avio_skip(pb, 4);
229  off = avio_tell(pb);
230 
231  if (!(mflags & 0x40)) {
232  /**
233  * If 0x40 is not set, the len_off field specifies an offset
234  * of this packet's payload data in the complete (reassembled)
235  * ASF packet. This is used to spread one ASF packet over
236  * multiple RTP packets.
237  */
238  if (asf->pktbuf && len_off != avio_tell(asf->pktbuf)) {
239  ffio_free_dyn_buf(&asf->pktbuf);
240  }
241  if (!len_off && !asf->pktbuf &&
242  (res = avio_open_dyn_buf(&asf->pktbuf)) < 0)
243  return res;
244  if (!asf->pktbuf)
245  return AVERROR(EIO);
246 
247  avio_write(asf->pktbuf, buf + off, len - off);
248  avio_skip(pb, len - off);
249  if (!(flags & RTP_FLAG_MARKER))
250  return -1;
251  out_len = avio_close_dyn_buf(asf->pktbuf, &asf->buf);
252  asf->pktbuf = NULL;
253  } else {
254  /**
255  * If 0x40 is set, the len_off field specifies the length of
256  * the next ASF packet that can be read from this payload
257  * data alone. This is commonly the same as the payload size,
258  * but could be less in case of packet splitting (i.e.
259  * multiple ASF packets in one RTP packet).
260  */
261 
262  int cur_len = start_off + len_off - off;
263  int prev_len = out_len;
264  out_len += cur_len;
265  if (FFMIN(cur_len, len - off) < 0)
266  return -1;
267  if ((res = av_reallocp(&asf->buf, out_len)) < 0)
268  return res;
269  memcpy(asf->buf + prev_len, buf + off,
270  FFMIN(cur_len, len - off));
271  avio_skip(pb, cur_len);
272  }
273  }
274 
275  init_packetizer(pb0, asf->buf, out_len);
276  pb->pos += rt->asf_pb_pos;
277  pb->eof_reached = 0;
278  rt->asf_ctx->pb = pb;
279  }
280 
281  for (;;) {
282  int i;
283 
284  res = ff_read_packet(rt->asf_ctx, pkt);
285  rt->asf_pb_pos = avio_tell(pb);
286  if (res != 0)
287  break;
288  for (i = 0; i < s->nb_streams; i++) {
289  if (s->streams[i]->id == rt->asf_ctx->streams[pkt->stream_index]->id) {
290  pkt->stream_index = i;
291  return 1; // FIXME: return 0 if last packet
292  }
293  }
295  }
296 
297  return res == 1 ? -1 : res;
298 }
299 
301 {
302  ffio_free_dyn_buf(&asf->pktbuf);
303  av_freep(&asf->buf);
304 }
305 
306 #define RTP_ASF_HANDLER(n, s, t) \
307 const RTPDynamicProtocolHandler ff_ms_rtp_ ## n ## _handler = { \
308  .enc_name = s, \
309  .codec_type = t, \
310  .codec_id = AV_CODEC_ID_NONE, \
311  .priv_data_size = sizeof(PayloadContext), \
312  .parse_sdp_a_line = asfrtp_parse_sdp_line, \
313  .close = asfrtp_close_context, \
314  .parse_packet = asfrtp_parse_packet, \
315 }
316 
317 RTP_ASF_HANDLER(asf_pfv, "x-asf-pf", AVMEDIA_TYPE_VIDEO);
318 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:86
flags
const SwsFlags flags[]
Definition: swscale.c:61
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:432
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, const uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:50
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:422
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:300
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1332
RTP_FLAG_MARKER
#define RTP_FLAG_MARKER
RTP marker bit was set for this packet.
Definition: rtpdec.h:94
AVDictionary
Definition: dict.c:32
ffio_init_read_context
void ffio_init_read_context(FFIOContext *s, const uint8_t *buffer, int buffer_size)
Wrap a buffer in an AVIOContext for reading.
Definition: aviobuf.c:99
FFIOContext
Definition: avio_internal.h:28
RTSPState::asf_ctx
AVFormatContext * asf_ctx
The following are used for RTP/ASF streams.
Definition: rtsp.h:315
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:367
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: avformat.c:777
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:347
AVIOContext::pos
int64_t pos
position in the file of the current buffer
Definition: avio.h:237
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
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:185
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1496
AVInputFormat
Definition: avformat.h:544
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:217
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:198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
RTP_ASF_HANDLER
#define RTP_ASF_HANDLER(n, s, t)
Definition: rtpdec_asf.c:306
PayloadContext::pb
FFIOContext pb
Definition: rtpdec_asf.c:184
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:314
AVFormatContext
Format I/O context.
Definition: avformat.h:1264
internal.h
opts
AVDictionary * opts
Definition: movenc.c:51
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:767
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:319
ff_asf_guid
uint8_t ff_asf_guid[16]
Definition: riff.h:96
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: avformat.c:822
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1306
init_packetizer
static void init_packetizer(FFIOContext *pb, uint8_t *buf, int len)
Definition: rtpdec_asf.c:91
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:81
base64.h
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1320
ff_asf_file_header
const ff_asf_guid ff_asf_file_header
Definition: asf_tags.c:27
asfrtp_parse_sdp_line
static int asfrtp_parse_sdp_line(AVFormatContext *s, int stream_index, PayloadContext *asf, const char *line)
Definition: rtpdec_asf.c:155
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:754
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:162
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:228
FFIOContext::pub
AVIOContext pub
Definition: avio_internal.h:29
RTSPState
Private data for the RTSP demuxer.
Definition: rtsp.h:226
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:188
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
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:233
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:36
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:326
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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:619
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:256
demux.h
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:1435
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:756
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:744
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:100
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:186
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:46
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:238
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:146
AVPacket::stream_index
int stream_index
Definition: packet.h:554
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
mem.h
AVIOContext::buffer
unsigned char * buffer
Start of the buffer.
Definition: avio.h:225
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVPacket
This structure stores compressed data.
Definition: packet.h:529
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:86
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:247
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_asf_header
const ff_asf_guid ff_asf_header
Definition: asf_tags.c:23
avstring.h
PayloadContext
RTP/AV1 specific private data.
Definition: rdt.c:85
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:106
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:194