Add initial support for RTP hinting in the mov muxer
[ffmpeg.git] / libavformat / movenchint.c
1 /*
2  * MOV, 3GP, MP4 muxer RTP hinting
3  * Copyright (c) 2010 Martin Storsjo
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 #include "movenc.h"
23 #include "libavutil/intreadwrite.h"
24
25 int ff_mov_init_hinting(AVFormatContext *s, int index, int src_index)
26 {
27     MOVMuxContext *mov  = s->priv_data;
28     MOVTrack *track     = &mov->tracks[index];
29     MOVTrack *src_track = &mov->tracks[src_index];
30     AVStream *src_st    = s->streams[src_index];
31     int ret = AVERROR(ENOMEM);
32     AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
33
34     track->tag = MKTAG('r','t','p',' ');
35     track->src_track = src_index;
36
37     if (!rtp_format) {
38         ret = AVERROR(ENOENT);
39         goto fail;
40     }
41
42     track->enc = avcodec_alloc_context();
43     if (!track->enc)
44         goto fail;
45     track->enc->codec_type = AVMEDIA_TYPE_DATA;
46     track->enc->codec_tag  = track->tag;
47
48     track->rtp_ctx = avformat_alloc_context();
49     if (!track->rtp_ctx)
50         goto fail;
51     track->rtp_ctx->oformat = rtp_format;
52     if (!av_new_stream(track->rtp_ctx, 0))
53         goto fail;
54
55     /* Copy stream parameters */
56     track->rtp_ctx->streams[0]->sample_aspect_ratio =
57                         src_st->sample_aspect_ratio;
58
59     /* Remove the allocated codec context, link to the original one
60      * instead, to give the rtp muxer access to codec parameters. */
61     av_free(track->rtp_ctx->streams[0]->codec);
62     track->rtp_ctx->streams[0]->codec = src_st->codec;
63
64     if ((ret = url_open_dyn_packet_buf(&track->rtp_ctx->pb,
65                                        RTP_MAX_PACKET_SIZE)) < 0)
66         goto fail;
67     ret = av_write_header(track->rtp_ctx);
68     if (ret)
69         goto fail;
70
71     /* Copy the RTP AVStream timebase back to the hint AVStream */
72     track->timescale = track->rtp_ctx->streams[0]->time_base.den;
73
74     /* Mark the hinted track that packets written to it should be
75      * sent to this track for hinting. */
76     src_track->hint_track = index;
77     return 0;
78 fail:
79     av_log(s, AV_LOG_WARNING,
80            "Unable to initialize hinting of stream %d\n", src_index);
81     if (track->rtp_ctx && track->rtp_ctx->pb) {
82         uint8_t *buf;
83         url_close_dyn_buf(track->rtp_ctx->pb, &buf);
84         av_free(buf);
85     }
86     if (track->rtp_ctx && track->rtp_ctx->streams[0]) {
87         av_metadata_free(&track->rtp_ctx->streams[0]->metadata);
88         av_free(track->rtp_ctx->streams[0]);
89     }
90     if (track->rtp_ctx) {
91         av_metadata_free(&track->rtp_ctx->metadata);
92         av_free(track->rtp_ctx->priv_data);
93         av_freep(&track->rtp_ctx);
94     }
95     av_freep(&track->enc);
96     /* Set a default timescale, to avoid crashes in dump_format */
97     track->timescale = 90000;
98     return ret;
99 }
100
101 static void output_immediate(const uint8_t *data, int size,
102                              ByteIOContext *out, int *entries)
103 {
104     while (size > 0) {
105         int len = size;
106         if (len > 14)
107             len = 14;
108         put_byte(out, 1); /* immediate constructor */
109         put_byte(out, len); /* amount of valid data */
110         put_buffer(out, data, len);
111         data += len;
112         size -= len;
113
114         for (; len < 14; len++)
115             put_byte(out, 0);
116
117         (*entries)++;
118     }
119 }
120
121 static void describe_payload(const uint8_t *data, int size,
122                              ByteIOContext *out, int *entries)
123 {
124     /* Describe the payload using different constructors */
125     output_immediate(data, size, out, entries);
126 }
127
128 /**
129  * Write an RTP hint (that may contain one or more RTP packets)
130  * for the packets in data. data contains one or more packets with a
131  * BE32 size header.
132  *
133  * @param out buffer where the hints are written
134  * @param data buffer containing RTP packets
135  * @param size the size of the data buffer
136  * @param trk the MOVTrack for the hint track
137  * @param pts pointer where the timestamp for the written RTP hint is stored
138  * @return the number of RTP packets in the written hint
139  */
140 static int write_hint_packets(ByteIOContext *out, const uint8_t *data,
141                               int size, MOVTrack *trk, int64_t *pts)
142 {
143     int64_t curpos;
144     int64_t count_pos, entries_pos;
145     int count = 0, entries;
146
147     count_pos = url_ftell(out);
148     /* RTPsample header */
149     put_be16(out, 0); /* packet count */
150     put_be16(out, 0); /* reserved */
151
152     while (size > 4) {
153         uint32_t packet_len = AV_RB32(data);
154         uint16_t seq;
155         uint32_t ts;
156
157         data += 4;
158         size -= 4;
159         if (packet_len > size || packet_len <= 12)
160             break;
161         if (data[1] >= 200 && data[1] <= 204) {
162             /* RTCP packet, just skip */
163             data += packet_len;
164             size -= packet_len;
165             continue;
166         }
167
168         if (packet_len > trk->max_packet_size)
169             trk->max_packet_size = packet_len;
170
171         seq = AV_RB16(&data[2]);
172         ts = AV_RB32(&data[4]);
173
174         if (trk->prev_rtp_ts == 0)
175             trk->prev_rtp_ts = ts;
176         /* Unwrap the 32-bit RTP timestamp that wraps around often
177          * into a not (as often) wrapping 64-bit timestamp. */
178         trk->cur_rtp_ts_unwrapped += (int32_t) (ts - trk->prev_rtp_ts);
179         trk->prev_rtp_ts = ts;
180         if (*pts == AV_NOPTS_VALUE)
181             *pts = trk->cur_rtp_ts_unwrapped;
182
183         count++;
184         /* RTPpacket header */
185         put_be32(out, 0); /* relative_time */
186         put_buffer(out, data, 2); /* RTP header */
187         put_be16(out, seq); /* RTPsequenceseed */
188         put_be16(out, 0); /* reserved + flags */
189         entries_pos = url_ftell(out);
190         put_be16(out, 0); /* entry count */
191
192         data += 12;
193         size -= 12;
194         packet_len -= 12;
195
196         entries = 0;
197         /* Write one or more constructors describing the payload data */
198         describe_payload(data, packet_len, out, &entries);
199         data += packet_len;
200         size -= packet_len;
201
202         curpos = url_ftell(out);
203         url_fseek(out, entries_pos, SEEK_SET);
204         put_be16(out, entries);
205         url_fseek(out, curpos, SEEK_SET);
206     }
207
208     curpos = url_ftell(out);
209     url_fseek(out, count_pos, SEEK_SET);
210     put_be16(out, count);
211     url_fseek(out, curpos, SEEK_SET);
212     return count;
213 }
214
215 int ff_mov_add_hinted_packet(AVFormatContext *s, AVPacket *pkt,
216                              int track_index, int sample)
217 {
218     MOVMuxContext *mov = s->priv_data;
219     MOVTrack *trk = &mov->tracks[track_index];
220     AVFormatContext *rtp_ctx = trk->rtp_ctx;
221     uint8_t *buf = NULL;
222     int size;
223     ByteIOContext *hintbuf = NULL;
224     AVPacket hint_pkt;
225     AVPacket local_pkt;
226     int ret = 0, count;
227
228     if (!rtp_ctx)
229         return AVERROR(ENOENT);
230     if (!rtp_ctx->pb)
231         return AVERROR(ENOMEM);
232
233     /* Feed the packet to the RTP muxer */
234     local_pkt = *pkt;
235     local_pkt.stream_index = 0;
236     local_pkt.pts = av_rescale_q(pkt->pts,
237         s->streams[pkt->stream_index]->time_base,
238         rtp_ctx->streams[0]->time_base);
239     local_pkt.dts = av_rescale_q(pkt->dts,
240         s->streams[pkt->stream_index]->time_base,
241         rtp_ctx->streams[0]->time_base);
242     av_write_frame(rtp_ctx, &local_pkt);
243
244     /* Fetch the output from the RTP muxer, open a new output buffer
245      * for next time. */
246     size = url_close_dyn_buf(rtp_ctx->pb, &buf);
247     if ((ret = url_open_dyn_packet_buf(&rtp_ctx->pb,
248                                        RTP_MAX_PACKET_SIZE)) < 0)
249         goto done;
250
251     if (size <= 0)
252         goto done;
253
254     /* Open a buffer for writing the hint */
255     if ((ret = url_open_dyn_buf(&hintbuf)) < 0)
256         goto done;
257     av_init_packet(&hint_pkt);
258     count = write_hint_packets(hintbuf, buf, size, trk, &hint_pkt.dts);
259     av_freep(&buf);
260
261     /* Write the hint data into the hint track */
262     hint_pkt.size = size = url_close_dyn_buf(hintbuf, &buf);
263     hint_pkt.data = buf;
264     hint_pkt.pts  = hint_pkt.dts;
265     hint_pkt.stream_index = track_index;
266     if (pkt->flags & AV_PKT_FLAG_KEY)
267         hint_pkt.flags |= AV_PKT_FLAG_KEY;
268     if (count > 0)
269         ff_mov_write_packet(s, &hint_pkt);
270 done:
271     av_free(buf);
272     return ret;
273 }
274
275 void ff_mov_close_hinting(MOVTrack *track) {
276     AVFormatContext* rtp_ctx = track->rtp_ctx;
277     uint8_t *ptr;
278
279     av_freep(&track->enc);
280     if (!rtp_ctx)
281         return;
282     if (rtp_ctx->pb) {
283         av_write_trailer(rtp_ctx);
284         url_close_dyn_buf(rtp_ctx->pb, &ptr);
285         av_free(ptr);
286     }
287     av_metadata_free(&rtp_ctx->streams[0]->metadata);
288     av_metadata_free(&rtp_ctx->metadata);
289     av_free(rtp_ctx->streams[0]);
290     av_freep(&rtp_ctx);
291 }
292