blob: 465d9bc29211998f654246363175dffad43bde38
1 | /* |
2 | * RTP JPEG-compressed Video Depacketizer, RFC 2435 |
3 | * Copyright (c) 2012 Samuel Pitoiset |
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 "avformat.h" |
23 | #include "avio_internal.h" |
24 | #include "rtpdec.h" |
25 | #include "rtpdec_formats.h" |
26 | #include "libavutil/intreadwrite.h" |
27 | #include "libavcodec/jpegtables.h" |
28 | #include "libavcodec/mjpeg.h" |
29 | #include "libavcodec/bytestream.h" |
30 | |
31 | /** |
32 | * RTP/JPEG specific private data. |
33 | */ |
34 | struct PayloadContext { |
35 | AVIOContext *frame; ///< current frame buffer |
36 | uint32_t timestamp; ///< current frame timestamp |
37 | int hdr_size; ///< size of the current frame header |
38 | uint8_t qtables[128][128]; |
39 | uint8_t qtables_len[128]; |
40 | }; |
41 | |
42 | static const uint8_t default_quantizers[128] = { |
43 | /* luma table */ |
44 | 16, 11, 12, 14, 12, 10, 16, 14, |
45 | 13, 14, 18, 17, 16, 19, 24, 40, |
46 | 26, 24, 22, 22, 24, 49, 35, 37, |
47 | 29, 40, 58, 51, 61, 60, 57, 51, |
48 | 56, 55, 64, 72, 92, 78, 64, 68, |
49 | 87, 69, 55, 56, 80, 109, 81, 87, |
50 | 95, 98, 103, 104, 103, 62, 77, 113, |
51 | 121, 112, 100, 120, 92, 101, 103, 99, |
52 | |
53 | /* chroma table */ |
54 | 17, 18, 18, 24, 21, 24, 47, 26, |
55 | 26, 47, 99, 66, 56, 66, 99, 99, |
56 | 99, 99, 99, 99, 99, 99, 99, 99, |
57 | 99, 99, 99, 99, 99, 99, 99, 99, |
58 | 99, 99, 99, 99, 99, 99, 99, 99, |
59 | 99, 99, 99, 99, 99, 99, 99, 99, |
60 | 99, 99, 99, 99, 99, 99, 99, 99, |
61 | 99, 99, 99, 99, 99, 99, 99, 99 |
62 | }; |
63 | |
64 | static void jpeg_close_context(PayloadContext *jpeg) |
65 | { |
66 | ffio_free_dyn_buf(&jpeg->frame); |
67 | } |
68 | |
69 | static int jpeg_create_huffman_table(PutByteContext *p, int table_class, |
70 | int table_id, const uint8_t *bits_table, |
71 | const uint8_t *value_table) |
72 | { |
73 | int i, n = 0; |
74 | |
75 | bytestream2_put_byte(p, table_class << 4 | table_id); |
76 | |
77 | for (i = 1; i <= 16; i++) { |
78 | n += bits_table[i]; |
79 | bytestream2_put_byte(p, bits_table[i]); |
80 | } |
81 | |
82 | for (i = 0; i < n; i++) { |
83 | bytestream2_put_byte(p, value_table[i]); |
84 | } |
85 | return n + 17; |
86 | } |
87 | |
88 | static void jpeg_put_marker(PutByteContext *pbc, int code) |
89 | { |
90 | bytestream2_put_byte(pbc, 0xff); |
91 | bytestream2_put_byte(pbc, code); |
92 | } |
93 | |
94 | static int jpeg_create_header(uint8_t *buf, int size, uint32_t type, uint32_t w, |
95 | uint32_t h, const uint8_t *qtable, int nb_qtable, |
96 | int dri) |
97 | { |
98 | PutByteContext pbc; |
99 | uint8_t *dht_size_ptr; |
100 | int dht_size, i; |
101 | |
102 | bytestream2_init_writer(&pbc, buf, size); |
103 | |
104 | /* Convert from blocks to pixels. */ |
105 | w <<= 3; |
106 | h <<= 3; |
107 | |
108 | /* SOI */ |
109 | jpeg_put_marker(&pbc, SOI); |
110 | |
111 | /* JFIF header */ |
112 | jpeg_put_marker(&pbc, APP0); |
113 | bytestream2_put_be16(&pbc, 16); |
114 | bytestream2_put_buffer(&pbc, "JFIF", 5); |
115 | bytestream2_put_be16(&pbc, 0x0201); |
116 | bytestream2_put_byte(&pbc, 0); |
117 | bytestream2_put_be16(&pbc, 1); |
118 | bytestream2_put_be16(&pbc, 1); |
119 | bytestream2_put_byte(&pbc, 0); |
120 | bytestream2_put_byte(&pbc, 0); |
121 | |
122 | if (dri) { |
123 | jpeg_put_marker(&pbc, DRI); |
124 | bytestream2_put_be16(&pbc, 4); |
125 | bytestream2_put_be16(&pbc, dri); |
126 | } |
127 | |
128 | /* DQT */ |
129 | jpeg_put_marker(&pbc, DQT); |
130 | bytestream2_put_be16(&pbc, 2 + nb_qtable * (1 + 64)); |
131 | |
132 | for (i = 0; i < nb_qtable; i++) { |
133 | bytestream2_put_byte(&pbc, i); |
134 | |
135 | /* Each table is an array of 64 values given in zig-zag |
136 | * order, identical to the format used in a JFIF DQT |
137 | * marker segment. */ |
138 | bytestream2_put_buffer(&pbc, qtable + 64 * i, 64); |
139 | } |
140 | |
141 | /* DHT */ |
142 | jpeg_put_marker(&pbc, DHT); |
143 | dht_size_ptr = pbc.buffer; |
144 | bytestream2_put_be16(&pbc, 0); |
145 | |
146 | dht_size = 2; |
147 | dht_size += jpeg_create_huffman_table(&pbc, 0, 0,avpriv_mjpeg_bits_dc_luminance, |
148 | avpriv_mjpeg_val_dc); |
149 | dht_size += jpeg_create_huffman_table(&pbc, 0, 1, avpriv_mjpeg_bits_dc_chrominance, |
150 | avpriv_mjpeg_val_dc); |
151 | dht_size += jpeg_create_huffman_table(&pbc, 1, 0, avpriv_mjpeg_bits_ac_luminance, |
152 | avpriv_mjpeg_val_ac_luminance); |
153 | dht_size += jpeg_create_huffman_table(&pbc, 1, 1, avpriv_mjpeg_bits_ac_chrominance, |
154 | avpriv_mjpeg_val_ac_chrominance); |
155 | AV_WB16(dht_size_ptr, dht_size); |
156 | |
157 | /* SOF0 */ |
158 | jpeg_put_marker(&pbc, SOF0); |
159 | bytestream2_put_be16(&pbc, 17); /* size */ |
160 | bytestream2_put_byte(&pbc, 8); /* bits per component */ |
161 | bytestream2_put_be16(&pbc, h); |
162 | bytestream2_put_be16(&pbc, w); |
163 | bytestream2_put_byte(&pbc, 3); /* number of components */ |
164 | bytestream2_put_byte(&pbc, 1); /* component number */ |
165 | bytestream2_put_byte(&pbc, (2 << 4) | (type ? 2 : 1)); /* hsample/vsample */ |
166 | bytestream2_put_byte(&pbc, 0); /* matrix number */ |
167 | bytestream2_put_byte(&pbc, 2); /* component number */ |
168 | bytestream2_put_byte(&pbc, 1 << 4 | 1); /* hsample/vsample */ |
169 | bytestream2_put_byte(&pbc, nb_qtable == 2 ? 1 : 0); /* matrix number */ |
170 | bytestream2_put_byte(&pbc, 3); /* component number */ |
171 | bytestream2_put_byte(&pbc, 1 << 4 | 1); /* hsample/vsample */ |
172 | bytestream2_put_byte(&pbc, nb_qtable == 2 ? 1 : 0); /* matrix number */ |
173 | |
174 | /* SOS */ |
175 | jpeg_put_marker(&pbc, SOS); |
176 | bytestream2_put_be16(&pbc, 12); |
177 | bytestream2_put_byte(&pbc, 3); |
178 | bytestream2_put_byte(&pbc, 1); |
179 | bytestream2_put_byte(&pbc, 0); |
180 | bytestream2_put_byte(&pbc, 2); |
181 | bytestream2_put_byte(&pbc, 17); |
182 | bytestream2_put_byte(&pbc, 3); |
183 | bytestream2_put_byte(&pbc, 17); |
184 | bytestream2_put_byte(&pbc, 0); |
185 | bytestream2_put_byte(&pbc, 63); |
186 | bytestream2_put_byte(&pbc, 0); |
187 | |
188 | /* Return the length in bytes of the JPEG header. */ |
189 | return bytestream2_tell_p(&pbc); |
190 | } |
191 | |
192 | static void create_default_qtables(uint8_t *qtables, uint8_t q) |
193 | { |
194 | int factor = q; |
195 | int i; |
196 | uint16_t S; |
197 | |
198 | factor = av_clip(q, 1, 99); |
199 | |
200 | if (q < 50) |
201 | S = 5000 / factor; |
202 | else |
203 | S = 200 - factor * 2; |
204 | |
205 | for (i = 0; i < 128; i++) { |
206 | int val = (default_quantizers[i] * S + 50) / 100; |
207 | |
208 | /* Limit the quantizers to 1 <= q <= 255. */ |
209 | val = av_clip(val, 1, 255); |
210 | qtables[i] = val; |
211 | } |
212 | } |
213 | |
214 | static int jpeg_parse_packet(AVFormatContext *ctx, PayloadContext *jpeg, |
215 | AVStream *st, AVPacket *pkt, uint32_t *timestamp, |
216 | const uint8_t *buf, int len, uint16_t seq, |
217 | int flags) |
218 | { |
219 | uint8_t type, q, width, height; |
220 | const uint8_t *qtables = NULL; |
221 | uint16_t qtable_len; |
222 | uint32_t off; |
223 | int ret, dri = 0; |
224 | |
225 | if (len < 8) { |
226 | av_log(ctx, AV_LOG_ERROR, "Too short RTP/JPEG packet.\n"); |
227 | return AVERROR_INVALIDDATA; |
228 | } |
229 | |
230 | /* Parse the main JPEG header. */ |
231 | off = AV_RB24(buf + 1); /* fragment byte offset */ |
232 | type = AV_RB8(buf + 4); /* id of jpeg decoder params */ |
233 | q = AV_RB8(buf + 5); /* quantization factor (or table id) */ |
234 | width = AV_RB8(buf + 6); /* frame width in 8 pixel blocks */ |
235 | height = AV_RB8(buf + 7); /* frame height in 8 pixel blocks */ |
236 | buf += 8; |
237 | len -= 8; |
238 | |
239 | if (type & 0x40) { |
240 | if (len < 4) { |
241 | av_log(ctx, AV_LOG_ERROR, "Too short RTP/JPEG packet.\n"); |
242 | return AVERROR_INVALIDDATA; |
243 | } |
244 | dri = AV_RB16(buf); |
245 | buf += 4; |
246 | len -= 4; |
247 | type &= ~0x40; |
248 | } |
249 | if (type > 1) { |
250 | avpriv_report_missing_feature(ctx, "RTP/JPEG type %"PRIu8, type); |
251 | return AVERROR_PATCHWELCOME; |
252 | } |
253 | |
254 | /* Parse the quantization table header. */ |
255 | if (off == 0) { |
256 | /* Start of JPEG data packet. */ |
257 | uint8_t new_qtables[128]; |
258 | uint8_t hdr[1024]; |
259 | |
260 | if (q > 127) { |
261 | uint8_t precision; |
262 | if (len < 4) { |
263 | av_log(ctx, AV_LOG_ERROR, "Too short RTP/JPEG packet.\n"); |
264 | return AVERROR_INVALIDDATA; |
265 | } |
266 | |
267 | /* The first byte is reserved for future use. */ |
268 | precision = AV_RB8(buf + 1); /* size of coefficients */ |
269 | qtable_len = AV_RB16(buf + 2); /* length in bytes */ |
270 | buf += 4; |
271 | len -= 4; |
272 | |
273 | if (precision) |
274 | av_log(ctx, AV_LOG_WARNING, "Only 8-bit precision is supported.\n"); |
275 | |
276 | if (qtable_len > 0) { |
277 | if (len < qtable_len) { |
278 | av_log(ctx, AV_LOG_ERROR, "Too short RTP/JPEG packet.\n"); |
279 | return AVERROR_INVALIDDATA; |
280 | } |
281 | qtables = buf; |
282 | buf += qtable_len; |
283 | len -= qtable_len; |
284 | if (q < 255) { |
285 | if (jpeg->qtables_len[q - 128] && |
286 | (jpeg->qtables_len[q - 128] != qtable_len || |
287 | memcmp(qtables, &jpeg->qtables[q - 128][0], qtable_len))) { |
288 | av_log(ctx, AV_LOG_WARNING, |
289 | "Quantization tables for q=%d changed\n", q); |
290 | } else if (!jpeg->qtables_len[q - 128] && qtable_len <= 128) { |
291 | memcpy(&jpeg->qtables[q - 128][0], qtables, |
292 | qtable_len); |
293 | jpeg->qtables_len[q - 128] = qtable_len; |
294 | } |
295 | } |
296 | } else { |
297 | if (q == 255) { |
298 | av_log(ctx, AV_LOG_ERROR, |
299 | "Invalid RTP/JPEG packet. Quantization tables not found.\n"); |
300 | return AVERROR_INVALIDDATA; |
301 | } |
302 | if (!jpeg->qtables_len[q - 128]) { |
303 | av_log(ctx, AV_LOG_ERROR, |
304 | "No quantization tables known for q=%d yet.\n", q); |
305 | return AVERROR_INVALIDDATA; |
306 | } |
307 | qtables = &jpeg->qtables[q - 128][0]; |
308 | qtable_len = jpeg->qtables_len[q - 128]; |
309 | } |
310 | } else { /* q <= 127 */ |
311 | if (q == 0 || q > 99) { |
312 | av_log(ctx, AV_LOG_ERROR, "Reserved q value %d\n", q); |
313 | return AVERROR_INVALIDDATA; |
314 | } |
315 | create_default_qtables(new_qtables, q); |
316 | qtables = new_qtables; |
317 | qtable_len = sizeof(new_qtables); |
318 | } |
319 | |
320 | /* Skip the current frame in case of the end packet |
321 | * has been lost somewhere. */ |
322 | ffio_free_dyn_buf(&jpeg->frame); |
323 | |
324 | if ((ret = avio_open_dyn_buf(&jpeg->frame)) < 0) |
325 | return ret; |
326 | jpeg->timestamp = *timestamp; |
327 | |
328 | /* Generate a frame and scan headers that can be prepended to the |
329 | * RTP/JPEG data payload to produce a JPEG compressed image in |
330 | * interchange format. */ |
331 | jpeg->hdr_size = jpeg_create_header(hdr, sizeof(hdr), type, width, |
332 | height, qtables, |
333 | qtable_len / 64, dri); |
334 | |
335 | /* Copy JPEG header to frame buffer. */ |
336 | avio_write(jpeg->frame, hdr, jpeg->hdr_size); |
337 | } |
338 | |
339 | if (!jpeg->frame) { |
340 | av_log(ctx, AV_LOG_ERROR, |
341 | "Received packet without a start chunk; dropping frame.\n"); |
342 | return AVERROR(EAGAIN); |
343 | } |
344 | |
345 | if (jpeg->timestamp != *timestamp) { |
346 | /* Skip the current frame if timestamp is incorrect. |
347 | * A start packet has been lost somewhere. */ |
348 | ffio_free_dyn_buf(&jpeg->frame); |
349 | av_log(ctx, AV_LOG_ERROR, "RTP timestamps don't match.\n"); |
350 | return AVERROR_INVALIDDATA; |
351 | } |
352 | |
353 | if (off != avio_tell(jpeg->frame) - jpeg->hdr_size) { |
354 | av_log(ctx, AV_LOG_ERROR, |
355 | "Missing packets; dropping frame.\n"); |
356 | return AVERROR(EAGAIN); |
357 | } |
358 | |
359 | /* Copy data to frame buffer. */ |
360 | avio_write(jpeg->frame, buf, len); |
361 | |
362 | if (flags & RTP_FLAG_MARKER) { |
363 | /* End of JPEG data packet. */ |
364 | uint8_t buf[2] = { 0xff, EOI }; |
365 | |
366 | /* Put EOI marker. */ |
367 | avio_write(jpeg->frame, buf, sizeof(buf)); |
368 | |
369 | /* Prepare the JPEG packet. */ |
370 | if ((ret = ff_rtp_finalize_packet(pkt, &jpeg->frame, st->index)) < 0) { |
371 | av_log(ctx, AV_LOG_ERROR, |
372 | "Error occurred when getting frame buffer.\n"); |
373 | return ret; |
374 | } |
375 | |
376 | return 0; |
377 | } |
378 | |
379 | return AVERROR(EAGAIN); |
380 | } |
381 | |
382 | RTPDynamicProtocolHandler ff_jpeg_dynamic_handler = { |
383 | .enc_name = "JPEG", |
384 | .codec_type = AVMEDIA_TYPE_VIDEO, |
385 | .codec_id = AV_CODEC_ID_MJPEG, |
386 | .priv_data_size = sizeof(PayloadContext), |
387 | .close = jpeg_close_context, |
388 | .parse_packet = jpeg_parse_packet, |
389 | .static_payload_id = 26, |
390 | }; |
391 |