Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 { | |
37 | AVPacket pkt; | |
38 | int bytes_per_frame, remaining; | |
39 | uint32_t timestamp; | |
40 | }; | |
41 | ||
42 | static int qt_rtp_parse_packet(AVFormatContext *s, PayloadContext *qt, | |
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 | ||
52 | if (qt->remaining) { | |
53 | int num = qt->pkt.size / qt->bytes_per_frame; | |
54 | ||
55 | if (av_new_packet(pkt, qt->bytes_per_frame)) | |
56 | return AVERROR(ENOMEM); | |
57 | pkt->stream_index = st->index; | |
58 | pkt->flags = qt->pkt.flags; | |
59 | memcpy(pkt->data, | |
60 | &qt->pkt.data[(num - qt->remaining) * qt->bytes_per_frame], | |
61 | qt->bytes_per_frame); | |
62 | if (--qt->remaining == 0) { | |
63 | av_freep(&qt->pkt.data); | |
64 | qt->pkt.size = 0; | |
65 | } | |
66 | return qt->remaining > 0; | |
67 | } | |
68 | ||
69 | /** | |
70 | * The RTP payload is described in: | |
71 | * http://developer.apple.com/quicktime/icefloe/dispatch026.html | |
72 | */ | |
73 | init_get_bits(&gb, buf, len << 3); | |
74 | ffio_init_context(&pb, (uint8_t*)buf, len, 0, NULL, NULL, NULL, NULL); | |
75 | ||
76 | if (len < 4) | |
77 | return AVERROR_INVALIDDATA; | |
78 | ||
79 | skip_bits(&gb, 4); // version | |
80 | if ((packing_scheme = get_bits(&gb, 2)) == 0) | |
81 | return AVERROR_INVALIDDATA; | |
82 | if (get_bits1(&gb)) | |
83 | flags |= RTP_FLAG_KEY; | |
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->codec->codec_type == AVMEDIA_TYPE_VIDEO && | |
110 | tag != MKTAG('v','i','d','e')) || | |
111 | (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && | |
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 + | |
177 | FF_INPUT_BUFFER_PADDING_SIZE)) < 0) { | |
178 | qt->pkt.size = 0; | |
179 | return err; | |
180 | } | |
181 | } else { | |
182 | av_freep(&qt->pkt.data); | |
183 | av_init_packet(&qt->pkt); | |
184 | qt->pkt.data = av_realloc(NULL, alen + FF_INPUT_BUFFER_PADDING_SIZE); | |
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 = flags & RTP_FLAG_KEY ? AV_PKT_FLAG_KEY : 0; | |
200 | pkt->stream_index = st->index; | |
201 | memset(pkt->data + pkt->size, 0, FF_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 = flags & RTP_FLAG_KEY ? 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_free_packet(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 PayloadContext *qt_rtp_new(void) | |
239 | { | |
240 | return av_mallocz(sizeof(PayloadContext)); | |
241 | } | |
242 | ||
243 | static void qt_rtp_free(PayloadContext *qt) | |
244 | { | |
245 | av_freep(&qt->pkt.data); | |
246 | av_free(qt); | |
247 | } | |
248 | ||
249 | #define RTP_QT_HANDLER(m, n, s, t) \ | |
250 | RTPDynamicProtocolHandler ff_ ## m ## _rtp_ ## n ## _handler = { \ | |
251 | .enc_name = s, \ | |
252 | .codec_type = t, \ | |
253 | .codec_id = AV_CODEC_ID_NONE, \ | |
254 | .alloc = qt_rtp_new, \ | |
255 | .free = qt_rtp_free, \ | |
256 | .parse_packet = qt_rtp_parse_packet, \ | |
257 | } | |
258 | ||
259 | RTP_QT_HANDLER(qt, vid, "X-QT", AVMEDIA_TYPE_VIDEO); | |
260 | RTP_QT_HANDLER(qt, aud, "X-QT", AVMEDIA_TYPE_AUDIO); | |
261 | RTP_QT_HANDLER(quicktime, vid, "X-QUICKTIME", AVMEDIA_TYPE_VIDEO); | |
262 | RTP_QT_HANDLER(quicktime, aud, "X-QUICKTIME", AVMEDIA_TYPE_AUDIO); |