2 * RTP JPEG-compressed Video Depacketizer, RFC 2435
3 * Copyright (c) 2012 Samuel Pitoiset
5 * This file is part of FFmpeg.
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.
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.
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
24 #include "rtpdec_formats.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavcodec/mjpeg.h"
27 #include "libavcodec/bytestream.h"
30 * RTP/JPEG specific private data.
32 struct PayloadContext
{
33 AVIOContext
*frame
; ///< current frame buffer
34 uint32_t timestamp
; ///< current frame timestamp
35 int hdr_size
; ///< size of the current frame header
36 uint8_t qtables
[128][128];
37 uint8_t qtables_len
[128];
40 static const uint8_t default_quantizers
[128] = {
42 16, 11, 12, 14, 12, 10, 16, 14,
43 13, 14, 18, 17, 16, 19, 24, 40,
44 26, 24, 22, 22, 24, 49, 35, 37,
45 29, 40, 58, 51, 61, 60, 57, 51,
46 56, 55, 64, 72, 92, 78, 64, 68,
47 87, 69, 55, 56, 80, 109, 81, 87,
48 95, 98, 103, 104, 103, 62, 77, 113,
49 121, 112, 100, 120, 92, 101, 103, 99,
52 17, 18, 18, 24, 21, 24, 47, 26,
53 26, 47, 99, 66, 56, 66, 99, 99,
54 99, 99, 99, 99, 99, 99, 99, 99,
55 99, 99, 99, 99, 99, 99, 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
62 static PayloadContext
*jpeg_new_context(void)
64 return av_mallocz(sizeof(PayloadContext
));
67 static inline void free_frame_if_needed(PayloadContext
*jpeg
)
71 avio_close_dyn_buf(jpeg
->frame
, &p
);
77 static void jpeg_free_context(PayloadContext
*jpeg
)
79 free_frame_if_needed(jpeg
);
83 static int jpeg_create_huffman_table(PutByteContext
*p
, int table_class
,
84 int table_id
, const uint8_t *bits_table
,
85 const uint8_t *value_table
)
89 bytestream2_put_byte(p
, table_class
<< 4 | table_id
);
91 for (i
= 1; i
<= 16; i
++) {
93 bytestream2_put_byte(p
, bits_table
[i
]);
96 for (i
= 0; i
< n
; i
++) {
97 bytestream2_put_byte(p
, value_table
[i
]);
102 static void jpeg_put_marker(PutByteContext
*pbc
, int code
)
104 bytestream2_put_byte(pbc
, 0xff);
105 bytestream2_put_byte(pbc
, code
);
108 static int jpeg_create_header(uint8_t *buf
, int size
, uint32_t type
, uint32_t w
,
109 uint32_t h
, const uint8_t *qtable
, int nb_qtable
,
113 uint8_t *dht_size_ptr
;
116 bytestream2_init_writer(&pbc
, buf
, size
);
118 /* Convert from blocks to pixels. */
123 jpeg_put_marker(&pbc
, SOI
);
126 jpeg_put_marker(&pbc
, APP0
);
127 bytestream2_put_be16(&pbc
, 16);
128 bytestream2_put_buffer(&pbc
, "JFIF", 5);
129 bytestream2_put_be16(&pbc
, 0x0201);
130 bytestream2_put_byte(&pbc
, 0);
131 bytestream2_put_be16(&pbc
, 1);
132 bytestream2_put_be16(&pbc
, 1);
133 bytestream2_put_byte(&pbc
, 0);
134 bytestream2_put_byte(&pbc
, 0);
137 jpeg_put_marker(&pbc
, DRI
);
138 bytestream2_put_be16(&pbc
, 4);
139 bytestream2_put_be16(&pbc
, dri
);
143 jpeg_put_marker(&pbc
, DQT
);
144 bytestream2_put_be16(&pbc
, 2 + nb_qtable
* (1 + 64));
146 for (i
= 0; i
< nb_qtable
; i
++) {
147 bytestream2_put_byte(&pbc
, i
);
149 /* Each table is an array of 64 values given in zig-zag
150 * order, identical to the format used in a JFIF DQT
152 bytestream2_put_buffer(&pbc
, qtable
+ 64 * i
, 64);
156 jpeg_put_marker(&pbc
, DHT
);
157 dht_size_ptr
= pbc
.buffer
;
158 bytestream2_put_be16(&pbc
, 0);
161 dht_size
+= jpeg_create_huffman_table(&pbc
, 0, 0,avpriv_mjpeg_bits_dc_luminance
,
162 avpriv_mjpeg_val_dc
);
163 dht_size
+= jpeg_create_huffman_table(&pbc
, 0, 1, avpriv_mjpeg_bits_dc_chrominance
,
164 avpriv_mjpeg_val_dc
);
165 dht_size
+= jpeg_create_huffman_table(&pbc
, 1, 0, avpriv_mjpeg_bits_ac_luminance
,
166 avpriv_mjpeg_val_ac_luminance
);
167 dht_size
+= jpeg_create_huffman_table(&pbc
, 1, 1, avpriv_mjpeg_bits_ac_chrominance
,
168 avpriv_mjpeg_val_ac_chrominance
);
169 AV_WB16(dht_size_ptr
, dht_size
);
172 jpeg_put_marker(&pbc
, SOF0
);
173 bytestream2_put_be16(&pbc
, 17); /* size */
174 bytestream2_put_byte(&pbc
, 8); /* bits per component */
175 bytestream2_put_be16(&pbc
, h
);
176 bytestream2_put_be16(&pbc
, w
);
177 bytestream2_put_byte(&pbc
, 3); /* number of components */
178 bytestream2_put_byte(&pbc
, 1); /* component number */
179 bytestream2_put_byte(&pbc
, (2 << 4) | (type
? 2 : 1)); /* hsample/vsample */
180 bytestream2_put_byte(&pbc
, 0); /* matrix number */
181 bytestream2_put_byte(&pbc
, 2); /* component number */
182 bytestream2_put_byte(&pbc
, 1 << 4 | 1); /* hsample/vsample */
183 bytestream2_put_byte(&pbc
, nb_qtable
== 2 ? 1 : 0); /* matrix number */
184 bytestream2_put_byte(&pbc
, 3); /* component number */
185 bytestream2_put_byte(&pbc
, 1 << 4 | 1); /* hsample/vsample */
186 bytestream2_put_byte(&pbc
, nb_qtable
== 2 ? 1 : 0); /* matrix number */
189 jpeg_put_marker(&pbc
, SOS
);
190 bytestream2_put_be16(&pbc
, 12);
191 bytestream2_put_byte(&pbc
, 3);
192 bytestream2_put_byte(&pbc
, 1);
193 bytestream2_put_byte(&pbc
, 0);
194 bytestream2_put_byte(&pbc
, 2);
195 bytestream2_put_byte(&pbc
, 17);
196 bytestream2_put_byte(&pbc
, 3);
197 bytestream2_put_byte(&pbc
, 17);
198 bytestream2_put_byte(&pbc
, 0);
199 bytestream2_put_byte(&pbc
, 63);
200 bytestream2_put_byte(&pbc
, 0);
202 /* Return the length in bytes of the JPEG header. */
203 return bytestream2_tell_p(&pbc
);
206 static void create_default_qtables(uint8_t *qtables
, uint8_t q
)
211 factor
= av_clip(q
, 1, 99);
216 q
= 200 - factor
* 2;
218 for (i
= 0; i
< 128; i
++) {
219 int val
= (default_quantizers
[i
] * q
+ 50) / 100;
221 /* Limit the quantizers to 1 <= q <= 255. */
222 val
= av_clip(val
, 1, 255);
227 static int jpeg_parse_packet(AVFormatContext
*ctx
, PayloadContext
*jpeg
,
228 AVStream
*st
, AVPacket
*pkt
, uint32_t *timestamp
,
229 const uint8_t *buf
, int len
, uint16_t seq
,
232 uint8_t type
, q
, width
, height
;
233 const uint8_t *qtables
= NULL
;
239 av_log(ctx
, AV_LOG_ERROR
, "Too short RTP/JPEG packet.\n");
240 return AVERROR_INVALIDDATA
;
243 /* Parse the main JPEG header. */
244 off
= AV_RB24(buf
+ 1); /* fragment byte offset */
245 type
= AV_RB8(buf
+ 4); /* id of jpeg decoder params */
246 q
= AV_RB8(buf
+ 5); /* quantization factor (or table id) */
247 width
= AV_RB8(buf
+ 6); /* frame width in 8 pixel blocks */
248 height
= AV_RB8(buf
+ 7); /* frame height in 8 pixel blocks */
254 av_log(ctx
, AV_LOG_ERROR
, "Too short RTP/JPEG packet.\n");
255 return AVERROR_INVALIDDATA
;
262 /* Parse the restart marker header. */
264 av_log(ctx
, AV_LOG_ERROR
,
265 "Unimplemented RTP/JPEG restart marker header.\n");
266 return AVERROR_PATCHWELCOME
;
269 av_log(ctx
, AV_LOG_ERROR
, "Unimplemented RTP/JPEG type %d\n", type
);
270 return AVERROR_PATCHWELCOME
;
273 /* Parse the quantization table header. */
275 /* Start of JPEG data packet. */
276 uint8_t new_qtables
[128];
282 av_log(ctx
, AV_LOG_ERROR
, "Too short RTP/JPEG packet.\n");
283 return AVERROR_INVALIDDATA
;
286 /* The first byte is reserved for future use. */
287 precision
= AV_RB8(buf
+ 1); /* size of coefficients */
288 qtable_len
= AV_RB16(buf
+ 2); /* length in bytes */
293 av_log(ctx
, AV_LOG_WARNING
, "Only 8-bit precision is supported.\n");
295 if (qtable_len
> 0) {
296 if (len
< qtable_len
) {
297 av_log(ctx
, AV_LOG_ERROR
, "Too short RTP/JPEG packet.\n");
298 return AVERROR_INVALIDDATA
;
304 if (jpeg
->qtables_len
[q
- 128] &&
305 (jpeg
->qtables_len
[q
- 128] != qtable_len
||
306 memcmp(qtables
, &jpeg
->qtables
[q
- 128][0], qtable_len
))) {
307 av_log(ctx
, AV_LOG_WARNING
,
308 "Quantization tables for q=%d changed\n", q
);
309 } else if (!jpeg
->qtables_len
[q
- 128] && qtable_len
<= 128) {
310 memcpy(&jpeg
->qtables
[q
- 128][0], qtables
,
312 jpeg
->qtables_len
[q
- 128] = qtable_len
;
317 av_log(ctx
, AV_LOG_ERROR
,
318 "Invalid RTP/JPEG packet. Quantization tables not found.\n");
319 return AVERROR_INVALIDDATA
;
321 if (!jpeg
->qtables_len
[q
- 128]) {
322 av_log(ctx
, AV_LOG_ERROR
,
323 "No quantization tables known for q=%d yet.\n", q
);
324 return AVERROR_INVALIDDATA
;
326 qtables
= &jpeg
->qtables
[q
- 128][0];
327 qtable_len
= jpeg
->qtables_len
[q
- 128];
329 } else { /* q <= 127 */
330 if (q
== 0 || q
> 99) {
331 av_log(ctx
, AV_LOG_ERROR
, "Reserved q value %d\n", q
);
332 return AVERROR_INVALIDDATA
;
334 create_default_qtables(new_qtables
, q
);
335 qtables
= new_qtables
;
336 qtable_len
= sizeof(new_qtables
);
339 /* Skip the current frame in case of the end packet
340 * has been lost somewhere. */
341 free_frame_if_needed(jpeg
);
343 if ((ret
= avio_open_dyn_buf(&jpeg
->frame
)) < 0)
345 jpeg
->timestamp
= *timestamp
;
347 /* Generate a frame and scan headers that can be prepended to the
348 * RTP/JPEG data payload to produce a JPEG compressed image in
349 * interchange format. */
350 jpeg
->hdr_size
= jpeg_create_header(hdr
, sizeof(hdr
), type
, width
,
352 qtable_len
/ 64, dri
);
354 /* Copy JPEG header to frame buffer. */
355 avio_write(jpeg
->frame
, hdr
, jpeg
->hdr_size
);
359 av_log(ctx
, AV_LOG_ERROR
,
360 "Received packet without a start chunk; dropping frame.\n");
361 return AVERROR(EAGAIN
);
364 if (jpeg
->timestamp
!= *timestamp
) {
365 /* Skip the current frame if timestamp is incorrect.
366 * A start packet has been lost somewhere. */
367 free_frame_if_needed(jpeg
);
368 av_log(ctx
, AV_LOG_ERROR
, "RTP timestamps don't match.\n");
369 return AVERROR_INVALIDDATA
;
372 if (off
!= avio_tell(jpeg
->frame
) - jpeg
->hdr_size
) {
373 av_log(ctx
, AV_LOG_ERROR
,
374 "Missing packets; dropping frame.\n");
375 return AVERROR(EAGAIN
);
378 /* Copy data to frame buffer. */
379 avio_write(jpeg
->frame
, buf
, len
);
381 if (flags
& RTP_FLAG_MARKER
) {
382 /* End of JPEG data packet. */
383 uint8_t buf
[2] = { 0xff, EOI
};
385 /* Put EOI marker. */
386 avio_write(jpeg
->frame
, buf
, sizeof(buf
));
388 /* Prepare the JPEG packet. */
389 if ((ret
= ff_rtp_finalize_packet(pkt
, &jpeg
->frame
, st
->index
)) < 0) {
390 av_log(ctx
, AV_LOG_ERROR
,
391 "Error occurred when getting frame buffer.\n");
398 return AVERROR(EAGAIN
);
401 RTPDynamicProtocolHandler ff_jpeg_dynamic_handler
= {
403 .codec_type
= AVMEDIA_TYPE_VIDEO
,
404 .codec_id
= AV_CODEC_ID_MJPEG
,
405 .alloc
= jpeg_new_context
,
406 .free
= jpeg_free_context
,
407 .parse_packet
= jpeg_parse_packet
,
408 .static_payload_id
= 26,