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 */ 34struct 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 42static 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 64static void jpeg_close_context(PayloadContext *jpeg) 65{ 66 ffio_free_dyn_buf(&jpeg->frame); 67} 68 69static 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 88static void jpeg_put_marker(PutByteContext *pbc, int code) 89{ 90 bytestream2_put_byte(pbc, 0xff); 91 bytestream2_put_byte(pbc, code); 92} 93 94static 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, 0x0102); 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,ff_mjpeg_bits_dc_luminance, 148 ff_mjpeg_val_dc); 149 dht_size += jpeg_create_huffman_table(&pbc, 0, 1, ff_mjpeg_bits_dc_chrominance, 150 ff_mjpeg_val_dc); 151 dht_size += jpeg_create_huffman_table(&pbc, 1, 0, ff_mjpeg_bits_ac_luminance, 152 ff_mjpeg_val_ac_luminance); 153 dht_size += jpeg_create_huffman_table(&pbc, 1, 1, ff_mjpeg_bits_ac_chrominance, 154 ff_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 192static 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 214static 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 382const 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