lavc/libkvazaar: fix incompatible pointer type.
[ffmpeg.git] / libavformat / rtpdec_vc2hq.c
1 /*
2  * RTP parser for VC-2 HQ payload format (draft version 1) - experimental
3  * Copyright (c) 2016 Thomas Volkert <thomas@netzeal.de>
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 "libavutil/intreadwrite.h"
23 #include "libavcodec/dirac.h"
24
25 #include "avio_internal.h"
26 #include "rtpdec_formats.h"
27
28 #define RTP_VC2HQ_PL_HEADER_SIZE             4
29
30 #define DIRAC_DATA_UNIT_HEADER_SIZE          13
31 #define DIRAC_PIC_NR_SIZE                    4
32 #define DIRAC_RTP_PCODE_HQ_PIC_FRAGMENT      0xEC
33
34 struct PayloadContext {
35     AVIOContext *buf;
36     uint32_t    frame_size;
37     uint32_t    frame_nr;
38     uint32_t    timestamp;
39     uint32_t    last_unit_size;
40     int         seen_sequence_header;
41 };
42
43 static const uint8_t start_sequence[] = { 'B', 'B', 'C', 'D' };
44
45 static void fill_parse_info_header(PayloadContext *pl_ctx, uint8_t *buf,
46                                    uint8_t parse_code, uint32_t data_unit_size)
47 {
48     memcpy(buf, start_sequence, sizeof(start_sequence));
49     buf[4]  = parse_code;
50     AV_WB32(&buf[5], data_unit_size);
51     AV_WB32(&buf[9], pl_ctx->last_unit_size);
52
53     pl_ctx->last_unit_size = data_unit_size;
54 }
55
56 static int vc2hq_handle_sequence_header(PayloadContext *pl_ctx, AVStream *st, AVPacket *pkt,
57                                         const uint8_t *buf, int len)
58 {
59     int res;
60     uint32_t size = DIRAC_DATA_UNIT_HEADER_SIZE + len;
61
62     if ((res = av_new_packet(pkt, DIRAC_DATA_UNIT_HEADER_SIZE + len)) < 0)
63         return res;
64
65     fill_parse_info_header(pl_ctx, pkt->data, 0x00, size);
66     /* payload of seq. header */
67     memcpy(pkt->data + DIRAC_DATA_UNIT_HEADER_SIZE, buf, len);
68     pkt->stream_index = st->index;
69
70     pl_ctx->seen_sequence_header = 1;
71
72     return 0;
73 }
74
75 static int vc2hq_mark_end_of_sequence(PayloadContext *pl_ctx, AVStream *st, AVPacket *pkt)
76 {
77     int res;
78     uint32_t size = 0;
79
80     /* create A/V packet */
81     if ((res = av_new_packet(pkt, DIRAC_DATA_UNIT_HEADER_SIZE)) < 0)
82         return res;
83
84     fill_parse_info_header(pl_ctx, pkt->data, 0x10, size);
85     pkt->stream_index = st->index;
86
87     pl_ctx->seen_sequence_header = 0;
88
89     return 0;
90 }
91
92 static int vc2hq_handle_frame_fragment(AVFormatContext *ctx, PayloadContext *pl_ctx, AVStream *st,
93                                        AVPacket *pkt, uint32_t *timestamp, const uint8_t *buf, int len,
94                                        int flags)
95 {
96     int res;
97     uint32_t pic_nr;
98     uint16_t frag_len;
99     uint16_t no_slices;
100
101     /* sanity check for size of input packet: 16 bytes header in any case as minimum */
102     if (len < 16) {
103         av_log(ctx, AV_LOG_ERROR, "Too short RTP/VC2hq packet, got %d bytes\n", len);
104         return AVERROR_INVALIDDATA;
105     }
106
107     pic_nr = AV_RB32(&buf[4]);
108     frag_len = AV_RB16(&buf[12]);
109     no_slices = AV_RB16(&buf[14]);
110
111     if (pl_ctx->buf && pl_ctx->frame_nr != pic_nr) {
112         av_log(ctx, AV_LOG_WARNING, "Dropping buffered RTP/VC2hq packet fragments - non-continuous picture numbers\n");
113         ffio_free_dyn_buf(&pl_ctx->buf);
114     }
115
116     /* transform parameters? */
117     if (no_slices == 0) {
118         if (len < frag_len + 16) {
119             av_log(ctx, AV_LOG_ERROR, "Too short RTP/VC2hq packet, got %d bytes\n", len);
120             return AVERROR_INVALIDDATA;
121         }
122
123         /* start frame buffering with new dynamic buffer */
124         if (!pl_ctx->buf) {
125
126             res = avio_open_dyn_buf(&pl_ctx->buf);
127             if (res < 0)
128                 return res;
129
130             /* reserve memory for frame header */
131             res = avio_seek(pl_ctx->buf, DIRAC_DATA_UNIT_HEADER_SIZE + DIRAC_PIC_NR_SIZE, SEEK_SET);
132             if (res < 0)
133                 return res;
134
135             pl_ctx->frame_nr = pic_nr;
136             pl_ctx->timestamp = *timestamp;
137             pl_ctx->frame_size = DIRAC_DATA_UNIT_HEADER_SIZE + DIRAC_PIC_NR_SIZE;
138         }
139
140         avio_write(pl_ctx->buf, buf + 16 /* skip pl header */, frag_len);
141         pl_ctx->frame_size += frag_len;
142
143         return AVERROR(EAGAIN);
144     } else {
145         if (len < frag_len + 20) {
146             av_log(ctx, AV_LOG_ERROR, "Too short RTP/VC2hq packet, got %d bytes\n", len);
147             return AVERROR_INVALIDDATA;
148         }
149
150         /* transform parameters were missed, no buffer available */
151         if (!pl_ctx->buf)
152             return AVERROR_INVALIDDATA;
153
154         avio_write(pl_ctx->buf, buf + 20 /* skip pl header */, frag_len);
155         pl_ctx->frame_size += frag_len;
156
157         /* RTP marker bit means: last fragment of current frame was received;
158            otherwise, an additional fragment is needed for the current frame */
159         if (!(flags & RTP_FLAG_MARKER))
160             return AVERROR(EAGAIN);
161     }
162
163     /* close frame buffering and create A/V packet */
164     res = ff_rtp_finalize_packet(pkt, &pl_ctx->buf, st->index);
165     if (res < 0)
166         return res;
167
168     fill_parse_info_header(pl_ctx, pkt->data, DIRAC_PCODE_PICTURE_HQ, pl_ctx->frame_size);
169     AV_WB32(&pkt->data[13], pl_ctx->frame_nr);
170
171     pl_ctx->frame_size = 0;
172
173     return 0;
174 }
175
176 static int vc2hq_handle_packet(AVFormatContext *ctx, PayloadContext *pl_ctx,
177                                AVStream *st, AVPacket *pkt, uint32_t *timestamp,
178                                const uint8_t *buf, int len, uint16_t seq,
179                                int flags)
180 {
181     uint8_t parse_code = 0;
182     int res = 0;
183
184     if (pl_ctx->buf && pl_ctx->timestamp != *timestamp) {
185         av_log(ctx, AV_LOG_WARNING, "Dropping buffered RTP/VC2hq packet fragments - non-continuous timestamps\n");
186         ffio_free_dyn_buf(&pl_ctx->buf);
187         pl_ctx->frame_size = 0;
188     }
189
190     /* sanity check for size of input packet: needed header data as minimum */
191     if (len < RTP_VC2HQ_PL_HEADER_SIZE) {
192         av_log(ctx, AV_LOG_ERROR, "Too short RTP/VC2hq packet, got %d bytes\n", len);
193         return AVERROR_INVALIDDATA;
194     }
195
196     parse_code = buf[3];
197
198     /* wait for next sequence header? */
199     if (pl_ctx->seen_sequence_header || parse_code == DIRAC_PCODE_SEQ_HEADER) {
200         switch(parse_code) {
201         /* sequence header */
202         case DIRAC_PCODE_SEQ_HEADER:
203             res = vc2hq_handle_sequence_header(pl_ctx, st, pkt, buf + RTP_VC2HQ_PL_HEADER_SIZE, len - RTP_VC2HQ_PL_HEADER_SIZE);
204             break;
205         /* end of sequence */
206         case DIRAC_PCODE_END_SEQ:
207             res = vc2hq_mark_end_of_sequence(pl_ctx, st, pkt);
208             break;
209         /* HQ picture fragment */
210         case DIRAC_RTP_PCODE_HQ_PIC_FRAGMENT:
211             res = vc2hq_handle_frame_fragment(ctx, pl_ctx, st, pkt, timestamp, buf, len, flags);
212             break;
213         }
214     }
215
216     return res;
217 }
218
219 const RTPDynamicProtocolHandler ff_vc2hq_dynamic_handler = {
220     .enc_name         = "VC2",
221     .codec_type       = AVMEDIA_TYPE_VIDEO,
222     .codec_id         = AV_CODEC_ID_DIRAC,
223     .priv_data_size   = sizeof(PayloadContext),
224     .parse_packet     = vc2hq_handle_packet
225 };