1/* 2 * MJPEG decoder 3 * Copyright (c) 2000, 2001 Fabrice Bellard 4 * Copyright (c) 2003 Alex Beregszaszi 5 * Copyright (c) 2003-2004 Michael Niedermayer 6 * 7 * Support for external huffman table, various fixes (AVID workaround), 8 * aspecting, new decode_frame mechanism and apple mjpeg-b support 9 * by Alex Beregszaszi 10 * 11 * This file is part of FFmpeg. 12 * 13 * FFmpeg is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU Lesser General Public 15 * License as published by the Free Software Foundation; either 16 * version 2.1 of the License, or (at your option) any later version. 17 * 18 * FFmpeg is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 * Lesser General Public License for more details. 22 * 23 * You should have received a copy of the GNU Lesser General Public 24 * License along with FFmpeg; if not, write to the Free Software 25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 26 */ 27 28/** 29 * @file 30 * MJPEG decoder. 31 */ 32 33#include "config_components.h" 34 35#include "libavutil/display.h" 36#include "libavutil/imgutils.h" 37#include "libavutil/avassert.h" 38#include "libavutil/opt.h" 39#include "avcodec.h" 40#include "blockdsp.h" 41#include "codec_internal.h" 42#include "copy_block.h" 43#include "decode.h" 44#include "hwconfig.h" 45#include "idctdsp.h" 46#include "internal.h" 47#include "jpegtables.h" 48#include "mjpeg.h" 49#include "mjpegdec.h" 50#include "jpeglsdec.h" 51#include "profiles.h" 52#include "put_bits.h" 53#include "tiff.h" 54#include "exif.h" 55#include "bytestream.h" 56#include "tiff_common.h" 57 58 59static int init_default_huffman_tables(MJpegDecodeContext *s) 60{ 61 static const struct { 62 int class; 63 int index; 64 const uint8_t *bits; 65 const uint8_t *values; 66 int length; 67 } ht[] = { 68 { 0, 0, ff_mjpeg_bits_dc_luminance, 69 ff_mjpeg_val_dc, 12 }, 70 { 0, 1, ff_mjpeg_bits_dc_chrominance, 71 ff_mjpeg_val_dc, 12 }, 72 { 1, 0, ff_mjpeg_bits_ac_luminance, 73 ff_mjpeg_val_ac_luminance, 162 }, 74 { 1, 1, ff_mjpeg_bits_ac_chrominance, 75 ff_mjpeg_val_ac_chrominance, 162 }, 76 { 2, 0, ff_mjpeg_bits_ac_luminance, 77 ff_mjpeg_val_ac_luminance, 162 }, 78 { 2, 1, ff_mjpeg_bits_ac_chrominance, 79 ff_mjpeg_val_ac_chrominance, 162 }, 80 }; 81 int i, ret; 82 83 for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) { 84 ff_free_vlc(&s->vlcs[ht[i].class][ht[i].index]); 85 ret = ff_mjpeg_build_vlc(&s->vlcs[ht[i].class][ht[i].index], 86 ht[i].bits, ht[i].values, 87 ht[i].class == 1, s->avctx); 88 if (ret < 0) 89 return ret; 90 91 if (ht[i].class < 2) { 92 memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index], 93 ht[i].bits + 1, 16); 94 memcpy(s->raw_huffman_values[ht[i].class][ht[i].index], 95 ht[i].values, ht[i].length); 96 } 97 } 98 99 return 0; 100} 101 102static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len) 103{ 104 s->buggy_avid = 1; 105 if (len > 14 && buf[12] == 1) /* 1 - NTSC */ 106 s->interlace_polarity = 1; 107 if (len > 14 && buf[12] == 2) /* 2 - PAL */ 108 s->interlace_polarity = 0; 109 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 110 av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1); 111} 112 113static void init_idct(AVCodecContext *avctx) 114{ 115 MJpegDecodeContext *s = avctx->priv_data; 116 117 ff_idctdsp_init(&s->idsp, avctx); 118 ff_init_scantable(s->idsp.idct_permutation, &s->scantable, 119 ff_zigzag_direct); 120} 121 122av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx) 123{ 124 MJpegDecodeContext *s = avctx->priv_data; 125 int ret; 126 127 if (!s->picture_ptr) { 128 s->picture = av_frame_alloc(); 129 if (!s->picture) 130 return AVERROR(ENOMEM); 131 s->picture_ptr = s->picture; 132 } 133 134 s->pkt = avctx->internal->in_pkt; 135 136 s->avctx = avctx; 137 ff_blockdsp_init(&s->bdsp, avctx); 138 ff_hpeldsp_init(&s->hdsp, avctx->flags); 139 init_idct(avctx); 140 s->buffer_size = 0; 141 s->buffer = NULL; 142 s->start_code = -1; 143 s->first_picture = 1; 144 s->got_picture = 0; 145 s->orig_height = avctx->coded_height; 146 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER; 147 avctx->colorspace = AVCOL_SPC_BT470BG; 148 s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE; 149 150 if ((ret = init_default_huffman_tables(s)) < 0) 151 return ret; 152 153 if (s->extern_huff) { 154 av_log(avctx, AV_LOG_INFO, "using external huffman table\n"); 155 if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0) 156 return ret; 157 if (ff_mjpeg_decode_dht(s)) { 158 av_log(avctx, AV_LOG_ERROR, 159 "error using external huffman table, switching back to internal\n"); 160 if ((ret = init_default_huffman_tables(s)) < 0) 161 return ret; 162 } 163 } 164 if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */ 165 s->interlace_polarity = 1; /* bottom field first */ 166 av_log(avctx, AV_LOG_DEBUG, "bottom field first\n"); 167 } else if (avctx->field_order == AV_FIELD_UNKNOWN) { 168 if (avctx->codec_tag == AV_RL32("MJPG")) 169 s->interlace_polarity = 1; 170 } 171 172 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) { 173 if (avctx->extradata_size >= 4) 174 s->smv_frames_per_jpeg = AV_RL32(avctx->extradata); 175 176 if (s->smv_frames_per_jpeg <= 0) { 177 av_log(avctx, AV_LOG_ERROR, "Invalid number of frames per jpeg.\n"); 178 return AVERROR_INVALIDDATA; 179 } 180 181 s->smv_frame = av_frame_alloc(); 182 if (!s->smv_frame) 183 return AVERROR(ENOMEM); 184 } else if (avctx->extradata_size > 8 185 && AV_RL32(avctx->extradata) == 0x2C 186 && AV_RL32(avctx->extradata+4) == 0x18) { 187 parse_avid(s, avctx->extradata, avctx->extradata_size); 188 } 189 190 if (avctx->codec->id == AV_CODEC_ID_AMV) 191 s->flipped = 1; 192 193 return 0; 194} 195 196 197/* quantize tables */ 198int ff_mjpeg_decode_dqt(MJpegDecodeContext *s) 199{ 200 int len, index, i; 201 202 len = get_bits(&s->gb, 16) - 2; 203 204 if (8*len > get_bits_left(&s->gb)) { 205 av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len); 206 return AVERROR_INVALIDDATA; 207 } 208 209 while (len >= 65) { 210 int pr = get_bits(&s->gb, 4); 211 if (pr > 1) { 212 av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n"); 213 return AVERROR_INVALIDDATA; 214 } 215 index = get_bits(&s->gb, 4); 216 if (index >= 4) 217 return -1; 218 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index); 219 /* read quant table */ 220 for (i = 0; i < 64; i++) { 221 s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8); 222 if (s->quant_matrixes[index][i] == 0) { 223 int log_level = s->avctx->err_recognition & AV_EF_EXPLODE ? AV_LOG_ERROR : AV_LOG_WARNING; 224 av_log(s->avctx, log_level, "dqt: 0 quant value\n"); 225 if (s->avctx->err_recognition & AV_EF_EXPLODE) 226 return AVERROR_INVALIDDATA; 227 } 228 } 229 230 // XXX FIXME fine-tune, and perhaps add dc too 231 s->qscale[index] = FFMAX(s->quant_matrixes[index][1], 232 s->quant_matrixes[index][8]) >> 1; 233 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", 234 index, s->qscale[index]); 235 len -= 1 + 64 * (1+pr); 236 } 237 return 0; 238} 239 240/* decode huffman tables and build VLC decoders */ 241int ff_mjpeg_decode_dht(MJpegDecodeContext *s) 242{ 243 int len, index, i, class, n, v; 244 uint8_t bits_table[17]; 245 uint8_t val_table[256]; 246 int ret = 0; 247 248 len = get_bits(&s->gb, 16) - 2; 249 250 if (8*len > get_bits_left(&s->gb)) { 251 av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len); 252 return AVERROR_INVALIDDATA; 253 } 254 255 while (len > 0) { 256 if (len < 17) 257 return AVERROR_INVALIDDATA; 258 class = get_bits(&s->gb, 4); 259 if (class >= 2) 260 return AVERROR_INVALIDDATA; 261 index = get_bits(&s->gb, 4); 262 if (index >= 4) 263 return AVERROR_INVALIDDATA; 264 n = 0; 265 for (i = 1; i <= 16; i++) { 266 bits_table[i] = get_bits(&s->gb, 8); 267 n += bits_table[i]; 268 } 269 len -= 17; 270 if (len < n || n > 256) 271 return AVERROR_INVALIDDATA; 272 273 for (i = 0; i < n; i++) { 274 v = get_bits(&s->gb, 8); 275 val_table[i] = v; 276 } 277 len -= n; 278 279 /* build VLC and flush previous vlc if present */ 280 ff_free_vlc(&s->vlcs[class][index]); 281 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n", 282 class, index, n); 283 if ((ret = ff_mjpeg_build_vlc(&s->vlcs[class][index], bits_table, 284 val_table, class > 0, s->avctx)) < 0) 285 return ret; 286 287 if (class > 0) { 288 ff_free_vlc(&s->vlcs[2][index]); 289 if ((ret = ff_mjpeg_build_vlc(&s->vlcs[2][index], bits_table, 290 val_table, 0, s->avctx)) < 0) 291 return ret; 292 } 293 294 for (i = 0; i < 16; i++) 295 s->raw_huffman_lengths[class][index][i] = bits_table[i + 1]; 296 for (i = 0; i < 256; i++) 297 s->raw_huffman_values[class][index][i] = val_table[i]; 298 } 299 return 0; 300} 301 302int ff_mjpeg_decode_sof(MJpegDecodeContext *s) 303{ 304 int len, nb_components, i, width, height, bits, ret, size_change; 305 unsigned pix_fmt_id; 306 int h_count[MAX_COMPONENTS] = { 0 }; 307 int v_count[MAX_COMPONENTS] = { 0 }; 308 309 s->cur_scan = 0; 310 memset(s->upscale_h, 0, sizeof(s->upscale_h)); 311 memset(s->upscale_v, 0, sizeof(s->upscale_v)); 312 313 len = get_bits(&s->gb, 16); 314 bits = get_bits(&s->gb, 8); 315 316 if (bits > 16 || bits < 1) { 317 av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits); 318 return AVERROR_INVALIDDATA; 319 } 320 321 if (s->avctx->bits_per_raw_sample != bits) { 322 av_log(s->avctx, s->avctx->bits_per_raw_sample > 0 ? AV_LOG_INFO : AV_LOG_DEBUG, "Changing bps from %d to %d\n", s->avctx->bits_per_raw_sample, bits); 323 s->avctx->bits_per_raw_sample = bits; 324 init_idct(s->avctx); 325 } 326 if (s->pegasus_rct) 327 bits = 9; 328 if (bits == 9 && !s->pegasus_rct) 329 s->rct = 1; // FIXME ugly 330 331 if(s->lossless && s->avctx->lowres){ 332 av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n"); 333 return -1; 334 } 335 336 height = get_bits(&s->gb, 16); 337 width = get_bits(&s->gb, 16); 338 339 // HACK for odd_height.mov 340 if (s->interlaced && s->width == width && s->height == height + 1) 341 height= s->height; 342 343 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height); 344 if (av_image_check_size(width, height, 0, s->avctx) < 0) 345 return AVERROR_INVALIDDATA; 346 if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL) 347 return AVERROR_INVALIDDATA; 348 349 nb_components = get_bits(&s->gb, 8); 350 if (nb_components <= 0 || 351 nb_components > MAX_COMPONENTS) 352 return -1; 353 if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) { 354 if (nb_components != s->nb_components) { 355 av_log(s->avctx, AV_LOG_ERROR, 356 "nb_components changing in interlaced picture\n"); 357 return AVERROR_INVALIDDATA; 358 } 359 } 360 if (s->ls && !(bits <= 8 || nb_components == 1)) { 361 avpriv_report_missing_feature(s->avctx, 362 "JPEG-LS that is not <= 8 " 363 "bits/component or 16-bit gray"); 364 return AVERROR_PATCHWELCOME; 365 } 366 if (len != 8 + 3 * nb_components) { 367 av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components); 368 return AVERROR_INVALIDDATA; 369 } 370 371 s->nb_components = nb_components; 372 s->h_max = 1; 373 s->v_max = 1; 374 for (i = 0; i < nb_components; i++) { 375 /* component id */ 376 s->component_id[i] = get_bits(&s->gb, 8) - 1; 377 h_count[i] = get_bits(&s->gb, 4); 378 v_count[i] = get_bits(&s->gb, 4); 379 /* compute hmax and vmax (only used in interleaved case) */ 380 if (h_count[i] > s->h_max) 381 s->h_max = h_count[i]; 382 if (v_count[i] > s->v_max) 383 s->v_max = v_count[i]; 384 s->quant_index[i] = get_bits(&s->gb, 8); 385 if (s->quant_index[i] >= 4) { 386 av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n"); 387 return AVERROR_INVALIDDATA; 388 } 389 if (!h_count[i] || !v_count[i]) { 390 av_log(s->avctx, AV_LOG_ERROR, 391 "Invalid sampling factor in component %d %d:%d\n", 392 i, h_count[i], v_count[i]); 393 return AVERROR_INVALIDDATA; 394 } 395 396 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", 397 i, h_count[i], v_count[i], 398 s->component_id[i], s->quant_index[i]); 399 } 400 if ( nb_components == 4 401 && s->component_id[0] == 'C' - 1 402 && s->component_id[1] == 'M' - 1 403 && s->component_id[2] == 'Y' - 1 404 && s->component_id[3] == 'K' - 1) 405 s->adobe_transform = 0; 406 407 if (s->ls && (s->h_max > 1 || s->v_max > 1)) { 408 avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS"); 409 return AVERROR_PATCHWELCOME; 410 } 411 412 if (s->bayer) { 413 if (nb_components == 2) { 414 /* Bayer images embedded in DNGs can contain 2 interleaved components and the 415 width stored in their SOF3 markers is the width of each one. We only output 416 a single component, therefore we need to adjust the output image width. We 417 handle the deinterleaving (but not the debayering) in this file. */ 418 width *= 2; 419 } 420 /* They can also contain 1 component, which is double the width and half the height 421 of the final image (rows are interleaved). We don't handle the decoding in this 422 file, but leave that to the TIFF/DNG decoder. */ 423 } 424 425 /* if different size, realloc/alloc picture */ 426 if (width != s->width || height != s->height || bits != s->bits || 427 memcmp(s->h_count, h_count, sizeof(h_count)) || 428 memcmp(s->v_count, v_count, sizeof(v_count))) { 429 size_change = 1; 430 431 s->width = width; 432 s->height = height; 433 s->bits = bits; 434 memcpy(s->h_count, h_count, sizeof(h_count)); 435 memcpy(s->v_count, v_count, sizeof(v_count)); 436 s->interlaced = 0; 437 s->got_picture = 0; 438 439 /* test interlaced mode */ 440 if (s->first_picture && 441 (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) && 442 s->orig_height != 0 && 443 s->height < ((s->orig_height * 3) / 4)) { 444 s->interlaced = 1; 445 s->bottom_field = s->interlace_polarity; 446 s->picture_ptr->interlaced_frame = 1; 447 s->picture_ptr->top_field_first = !s->interlace_polarity; 448 height *= 2; 449 } 450 451 ret = ff_set_dimensions(s->avctx, width, height); 452 if (ret < 0) 453 return ret; 454 455 if ((s->avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') || 456 s->avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) && 457 s->orig_height < height) 458 s->avctx->height = AV_CEIL_RSHIFT(s->orig_height, s->avctx->lowres); 459 460 s->first_picture = 0; 461 } else { 462 size_change = 0; 463 } 464 465 if (s->avctx->codec_id == AV_CODEC_ID_SMVJPEG) { 466 s->avctx->height = s->avctx->coded_height / s->smv_frames_per_jpeg; 467 if (s->avctx->height <= 0) 468 return AVERROR_INVALIDDATA; 469 } 470 471 if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) { 472 if (s->progressive) { 473 avpriv_request_sample(s->avctx, "progressively coded interlaced picture"); 474 return AVERROR_INVALIDDATA; 475 } 476 } else { 477 if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4)) 478 s->rgb = 1; 479 else if (!s->lossless) 480 s->rgb = 0; 481 /* XXX: not complete test ! */ 482 pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) | 483 (s->h_count[1] << 20) | (s->v_count[1] << 16) | 484 (s->h_count[2] << 12) | (s->v_count[2] << 8) | 485 (s->h_count[3] << 4) | s->v_count[3]; 486 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id); 487 /* NOTE we do not allocate pictures large enough for the possible 488 * padding of h/v_count being 4 */ 489 if (!(pix_fmt_id & 0xD0D0D0D0)) 490 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1; 491 if (!(pix_fmt_id & 0x0D0D0D0D)) 492 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1; 493 494 for (i = 0; i < 8; i++) { 495 int j = 6 + (i&1) - (i&6); 496 int is = (pix_fmt_id >> (4*i)) & 0xF; 497 int js = (pix_fmt_id >> (4*j)) & 0xF; 498 499 if (is == 1 && js != 2 && (i < 2 || i > 5)) 500 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF; 501 if (is == 1 && js != 2 && (i < 2 || i > 5)) 502 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF; 503 504 if (is == 1 && js == 2) { 505 if (i & 1) s->upscale_h[j/2] = 1; 506 else s->upscale_v[j/2] = 1; 507 } 508 } 509 510 if (s->bayer) { 511 if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000) 512 goto unk_pixfmt; 513 } 514 515 switch (pix_fmt_id) { 516 case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */ 517 if (!s->bayer) 518 goto unk_pixfmt; 519 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE; 520 break; 521 case 0x11111100: 522 if (s->rgb) 523 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48; 524 else { 525 if ( s->adobe_transform == 0 526 || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) { 527 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16; 528 } else { 529 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P; 530 else s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16; 531 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 532 } 533 } 534 av_assert0(s->nb_components == 3); 535 break; 536 case 0x11111111: 537 if (s->rgb) 538 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64; 539 else { 540 if (s->adobe_transform == 0 && s->bits <= 8) { 541 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP; 542 } else { 543 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16; 544 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 545 } 546 } 547 av_assert0(s->nb_components == 4); 548 break; 549 case 0x22111122: 550 case 0x22111111: 551 if (s->adobe_transform == 0 && s->bits <= 8) { 552 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP; 553 s->upscale_v[1] = s->upscale_v[2] = 1; 554 s->upscale_h[1] = s->upscale_h[2] = 1; 555 } else if (s->adobe_transform == 2 && s->bits <= 8) { 556 s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P; 557 s->upscale_v[1] = s->upscale_v[2] = 1; 558 s->upscale_h[1] = s->upscale_h[2] = 1; 559 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 560 } else { 561 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P; 562 else s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16; 563 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 564 } 565 av_assert0(s->nb_components == 4); 566 break; 567 case 0x12121100: 568 case 0x22122100: 569 case 0x21211100: 570 case 0x21112100: 571 case 0x22211200: 572 case 0x22221100: 573 case 0x22112200: 574 case 0x11222200: 575 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P; 576 else 577 goto unk_pixfmt; 578 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 579 break; 580 case 0x11000000: 581 case 0x13000000: 582 case 0x14000000: 583 case 0x31000000: 584 case 0x33000000: 585 case 0x34000000: 586 case 0x41000000: 587 case 0x43000000: 588 case 0x44000000: 589 if(s->bits <= 8) 590 s->avctx->pix_fmt = s->force_pal8 ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_GRAY8; 591 else 592 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16; 593 break; 594 case 0x12111100: 595 case 0x14121200: 596 case 0x14111100: 597 case 0x22211100: 598 case 0x22112100: 599 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') { 600 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP; 601 else 602 goto unk_pixfmt; 603 s->upscale_v[0] = s->upscale_v[1] = 1; 604 } else { 605 if (pix_fmt_id == 0x14111100) 606 s->upscale_v[1] = s->upscale_v[2] = 1; 607 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P; 608 else 609 goto unk_pixfmt; 610 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 611 } 612 break; 613 case 0x21111100: 614 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') { 615 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP; 616 else 617 goto unk_pixfmt; 618 s->upscale_h[0] = s->upscale_h[1] = 1; 619 } else { 620 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P; 621 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16; 622 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 623 } 624 break; 625 case 0x31111100: 626 if (s->bits > 8) 627 goto unk_pixfmt; 628 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P; 629 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 630 s->upscale_h[1] = s->upscale_h[2] = 2; 631 break; 632 case 0x22121100: 633 case 0x22111200: 634 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P; 635 else 636 goto unk_pixfmt; 637 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 638 break; 639 case 0x22111100: 640 case 0x23111100: 641 case 0x42111100: 642 case 0x24111100: 643 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P; 644 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16; 645 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 646 if (pix_fmt_id == 0x42111100) { 647 if (s->bits > 8) 648 goto unk_pixfmt; 649 s->upscale_h[1] = s->upscale_h[2] = 1; 650 } else if (pix_fmt_id == 0x24111100) { 651 if (s->bits > 8) 652 goto unk_pixfmt; 653 s->upscale_v[1] = s->upscale_v[2] = 1; 654 } else if (pix_fmt_id == 0x23111100) { 655 if (s->bits > 8) 656 goto unk_pixfmt; 657 s->upscale_v[1] = s->upscale_v[2] = 2; 658 } 659 break; 660 case 0x41111100: 661 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P; 662 else 663 goto unk_pixfmt; 664 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; 665 break; 666 default: 667 unk_pixfmt: 668 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits); 669 memset(s->upscale_h, 0, sizeof(s->upscale_h)); 670 memset(s->upscale_v, 0, sizeof(s->upscale_v)); 671 return AVERROR_PATCHWELCOME; 672 } 673 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) { 674 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling"); 675 return AVERROR_PATCHWELCOME; 676 } 677 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) { 678 avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling"); 679 return AVERROR_PATCHWELCOME; 680 } 681 if (s->ls) { 682 memset(s->upscale_h, 0, sizeof(s->upscale_h)); 683 memset(s->upscale_v, 0, sizeof(s->upscale_v)); 684 if (s->nb_components == 3) { 685 s->avctx->pix_fmt = AV_PIX_FMT_RGB24; 686 } else if (s->nb_components != 1) { 687 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components); 688 return AVERROR_PATCHWELCOME; 689 } else if ((s->palette_index || s->force_pal8) && s->bits <= 8) 690 s->avctx->pix_fmt = AV_PIX_FMT_PAL8; 691 else if (s->bits <= 8) 692 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8; 693 else 694 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16; 695 } 696 697 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt); 698 if (!s->pix_desc) { 699 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n"); 700 return AVERROR_BUG; 701 } 702 703 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) { 704 s->avctx->pix_fmt = s->hwaccel_pix_fmt; 705 } else { 706 enum AVPixelFormat pix_fmts[] = { 707#if CONFIG_MJPEG_NVDEC_HWACCEL 708 AV_PIX_FMT_CUDA, 709#endif 710#if CONFIG_MJPEG_VAAPI_HWACCEL 711 AV_PIX_FMT_VAAPI, 712#endif 713 s->avctx->pix_fmt, 714 AV_PIX_FMT_NONE, 715 }; 716 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts); 717 if (s->hwaccel_pix_fmt < 0) 718 return AVERROR(EINVAL); 719 720 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt; 721 s->avctx->pix_fmt = s->hwaccel_pix_fmt; 722 } 723 724 if (s->avctx->skip_frame == AVDISCARD_ALL) { 725 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I; 726 s->picture_ptr->key_frame = 1; 727 s->got_picture = 1; 728 return 0; 729 } 730 731 av_frame_unref(s->picture_ptr); 732 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0) 733 return -1; 734 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I; 735 s->picture_ptr->key_frame = 1; 736 s->got_picture = 1; 737 738 // Lets clear the palette to avoid leaving uninitialized values in it 739 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8) 740 memset(s->picture_ptr->data[1], 0, 1024); 741 742 for (i = 0; i < 4; i++) 743 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced; 744 745 ff_dlog(s->avctx, "%d %d %d %d %d %d\n", 746 s->width, s->height, s->linesize[0], s->linesize[1], 747 s->interlaced, s->avctx->height); 748 749 } 750 751 if ((s->rgb && !s->lossless && !s->ls) || 752 (!s->rgb && s->ls && s->nb_components > 1) || 753 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls) 754 ) { 755 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n"); 756 return AVERROR_PATCHWELCOME; 757 } 758 759 /* totally blank picture as progressive JPEG will only add details to it */ 760 if (s->progressive) { 761 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8); 762 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8); 763 for (i = 0; i < s->nb_components; i++) { 764 int size = bw * bh * s->h_count[i] * s->v_count[i]; 765 av_freep(&s->blocks[i]); 766 av_freep(&s->last_nnz[i]); 767 s->blocks[i] = av_calloc(size, sizeof(**s->blocks)); 768 s->last_nnz[i] = av_calloc(size, sizeof(**s->last_nnz)); 769 if (!s->blocks[i] || !s->last_nnz[i]) 770 return AVERROR(ENOMEM); 771 s->block_stride[i] = bw * s->h_count[i]; 772 } 773 memset(s->coefs_finished, 0, sizeof(s->coefs_finished)); 774 } 775 776 if (s->avctx->hwaccel) { 777 s->hwaccel_picture_private = 778 av_mallocz(s->avctx->hwaccel->frame_priv_data_size); 779 if (!s->hwaccel_picture_private) 780 return AVERROR(ENOMEM); 781 782 ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer, 783 s->raw_image_buffer_size); 784 if (ret < 0) 785 return ret; 786 } 787 788 return 0; 789} 790 791static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index) 792{ 793 int code; 794 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2); 795 if (code < 0 || code > 16) { 796 av_log(s->avctx, AV_LOG_WARNING, 797 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 798 0, dc_index, &s->vlcs[0][dc_index]); 799 return 0xfffff; 800 } 801 802 if (code) 803 return get_xbits(&s->gb, code); 804 else 805 return 0; 806} 807 808/* decode block and dequantize */ 809static int decode_block(MJpegDecodeContext *s, int16_t *block, int component, 810 int dc_index, int ac_index, uint16_t *quant_matrix) 811{ 812 int code, i, j, level, val; 813 814 /* DC coef */ 815 val = mjpeg_decode_dc(s, dc_index); 816 if (val == 0xfffff) { 817 av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); 818 return AVERROR_INVALIDDATA; 819 } 820 val = val * (unsigned)quant_matrix[0] + s->last_dc[component]; 821 val = av_clip_int16(val); 822 s->last_dc[component] = val; 823 block[0] = val; 824 /* AC coefs */ 825 i = 0; 826 {OPEN_READER(re, &s->gb); 827 do { 828 UPDATE_CACHE(re, &s->gb); 829 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2); 830 831 i += ((unsigned)code) >> 4; 832 code &= 0xf; 833 if (code) { 834 if (code > MIN_CACHE_BITS - 16) 835 UPDATE_CACHE(re, &s->gb); 836 837 { 838 int cache = GET_CACHE(re, &s->gb); 839 int sign = (~cache) >> 31; 840 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign; 841 } 842 843 LAST_SKIP_BITS(re, &s->gb, code); 844 845 if (i > 63) { 846 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); 847 return AVERROR_INVALIDDATA; 848 } 849 j = s->scantable.permutated[i]; 850 block[j] = level * quant_matrix[i]; 851 } 852 } while (i < 63); 853 CLOSE_READER(re, &s->gb);} 854 855 return 0; 856} 857 858static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block, 859 int component, int dc_index, 860 uint16_t *quant_matrix, int Al) 861{ 862 unsigned val; 863 s->bdsp.clear_block(block); 864 val = mjpeg_decode_dc(s, dc_index); 865 if (val == 0xfffff) { 866 av_log(s->avctx, AV_LOG_ERROR, "error dc\n"); 867 return AVERROR_INVALIDDATA; 868 } 869 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component]; 870 s->last_dc[component] = val; 871 block[0] = val; 872 return 0; 873} 874 875/* decode block and dequantize - progressive JPEG version */ 876static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block, 877 uint8_t *last_nnz, int ac_index, 878 uint16_t *quant_matrix, 879 int ss, int se, int Al, int *EOBRUN) 880{ 881 int code, i, j, val, run; 882 unsigned level; 883 884 if (*EOBRUN) { 885 (*EOBRUN)--; 886 return 0; 887 } 888 889 { 890 OPEN_READER(re, &s->gb); 891 for (i = ss; ; i++) { 892 UPDATE_CACHE(re, &s->gb); 893 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2); 894 895 run = ((unsigned) code) >> 4; 896 code &= 0xF; 897 if (code) { 898 i += run; 899 if (code > MIN_CACHE_BITS - 16) 900 UPDATE_CACHE(re, &s->gb); 901 902 { 903 int cache = GET_CACHE(re, &s->gb); 904 int sign = (~cache) >> 31; 905 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign; 906 } 907 908 LAST_SKIP_BITS(re, &s->gb, code); 909 910 if (i >= se) { 911 if (i == se) { 912 j = s->scantable.permutated[se]; 913 block[j] = level * (quant_matrix[se] << Al); 914 break; 915 } 916 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); 917 return AVERROR_INVALIDDATA; 918 } 919 j = s->scantable.permutated[i]; 920 block[j] = level * (quant_matrix[i] << Al); 921 } else { 922 if (run == 0xF) {// ZRL - skip 15 coefficients 923 i += 15; 924 if (i >= se) { 925 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i); 926 return AVERROR_INVALIDDATA; 927 } 928 } else { 929 val = (1 << run); 930 if (run) { 931 UPDATE_CACHE(re, &s->gb); 932 val += NEG_USR32(GET_CACHE(re, &s->gb), run); 933 LAST_SKIP_BITS(re, &s->gb, run); 934 } 935 *EOBRUN = val - 1; 936 break; 937 } 938 } 939 } 940 CLOSE_READER(re, &s->gb); 941 } 942 943 if (i > *last_nnz) 944 *last_nnz = i; 945 946 return 0; 947} 948 949#define REFINE_BIT(j) { \ 950 UPDATE_CACHE(re, &s->gb); \ 951 sign = block[j] >> 15; \ 952 block[j] += SHOW_UBITS(re, &s->gb, 1) * \ 953 ((quant_matrix[i] ^ sign) - sign) << Al; \ 954 LAST_SKIP_BITS(re, &s->gb, 1); \ 955} 956 957#define ZERO_RUN \ 958for (; ; i++) { \ 959 if (i > last) { \ 960 i += run; \ 961 if (i > se) { \ 962 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \ 963 return -1; \ 964 } \ 965 break; \ 966 } \ 967 j = s->scantable.permutated[i]; \ 968 if (block[j]) \ 969 REFINE_BIT(j) \ 970 else if (run-- == 0) \ 971 break; \ 972} 973 974/* decode block and dequantize - progressive JPEG refinement pass */ 975static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block, 976 uint8_t *last_nnz, 977 int ac_index, uint16_t *quant_matrix, 978 int ss, int se, int Al, int *EOBRUN) 979{ 980 int code, i = ss, j, sign, val, run; 981 int last = FFMIN(se, *last_nnz); 982 983 OPEN_READER(re, &s->gb); 984 if (*EOBRUN) { 985 (*EOBRUN)--; 986 } else { 987 for (; ; i++) { 988 UPDATE_CACHE(re, &s->gb); 989 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2); 990 991 if (code & 0xF) { 992 run = ((unsigned) code) >> 4; 993 UPDATE_CACHE(re, &s->gb); 994 val = SHOW_UBITS(re, &s->gb, 1); 995 LAST_SKIP_BITS(re, &s->gb, 1); 996 ZERO_RUN; 997 j = s->scantable.permutated[i]; 998 val--; 999 block[j] = ((quant_matrix[i] << Al) ^ val) - val; 1000 if (i == se) { 1001 if (i > *last_nnz) 1002 *last_nnz = i; 1003 CLOSE_READER(re, &s->gb); 1004 return 0; 1005 } 1006 } else { 1007 run = ((unsigned) code) >> 4; 1008 if (run == 0xF) { 1009 ZERO_RUN; 1010 } else { 1011 val = run; 1012 run = (1 << run); 1013 if (val) { 1014 UPDATE_CACHE(re, &s->gb); 1015 run += SHOW_UBITS(re, &s->gb, val); 1016 LAST_SKIP_BITS(re, &s->gb, val); 1017 } 1018 *EOBRUN = run - 1; 1019 break; 1020 } 1021 } 1022 } 1023 1024 if (i > *last_nnz) 1025 *last_nnz = i; 1026 } 1027 1028 for (; i <= last; i++) { 1029 j = s->scantable.permutated[i]; 1030 if (block[j]) 1031 REFINE_BIT(j) 1032 } 1033 CLOSE_READER(re, &s->gb); 1034 1035 return 0; 1036} 1037#undef REFINE_BIT 1038#undef ZERO_RUN 1039 1040static int handle_rstn(MJpegDecodeContext *s, int nb_components) 1041{ 1042 int i; 1043 int reset = 0; 1044 1045 if (s->restart_interval) { 1046 s->restart_count--; 1047 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){ 1048 align_get_bits(&s->gb); 1049 for (i = 0; i < nb_components; i++) /* reset dc */ 1050 s->last_dc[i] = (4 << s->bits); 1051 } 1052 1053 i = 8 + ((-get_bits_count(&s->gb)) & 7); 1054 /* skip RSTn */ 1055 if (s->restart_count == 0) { 1056 if( show_bits(&s->gb, i) == (1 << i) - 1 1057 || show_bits(&s->gb, i) == 0xFF) { 1058 int pos = get_bits_count(&s->gb); 1059 align_get_bits(&s->gb); 1060 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF) 1061 skip_bits(&s->gb, 8); 1062 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) { 1063 for (i = 0; i < nb_components; i++) /* reset dc */ 1064 s->last_dc[i] = (4 << s->bits); 1065 reset = 1; 1066 } else 1067 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb)); 1068 } 1069 } 1070 } 1071 return reset; 1072} 1073 1074/* Handles 1 to 4 components */ 1075static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform) 1076{ 1077 int i, mb_x, mb_y; 1078 unsigned width; 1079 uint16_t (*buffer)[4]; 1080 int left[4], top[4], topleft[4]; 1081 const int linesize = s->linesize[0]; 1082 const int mask = ((1 << s->bits) - 1) << point_transform; 1083 int resync_mb_y = 0; 1084 int resync_mb_x = 0; 1085 int vpred[6]; 1086 1087 if (!s->bayer && s->nb_components < 3) 1088 return AVERROR_INVALIDDATA; 1089 if (s->bayer && s->nb_components > 2) 1090 return AVERROR_INVALIDDATA; 1091 if (s->nb_components <= 0 || s->nb_components > 4) 1092 return AVERROR_INVALIDDATA; 1093 if (s->v_max != 1 || s->h_max != 1 || !s->lossless) 1094 return AVERROR_INVALIDDATA; 1095 if (s->bayer) { 1096 if (s->rct || s->pegasus_rct) 1097 return AVERROR_INVALIDDATA; 1098 } 1099 1100 1101 s->restart_count = s->restart_interval; 1102 1103 if (s->restart_interval == 0) 1104 s->restart_interval = INT_MAX; 1105 1106 if (s->bayer) 1107 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */ 1108 else 1109 width = s->mb_width; 1110 1111 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0])); 1112 if (!s->ljpeg_buffer) 1113 return AVERROR(ENOMEM); 1114 1115 buffer = s->ljpeg_buffer; 1116 1117 for (i = 0; i < 4; i++) 1118 buffer[0][i] = 1 << (s->bits - 1); 1119 1120 for (mb_y = 0; mb_y < s->mb_height; mb_y++) { 1121 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y); 1122 1123 if (s->interlaced && s->bottom_field) 1124 ptr += linesize >> 1; 1125 1126 for (i = 0; i < 4; i++) 1127 top[i] = left[i] = topleft[i] = buffer[0][i]; 1128 1129 if ((mb_y * s->width) % s->restart_interval == 0) { 1130 for (i = 0; i < 6; i++) 1131 vpred[i] = 1 << (s->bits-1); 1132 } 1133 1134 for (mb_x = 0; mb_x < width; mb_x++) { 1135 int modified_predictor = predictor; 1136 1137 if (get_bits_left(&s->gb) < 1) { 1138 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n"); 1139 return AVERROR_INVALIDDATA; 1140 } 1141 1142 if (s->restart_interval && !s->restart_count){ 1143 s->restart_count = s->restart_interval; 1144 resync_mb_x = mb_x; 1145 resync_mb_y = mb_y; 1146 for(i=0; i<4; i++) 1147 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1); 1148 } 1149 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x) 1150 modified_predictor = 1; 1151 1152 for (i=0;i<nb_components;i++) { 1153 int pred, dc; 1154 1155 topleft[i] = top[i]; 1156 top[i] = buffer[mb_x][i]; 1157 1158 dc = mjpeg_decode_dc(s, s->dc_index[i]); 1159 if(dc == 0xFFFFF) 1160 return -1; 1161 1162 if (!s->bayer || mb_x) { 1163 pred = left[i]; 1164 } else { /* This path runs only for the first line in bayer images */ 1165 vpred[i] += dc; 1166 pred = vpred[i] - dc; 1167 } 1168 1169 PREDICT(pred, topleft[i], top[i], pred, modified_predictor); 1170 1171 left[i] = buffer[mb_x][i] = 1172 mask & (pred + (unsigned)(dc * (1 << point_transform))); 1173 } 1174 1175 if (s->restart_interval && !--s->restart_count) { 1176 align_get_bits(&s->gb); 1177 skip_bits(&s->gb, 16); /* skip RSTn */ 1178 } 1179 } 1180 if (s->rct && s->nb_components == 4) { 1181 for (mb_x = 0; mb_x < s->mb_width; mb_x++) { 1182 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2); 1183 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2]; 1184 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2]; 1185 ptr[4*mb_x + 0] = buffer[mb_x][3]; 1186 } 1187 } else if (s->nb_components == 4) { 1188 for(i=0; i<nb_components; i++) { 1189 int c= s->comp_index[i]; 1190 if (s->bits <= 8) { 1191 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { 1192 ptr[4*mb_x+3-c] = buffer[mb_x][i]; 1193 } 1194 } else if(s->bits == 9) { 1195 return AVERROR_PATCHWELCOME; 1196 } else { 1197 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { 1198 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i]; 1199 } 1200 } 1201 } 1202 } else if (s->rct) { 1203 for (mb_x = 0; mb_x < s->mb_width; mb_x++) { 1204 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2); 1205 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1]; 1206 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1]; 1207 } 1208 } else if (s->pegasus_rct) { 1209 for (mb_x = 0; mb_x < s->mb_width; mb_x++) { 1210 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2); 1211 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1]; 1212 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1]; 1213 } 1214 } else if (s->bayer) { 1215 if (s->bits <= 8) 1216 return AVERROR_PATCHWELCOME; 1217 if (nb_components == 1) { 1218 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */ 1219 for (mb_x = 0; mb_x < width; mb_x++) 1220 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0]; 1221 } else if (nb_components == 2) { 1222 for (mb_x = 0; mb_x < width; mb_x++) { 1223 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0]; 1224 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1]; 1225 } 1226 } 1227 } else { 1228 for(i=0; i<nb_components; i++) { 1229 int c= s->comp_index[i]; 1230 if (s->bits <= 8) { 1231 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { 1232 ptr[3*mb_x+2-c] = buffer[mb_x][i]; 1233 } 1234 } else if(s->bits == 9) { 1235 return AVERROR_PATCHWELCOME; 1236 } else { 1237 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { 1238 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i]; 1239 } 1240 } 1241 } 1242 } 1243 } 1244 return 0; 1245} 1246 1247static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, 1248 int point_transform, int nb_components) 1249{ 1250 int i, mb_x, mb_y, mask; 1251 int bits= (s->bits+7)&~7; 1252 int resync_mb_y = 0; 1253 int resync_mb_x = 0; 1254 1255 point_transform += bits - s->bits; 1256 mask = ((1 << s->bits) - 1) << point_transform; 1257 1258 av_assert0(nb_components>=1 && nb_components<=4); 1259 1260 for (mb_y = 0; mb_y < s->mb_height; mb_y++) { 1261 for (mb_x = 0; mb_x < s->mb_width; mb_x++) { 1262 if (get_bits_left(&s->gb) < 1) { 1263 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n"); 1264 return AVERROR_INVALIDDATA; 1265 } 1266 if (s->restart_interval && !s->restart_count){ 1267 s->restart_count = s->restart_interval; 1268 resync_mb_x = mb_x; 1269 resync_mb_y = mb_y; 1270 } 1271 1272 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){ 1273 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x; 1274 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x; 1275 for (i = 0; i < nb_components; i++) { 1276 uint8_t *ptr; 1277 uint16_t *ptr16; 1278 int n, h, v, x, y, c, j, linesize; 1279 n = s->nb_blocks[i]; 1280 c = s->comp_index[i]; 1281 h = s->h_scount[i]; 1282 v = s->v_scount[i]; 1283 x = 0; 1284 y = 0; 1285 linesize= s->linesize[c]; 1286 1287 if(bits>8) linesize /= 2; 1288 1289 for(j=0; j<n; j++) { 1290 int pred, dc; 1291 1292 dc = mjpeg_decode_dc(s, s->dc_index[i]); 1293 if(dc == 0xFFFFF) 1294 return -1; 1295 if ( h * mb_x + x >= s->width 1296 || v * mb_y + y >= s->height) { 1297 // Nothing to do 1298 } else if (bits<=8) { 1299 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap 1300 if(y==0 && toprow){ 1301 if(x==0 && leftcol){ 1302 pred= 1 << (bits - 1); 1303 }else{ 1304 pred= ptr[-1]; 1305 } 1306 }else{ 1307 if(x==0 && leftcol){ 1308 pred= ptr[-linesize]; 1309 }else{ 1310 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); 1311 } 1312 } 1313 1314 if (s->interlaced && s->bottom_field) 1315 ptr += linesize >> 1; 1316 pred &= mask; 1317 *ptr= pred + ((unsigned)dc << point_transform); 1318 }else{ 1319 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap 1320 if(y==0 && toprow){ 1321 if(x==0 && leftcol){ 1322 pred= 1 << (bits - 1); 1323 }else{ 1324 pred= ptr16[-1]; 1325 } 1326 }else{ 1327 if(x==0 && leftcol){ 1328 pred= ptr16[-linesize]; 1329 }else{ 1330 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor); 1331 } 1332 } 1333 1334 if (s->interlaced && s->bottom_field) 1335 ptr16 += linesize >> 1; 1336 pred &= mask; 1337 *ptr16= pred + ((unsigned)dc << point_transform); 1338 } 1339 if (++x == h) { 1340 x = 0; 1341 y++; 1342 } 1343 } 1344 } 1345 } else { 1346 for (i = 0; i < nb_components; i++) { 1347 uint8_t *ptr; 1348 uint16_t *ptr16; 1349 int n, h, v, x, y, c, j, linesize, dc; 1350 n = s->nb_blocks[i]; 1351 c = s->comp_index[i]; 1352 h = s->h_scount[i]; 1353 v = s->v_scount[i]; 1354 x = 0; 1355 y = 0; 1356 linesize = s->linesize[c]; 1357 1358 if(bits>8) linesize /= 2; 1359 1360 for (j = 0; j < n; j++) { 1361 int pred; 1362 1363 dc = mjpeg_decode_dc(s, s->dc_index[i]); 1364 if(dc == 0xFFFFF) 1365 return -1; 1366 if ( h * mb_x + x >= s->width 1367 || v * mb_y + y >= s->height) { 1368 // Nothing to do 1369 } else if (bits<=8) { 1370 ptr = s->picture_ptr->data[c] + 1371 (linesize * (v * mb_y + y)) + 1372 (h * mb_x + x); //FIXME optimize this crap 1373 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); 1374 1375 pred &= mask; 1376 *ptr = pred + ((unsigned)dc << point_transform); 1377 }else{ 1378 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap 1379 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor); 1380 1381 pred &= mask; 1382 *ptr16= pred + ((unsigned)dc << point_transform); 1383 } 1384 1385 if (++x == h) { 1386 x = 0; 1387 y++; 1388 } 1389 } 1390 } 1391 } 1392 if (s->restart_interval && !--s->restart_count) { 1393 align_get_bits(&s->gb); 1394 skip_bits(&s->gb, 16); /* skip RSTn */ 1395 } 1396 } 1397 } 1398 return 0; 1399} 1400 1401static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s, 1402 uint8_t *dst, const uint8_t *src, 1403 int linesize, int lowres) 1404{ 1405 switch (lowres) { 1406 case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8); 1407 break; 1408 case 1: copy_block4(dst, src, linesize, linesize, 4); 1409 break; 1410 case 2: copy_block2(dst, src, linesize, linesize, 2); 1411 break; 1412 case 3: *dst = *src; 1413 break; 1414 } 1415} 1416 1417static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize) 1418{ 1419 int block_x, block_y; 1420 int size = 8 >> s->avctx->lowres; 1421 if (s->bits > 8) { 1422 for (block_y=0; block_y<size; block_y++) 1423 for (block_x=0; block_x<size; block_x++) 1424 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits; 1425 } else { 1426 for (block_y=0; block_y<size; block_y++) 1427 for (block_x=0; block_x<size; block_x++) 1428 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits; 1429 } 1430} 1431 1432static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, 1433 int Al, const uint8_t *mb_bitmask, 1434 int mb_bitmask_size, 1435 const AVFrame *reference) 1436{ 1437 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height; 1438 uint8_t *data[MAX_COMPONENTS]; 1439 const uint8_t *reference_data[MAX_COMPONENTS]; 1440 int linesize[MAX_COMPONENTS]; 1441 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning 1442 int bytes_per_pixel = 1 + (s->bits > 8); 1443 1444 if (mb_bitmask) { 1445 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) { 1446 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n"); 1447 return AVERROR_INVALIDDATA; 1448 } 1449 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height); 1450 } 1451 1452 s->restart_count = 0; 1453 1454 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift, 1455 &chroma_v_shift); 1456 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift); 1457 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift); 1458 1459 for (i = 0; i < nb_components; i++) { 1460 int c = s->comp_index[i]; 1461 data[c] = s->picture_ptr->data[c]; 1462 reference_data[c] = reference ? reference->data[c] : NULL; 1463 linesize[c] = s->linesize[c]; 1464 s->coefs_finished[c] |= 1; 1465 } 1466 1467 for (mb_y = 0; mb_y < s->mb_height; mb_y++) { 1468 for (mb_x = 0; mb_x < s->mb_width; mb_x++) { 1469 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb); 1470 1471 if (s->restart_interval && !s->restart_count) 1472 s->restart_count = s->restart_interval; 1473 1474 if (get_bits_left(&s->gb) < 0) { 1475 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n", 1476 -get_bits_left(&s->gb)); 1477 return AVERROR_INVALIDDATA; 1478 } 1479 for (i = 0; i < nb_components; i++) { 1480 uint8_t *ptr; 1481 int n, h, v, x, y, c, j; 1482 int block_offset; 1483 n = s->nb_blocks[i]; 1484 c = s->comp_index[i]; 1485 h = s->h_scount[i]; 1486 v = s->v_scount[i]; 1487 x = 0; 1488 y = 0; 1489 for (j = 0; j < n; j++) { 1490 block_offset = (((linesize[c] * (v * mb_y + y) * 8) + 1491 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres); 1492 1493 if (s->interlaced && s->bottom_field) 1494 block_offset += linesize[c] >> 1; 1495 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width) 1496 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) { 1497 ptr = data[c] + block_offset; 1498 } else 1499 ptr = NULL; 1500 if (!s->progressive) { 1501 if (copy_mb) { 1502 if (ptr) 1503 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset, 1504 linesize[c], s->avctx->lowres); 1505 1506 } else { 1507 s->bdsp.clear_block(s->block); 1508 if (decode_block(s, s->block, i, 1509 s->dc_index[i], s->ac_index[i], 1510 s->quant_matrixes[s->quant_sindex[i]]) < 0) { 1511 av_log(s->avctx, AV_LOG_ERROR, 1512 "error y=%d x=%d\n", mb_y, mb_x); 1513 return AVERROR_INVALIDDATA; 1514 } 1515 if (ptr) { 1516 s->idsp.idct_put(ptr, linesize[c], s->block); 1517 if (s->bits & 7) 1518 shift_output(s, ptr, linesize[c]); 1519 } 1520 } 1521 } else { 1522 int block_idx = s->block_stride[c] * (v * mb_y + y) + 1523 (h * mb_x + x); 1524 int16_t *block = s->blocks[c][block_idx]; 1525 if (Ah) 1526 block[0] += get_bits1(&s->gb) * 1527 s->quant_matrixes[s->quant_sindex[i]][0] << Al; 1528 else if (decode_dc_progressive(s, block, i, s->dc_index[i], 1529 s->quant_matrixes[s->quant_sindex[i]], 1530 Al) < 0) { 1531 av_log(s->avctx, AV_LOG_ERROR, 1532 "error y=%d x=%d\n", mb_y, mb_x); 1533 return AVERROR_INVALIDDATA; 1534 } 1535 } 1536 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x); 1537 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n", 1538 mb_x, mb_y, x, y, c, s->bottom_field, 1539 (v * mb_y + y) * 8, (h * mb_x + x) * 8); 1540 if (++x == h) { 1541 x = 0; 1542 y++; 1543 } 1544 } 1545 } 1546 1547 handle_rstn(s, nb_components); 1548 } 1549 } 1550 return 0; 1551} 1552 1553static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, 1554 int se, int Ah, int Al) 1555{ 1556 int mb_x, mb_y; 1557 int EOBRUN = 0; 1558 int c = s->comp_index[0]; 1559 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]]; 1560 1561 av_assert0(ss>=0 && Ah>=0 && Al>=0); 1562 if (se < ss || se > 63) { 1563 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se); 1564 return AVERROR_INVALIDDATA; 1565 } 1566 1567 // s->coefs_finished is a bitmask for coefficients coded 1568 // ss and se are parameters telling start and end coefficients 1569 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss); 1570 1571 s->restart_count = 0; 1572 1573 for (mb_y = 0; mb_y < s->mb_height; mb_y++) { 1574 int block_idx = mb_y * s->block_stride[c]; 1575 int16_t (*block)[64] = &s->blocks[c][block_idx]; 1576 uint8_t *last_nnz = &s->last_nnz[c][block_idx]; 1577 if (get_bits_left(&s->gb) <= 0) { 1578 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n"); 1579 return AVERROR_INVALIDDATA; 1580 } 1581 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) { 1582 int ret; 1583 if (s->restart_interval && !s->restart_count) 1584 s->restart_count = s->restart_interval; 1585 1586 if (Ah) 1587 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0], 1588 quant_matrix, ss, se, Al, &EOBRUN); 1589 else 1590 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0], 1591 quant_matrix, ss, se, Al, &EOBRUN); 1592 1593 if (ret >= 0 && get_bits_left(&s->gb) < 0) 1594 ret = AVERROR_INVALIDDATA; 1595 if (ret < 0) { 1596 av_log(s->avctx, AV_LOG_ERROR, 1597 "error y=%d x=%d\n", mb_y, mb_x); 1598 return AVERROR_INVALIDDATA; 1599 } 1600 1601 if (handle_rstn(s, 0)) 1602 EOBRUN = 0; 1603 } 1604 } 1605 return 0; 1606} 1607 1608static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s) 1609{ 1610 int mb_x, mb_y; 1611 int c; 1612 const int bytes_per_pixel = 1 + (s->bits > 8); 1613 const int block_size = s->lossless ? 1 : 8; 1614 1615 for (c = 0; c < s->nb_components; c++) { 1616 uint8_t *data = s->picture_ptr->data[c]; 1617 int linesize = s->linesize[c]; 1618 int h = s->h_max / s->h_count[c]; 1619 int v = s->v_max / s->v_count[c]; 1620 int mb_width = (s->width + h * block_size - 1) / (h * block_size); 1621 int mb_height = (s->height + v * block_size - 1) / (v * block_size); 1622 1623 if (~s->coefs_finished[c]) 1624 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c); 1625 1626 if (s->interlaced && s->bottom_field) 1627 data += linesize >> 1; 1628 1629 for (mb_y = 0; mb_y < mb_height; mb_y++) { 1630 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres); 1631 int block_idx = mb_y * s->block_stride[c]; 1632 int16_t (*block)[64] = &s->blocks[c][block_idx]; 1633 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) { 1634 s->idsp.idct_put(ptr, linesize, *block); 1635 if (s->bits & 7) 1636 shift_output(s, ptr, linesize); 1637 ptr += bytes_per_pixel*8 >> s->avctx->lowres; 1638 } 1639 } 1640 } 1641} 1642 1643int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, 1644 int mb_bitmask_size, const AVFrame *reference) 1645{ 1646 int len, nb_components, i, h, v, predictor, point_transform; 1647 int index, id, ret; 1648 const int block_size = s->lossless ? 1 : 8; 1649 int ilv, prev_shift; 1650 1651 if (!s->got_picture) { 1652 av_log(s->avctx, AV_LOG_WARNING, 1653 "Can not process SOS before SOF, skipping\n"); 1654 return -1; 1655 } 1656 1657 if (reference) { 1658 if (reference->width != s->picture_ptr->width || 1659 reference->height != s->picture_ptr->height || 1660 reference->format != s->picture_ptr->format) { 1661 av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n"); 1662 return AVERROR_INVALIDDATA; 1663 } 1664 } 1665 1666 /* XXX: verify len field validity */ 1667 len = get_bits(&s->gb, 16); 1668 nb_components = get_bits(&s->gb, 8); 1669 if (nb_components == 0 || nb_components > MAX_COMPONENTS) { 1670 avpriv_report_missing_feature(s->avctx, 1671 "decode_sos: nb_components (%d)", 1672 nb_components); 1673 return AVERROR_PATCHWELCOME; 1674 } 1675 if (len != 6 + 2 * nb_components) { 1676 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len); 1677 return AVERROR_INVALIDDATA; 1678 } 1679 for (i = 0; i < nb_components; i++) { 1680 id = get_bits(&s->gb, 8) - 1; 1681 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id); 1682 /* find component index */ 1683 for (index = 0; index < s->nb_components; index++) 1684 if (id == s->component_id[index]) 1685 break; 1686 if (index == s->nb_components) { 1687 av_log(s->avctx, AV_LOG_ERROR, 1688 "decode_sos: index(%d) out of components\n", index); 1689 return AVERROR_INVALIDDATA; 1690 } 1691 /* Metasoft MJPEG codec has Cb and Cr swapped */ 1692 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J') 1693 && nb_components == 3 && s->nb_components == 3 && i) 1694 index = 3 - i; 1695 1696 s->quant_sindex[i] = s->quant_index[index]; 1697 s->nb_blocks[i] = s->h_count[index] * s->v_count[index]; 1698 s->h_scount[i] = s->h_count[index]; 1699 s->v_scount[i] = s->v_count[index]; 1700 1701 if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P) 1702 index = (index+2)%3; 1703 1704 s->comp_index[i] = index; 1705 1706 s->dc_index[i] = get_bits(&s->gb, 4); 1707 s->ac_index[i] = get_bits(&s->gb, 4); 1708 1709 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 || 1710 s->dc_index[i] >= 4 || s->ac_index[i] >= 4) 1711 goto out_of_range; 1712 if (!s->vlcs[0][s->dc_index[i]].table || !(s->progressive ? s->vlcs[2][s->ac_index[0]].table : s->vlcs[1][s->ac_index[i]].table)) 1713 goto out_of_range; 1714 } 1715 1716 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */ 1717 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */ 1718 if(s->avctx->codec_tag != AV_RL32("CJPG")){ 1719 prev_shift = get_bits(&s->gb, 4); /* Ah */ 1720 point_transform = get_bits(&s->gb, 4); /* Al */ 1721 }else 1722 prev_shift = point_transform = 0; 1723 1724 if (nb_components > 1) { 1725 /* interleaved stream */ 1726 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size); 1727 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size); 1728 } else if (!s->ls) { /* skip this for JPEG-LS */ 1729 h = s->h_max / s->h_scount[0]; 1730 v = s->v_max / s->v_scount[0]; 1731 s->mb_width = (s->width + h * block_size - 1) / (h * block_size); 1732 s->mb_height = (s->height + v * block_size - 1) / (v * block_size); 1733 s->nb_blocks[0] = 1; 1734 s->h_scount[0] = 1; 1735 s->v_scount[0] = 1; 1736 } 1737 1738 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 1739 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n", 1740 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "", 1741 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod, 1742 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components); 1743 1744 1745 /* mjpeg-b can have padding bytes between sos and image data, skip them */ 1746 for (i = s->mjpb_skiptosod; i > 0; i--) 1747 skip_bits(&s->gb, 8); 1748 1749next_field: 1750 for (i = 0; i < nb_components; i++) 1751 s->last_dc[i] = (4 << s->bits); 1752 1753 if (s->avctx->hwaccel) { 1754 int bytes_to_start = get_bits_count(&s->gb) / 8; 1755 av_assert0(bytes_to_start >= 0 && 1756 s->raw_scan_buffer_size >= bytes_to_start); 1757 1758 ret = s->avctx->hwaccel->decode_slice(s->avctx, 1759 s->raw_scan_buffer + bytes_to_start, 1760 s->raw_scan_buffer_size - bytes_to_start); 1761 if (ret < 0) 1762 return ret; 1763 1764 } else if (s->lossless) { 1765 av_assert0(s->picture_ptr == s->picture); 1766 if (CONFIG_JPEGLS_DECODER && s->ls) { 1767// for () { 1768// reset_ls_coding_parameters(s, 0); 1769 1770 if ((ret = ff_jpegls_decode_picture(s, predictor, 1771 point_transform, ilv)) < 0) 1772 return ret; 1773 } else { 1774 if (s->rgb || s->bayer) { 1775 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0) 1776 return ret; 1777 } else { 1778 if ((ret = ljpeg_decode_yuv_scan(s, predictor, 1779 point_transform, 1780 nb_components)) < 0) 1781 return ret; 1782 } 1783 } 1784 } else { 1785 if (s->progressive && predictor) { 1786 av_assert0(s->picture_ptr == s->picture); 1787 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor, 1788 ilv, prev_shift, 1789 point_transform)) < 0) 1790 return ret; 1791 } else { 1792 if ((ret = mjpeg_decode_scan(s, nb_components, 1793 prev_shift, point_transform, 1794 mb_bitmask, mb_bitmask_size, reference)) < 0) 1795 return ret; 1796 } 1797 } 1798 1799 if (s->interlaced && 1800 get_bits_left(&s->gb) > 32 && 1801 show_bits(&s->gb, 8) == 0xFF) { 1802 GetBitContext bak = s->gb; 1803 align_get_bits(&bak); 1804 if (show_bits(&bak, 16) == 0xFFD1) { 1805 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n"); 1806 s->gb = bak; 1807 skip_bits(&s->gb, 16); 1808 s->bottom_field ^= 1; 1809 1810 goto next_field; 1811 } 1812 } 1813 1814 emms_c(); 1815 return 0; 1816 out_of_range: 1817 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n"); 1818 return AVERROR_INVALIDDATA; 1819} 1820 1821static int mjpeg_decode_dri(MJpegDecodeContext *s) 1822{ 1823 if (get_bits(&s->gb, 16) != 4) 1824 return AVERROR_INVALIDDATA; 1825 s->restart_interval = get_bits(&s->gb, 16); 1826 s->restart_count = 0; 1827 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", 1828 s->restart_interval); 1829 1830 return 0; 1831} 1832 1833static int mjpeg_decode_app(MJpegDecodeContext *s) 1834{ 1835 int len, id, i; 1836 1837 len = get_bits(&s->gb, 16); 1838 if (len < 6) { 1839 if (s->bayer) { 1840 // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers 1841 av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len); 1842 skip_bits(&s->gb, len); 1843 return 0; 1844 } else 1845 return AVERROR_INVALIDDATA; 1846 } 1847 if (8 * len > get_bits_left(&s->gb)) 1848 return AVERROR_INVALIDDATA; 1849 1850 id = get_bits_long(&s->gb, 32); 1851 len -= 6; 1852 1853 if (s->avctx->debug & FF_DEBUG_STARTCODE) 1854 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n", 1855 av_fourcc2str(av_bswap32(id)), id, len); 1856 1857 /* Buggy AVID, it puts EOI only at every 10th frame. */ 1858 /* Also, this fourcc is used by non-avid files too, it holds some 1859 information, but it's always present in AVID-created files. */ 1860 if (id == AV_RB32("AVI1")) { 1861 /* structure: 1862 4bytes AVI1 1863 1bytes polarity 1864 1bytes always zero 1865 4bytes field_size 1866 4bytes field_size_less_padding 1867 */ 1868 s->buggy_avid = 1; 1869 i = get_bits(&s->gb, 8); len--; 1870 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i); 1871 goto out; 1872 } 1873 1874 if (id == AV_RB32("JFIF")) { 1875 int t_w, t_h, v1, v2; 1876 if (len < 8) 1877 goto out; 1878 skip_bits(&s->gb, 8); /* the trailing zero-byte */ 1879 v1 = get_bits(&s->gb, 8); 1880 v2 = get_bits(&s->gb, 8); 1881 skip_bits(&s->gb, 8); 1882 1883 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16); 1884 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16); 1885 if ( s->avctx->sample_aspect_ratio.num <= 0 1886 || s->avctx->sample_aspect_ratio.den <= 0) { 1887 s->avctx->sample_aspect_ratio.num = 0; 1888 s->avctx->sample_aspect_ratio.den = 1; 1889 } 1890 1891 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 1892 av_log(s->avctx, AV_LOG_INFO, 1893 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n", 1894 v1, v2, 1895 s->avctx->sample_aspect_ratio.num, 1896 s->avctx->sample_aspect_ratio.den); 1897 1898 len -= 8; 1899 if (len >= 2) { 1900 t_w = get_bits(&s->gb, 8); 1901 t_h = get_bits(&s->gb, 8); 1902 if (t_w && t_h) { 1903 /* skip thumbnail */ 1904 if (len -10 - (t_w * t_h * 3) > 0) 1905 len -= t_w * t_h * 3; 1906 } 1907 len -= 2; 1908 } 1909 goto out; 1910 } 1911 1912 if ( id == AV_RB32("Adob") 1913 && len >= 7 1914 && show_bits(&s->gb, 8) == 'e' 1915 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) { 1916 skip_bits(&s->gb, 8); /* 'e' */ 1917 skip_bits(&s->gb, 16); /* version */ 1918 skip_bits(&s->gb, 16); /* flags0 */ 1919 skip_bits(&s->gb, 16); /* flags1 */ 1920 s->adobe_transform = get_bits(&s->gb, 8); 1921 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 1922 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform); 1923 len -= 7; 1924 goto out; 1925 } 1926 1927 if (id == AV_RB32("LJIF")) { 1928 int rgb = s->rgb; 1929 int pegasus_rct = s->pegasus_rct; 1930 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 1931 av_log(s->avctx, AV_LOG_INFO, 1932 "Pegasus lossless jpeg header found\n"); 1933 skip_bits(&s->gb, 16); /* version ? */ 1934 skip_bits(&s->gb, 16); /* unknown always 0? */ 1935 skip_bits(&s->gb, 16); /* unknown always 0? */ 1936 skip_bits(&s->gb, 16); /* unknown always 0? */ 1937 switch (i=get_bits(&s->gb, 8)) { 1938 case 1: 1939 rgb = 1; 1940 pegasus_rct = 0; 1941 break; 1942 case 2: 1943 rgb = 1; 1944 pegasus_rct = 1; 1945 break; 1946 default: 1947 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i); 1948 } 1949 1950 len -= 9; 1951 if (s->bayer) 1952 goto out; 1953 if (s->got_picture) 1954 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) { 1955 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n"); 1956 goto out; 1957 } 1958 1959 s->rgb = rgb; 1960 s->pegasus_rct = pegasus_rct; 1961 1962 goto out; 1963 } 1964 if (id == AV_RL32("colr") && len > 0) { 1965 s->colr = get_bits(&s->gb, 8); 1966 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 1967 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr); 1968 len --; 1969 goto out; 1970 } 1971 if (id == AV_RL32("xfrm") && len > 0) { 1972 s->xfrm = get_bits(&s->gb, 8); 1973 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 1974 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm); 1975 len --; 1976 goto out; 1977 } 1978 1979 /* JPS extension by VRex */ 1980 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) { 1981 int flags, layout, type; 1982 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 1983 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n"); 1984 1985 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */ 1986 skip_bits(&s->gb, 16); len -= 2; /* block length */ 1987 skip_bits(&s->gb, 8); /* reserved */ 1988 flags = get_bits(&s->gb, 8); 1989 layout = get_bits(&s->gb, 8); 1990 type = get_bits(&s->gb, 8); 1991 len -= 4; 1992 1993 av_freep(&s->stereo3d); 1994 s->stereo3d = av_stereo3d_alloc(); 1995 if (!s->stereo3d) { 1996 goto out; 1997 } 1998 if (type == 0) { 1999 s->stereo3d->type = AV_STEREO3D_2D; 2000 } else if (type == 1) { 2001 switch (layout) { 2002 case 0x01: 2003 s->stereo3d->type = AV_STEREO3D_LINES; 2004 break; 2005 case 0x02: 2006 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE; 2007 break; 2008 case 0x03: 2009 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM; 2010 break; 2011 } 2012 if (!(flags & 0x04)) { 2013 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT; 2014 } 2015 } 2016 goto out; 2017 } 2018 2019 /* EXIF metadata */ 2020 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) { 2021 GetByteContext gbytes; 2022 int ret, le, ifd_offset, bytes_read; 2023 const uint8_t *aligned; 2024 2025 skip_bits(&s->gb, 16); // skip padding 2026 len -= 2; 2027 2028 // init byte wise reading 2029 aligned = align_get_bits(&s->gb); 2030 bytestream2_init(&gbytes, aligned, len); 2031 2032 // read TIFF header 2033 ret = ff_tdecode_header(&gbytes, &le, &ifd_offset); 2034 if (ret) { 2035 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n"); 2036 } else { 2037 bytestream2_seek(&gbytes, ifd_offset, SEEK_SET); 2038 2039 // read 0th IFD and store the metadata 2040 // (return values > 0 indicate the presence of subimage metadata) 2041 ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata); 2042 if (ret < 0) { 2043 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n"); 2044 } 2045 } 2046 2047 bytes_read = bytestream2_tell(&gbytes); 2048 skip_bits(&s->gb, bytes_read << 3); 2049 len -= bytes_read; 2050 2051 goto out; 2052 } 2053 2054 /* Apple MJPEG-A */ 2055 if ((s->start_code == APP1) && (len > (0x28 - 8))) { 2056 id = get_bits_long(&s->gb, 32); 2057 len -= 4; 2058 /* Apple MJPEG-A */ 2059 if (id == AV_RB32("mjpg")) { 2060 /* structure: 2061 4bytes field size 2062 4bytes pad field size 2063 4bytes next off 2064 4bytes quant off 2065 4bytes huff off 2066 4bytes image off 2067 4bytes scan off 2068 4bytes data off 2069 */ 2070 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 2071 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n"); 2072 } 2073 } 2074 2075 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) { 2076 int id2; 2077 unsigned seqno; 2078 unsigned nummarkers; 2079 2080 id = get_bits_long(&s->gb, 32); 2081 id2 = get_bits(&s->gb, 24); 2082 len -= 7; 2083 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) { 2084 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n"); 2085 goto out; 2086 } 2087 2088 skip_bits(&s->gb, 8); 2089 seqno = get_bits(&s->gb, 8); 2090 len -= 2; 2091 if (seqno == 0) { 2092 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n"); 2093 goto out; 2094 } 2095 2096 nummarkers = get_bits(&s->gb, 8); 2097 len -= 1; 2098 if (nummarkers == 0) { 2099 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n"); 2100 goto out; 2101 } else if (s->iccnum != 0 && nummarkers != s->iccnum) { 2102 av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n"); 2103 goto out; 2104 } else if (seqno > nummarkers) { 2105 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n"); 2106 goto out; 2107 } 2108 2109 /* Allocate if this is the first APP2 we've seen. */ 2110 if (s->iccnum == 0) { 2111 if (!FF_ALLOCZ_TYPED_ARRAY(s->iccentries, nummarkers)) { 2112 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n"); 2113 return AVERROR(ENOMEM); 2114 } 2115 s->iccnum = nummarkers; 2116 } 2117 2118 if (s->iccentries[seqno - 1].data) { 2119 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n"); 2120 goto out; 2121 } 2122 2123 s->iccentries[seqno - 1].length = len; 2124 s->iccentries[seqno - 1].data = av_malloc(len); 2125 if (!s->iccentries[seqno - 1].data) { 2126 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n"); 2127 return AVERROR(ENOMEM); 2128 } 2129 2130 memcpy(s->iccentries[seqno - 1].data, align_get_bits(&s->gb), len); 2131 skip_bits(&s->gb, len << 3); 2132 len = 0; 2133 s->iccread++; 2134 2135 if (s->iccread > s->iccnum) 2136 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n"); 2137 } 2138 2139out: 2140 /* slow but needed for extreme adobe jpegs */ 2141 if (len < 0) 2142 av_log(s->avctx, AV_LOG_ERROR, 2143 "mjpeg: error, decode_app parser read over the end\n"); 2144 while (--len > 0) 2145 skip_bits(&s->gb, 8); 2146 2147 return 0; 2148} 2149 2150static int mjpeg_decode_com(MJpegDecodeContext *s) 2151{ 2152 int len = get_bits(&s->gb, 16); 2153 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) { 2154 int i; 2155 char *cbuf = av_malloc(len - 1); 2156 if (!cbuf) 2157 return AVERROR(ENOMEM); 2158 2159 for (i = 0; i < len - 2; i++) 2160 cbuf[i] = get_bits(&s->gb, 8); 2161 if (i > 0 && cbuf[i - 1] == '\n') 2162 cbuf[i - 1] = 0; 2163 else 2164 cbuf[i] = 0; 2165 2166 if (s->avctx->debug & FF_DEBUG_PICT_INFO) 2167 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf); 2168 2169 /* buggy avid, it puts EOI only at every 10th frame */ 2170 if (!strncmp(cbuf, "AVID", 4)) { 2171 parse_avid(s, cbuf, len); 2172 } else if (!strcmp(cbuf, "CS=ITU601")) 2173 s->cs_itu601 = 1; 2174 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) || 2175 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20))) 2176 s->flipped = 1; 2177 else if (!strcmp(cbuf, "MULTISCOPE II")) { 2178 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 }; 2179 s->multiscope = 2; 2180 } 2181 2182 av_free(cbuf); 2183 } 2184 2185 return 0; 2186} 2187 2188/* return the 8 bit start code value and update the search 2189 state. Return -1 if no start code found */ 2190static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end) 2191{ 2192 const uint8_t *buf_ptr; 2193 unsigned int v, v2; 2194 int val; 2195 int skipped = 0; 2196 2197 buf_ptr = *pbuf_ptr; 2198 while (buf_end - buf_ptr > 1) { 2199 v = *buf_ptr++; 2200 v2 = *buf_ptr; 2201 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) { 2202 val = *buf_ptr++; 2203 goto found; 2204 } 2205 skipped++; 2206 } 2207 buf_ptr = buf_end; 2208 val = -1; 2209found: 2210 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped); 2211 *pbuf_ptr = buf_ptr; 2212 return val; 2213} 2214 2215int ff_mjpeg_find_marker(MJpegDecodeContext *s, 2216 const uint8_t **buf_ptr, const uint8_t *buf_end, 2217 const uint8_t **unescaped_buf_ptr, 2218 int *unescaped_buf_size) 2219{ 2220 int start_code; 2221 start_code = find_marker(buf_ptr, buf_end); 2222 2223 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr); 2224 if (!s->buffer) 2225 return AVERROR(ENOMEM); 2226 2227 /* unescape buffer of SOS, use special treatment for JPEG-LS */ 2228 if (start_code == SOS && !s->ls) { 2229 const uint8_t *src = *buf_ptr; 2230 const uint8_t *ptr = src; 2231 uint8_t *dst = s->buffer; 2232 2233 #define copy_data_segment(skip) do { \ 2234 ptrdiff_t length = (ptr - src) - (skip); \ 2235 if (length > 0) { \ 2236 memcpy(dst, src, length); \ 2237 dst += length; \ 2238 src = ptr; \ 2239 } \ 2240 } while (0) 2241 2242 if (s->avctx->codec_id == AV_CODEC_ID_THP) { 2243 ptr = buf_end; 2244 copy_data_segment(0); 2245 } else { 2246 while (ptr < buf_end) { 2247 uint8_t x = *(ptr++); 2248 2249 if (x == 0xff) { 2250 ptrdiff_t skip = 0; 2251 while (ptr < buf_end && x == 0xff) { 2252 x = *(ptr++); 2253 skip++; 2254 } 2255 2256 /* 0xFF, 0xFF, ... */ 2257 if (skip > 1) { 2258 copy_data_segment(skip); 2259 2260 /* decrement src as it is equal to ptr after the 2261 * copy_data_segment macro and we might want to 2262 * copy the current value of x later on */ 2263 src--; 2264 } 2265 2266 if (x < RST0 || x > RST7) { 2267 copy_data_segment(1); 2268 if (x) 2269 break; 2270 } 2271 } 2272 } 2273 if (src < ptr) 2274 copy_data_segment(0); 2275 } 2276 #undef copy_data_segment 2277 2278 *unescaped_buf_ptr = s->buffer; 2279 *unescaped_buf_size = dst - s->buffer; 2280 memset(s->buffer + *unescaped_buf_size, 0, 2281 AV_INPUT_BUFFER_PADDING_SIZE); 2282 2283 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n", 2284 (buf_end - *buf_ptr) - (dst - s->buffer)); 2285 } else if (start_code == SOS && s->ls) { 2286 const uint8_t *src = *buf_ptr; 2287 uint8_t *dst = s->buffer; 2288 int bit_count = 0; 2289 int t = 0, b = 0; 2290 PutBitContext pb; 2291 2292 /* find marker */ 2293 while (src + t < buf_end) { 2294 uint8_t x = src[t++]; 2295 if (x == 0xff) { 2296 while ((src + t < buf_end) && x == 0xff) 2297 x = src[t++]; 2298 if (x & 0x80) { 2299 t -= FFMIN(2, t); 2300 break; 2301 } 2302 } 2303 } 2304 bit_count = t * 8; 2305 init_put_bits(&pb, dst, t); 2306 2307 /* unescape bitstream */ 2308 while (b < t) { 2309 uint8_t x = src[b++]; 2310 put_bits(&pb, 8, x); 2311 if (x == 0xFF && b < t) { 2312 x = src[b++]; 2313 if (x & 0x80) { 2314 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n"); 2315 x &= 0x7f; 2316 } 2317 put_bits(&pb, 7, x); 2318 bit_count--; 2319 } 2320 } 2321 flush_put_bits(&pb); 2322 2323 *unescaped_buf_ptr = dst; 2324 *unescaped_buf_size = (bit_count + 7) >> 3; 2325 memset(s->buffer + *unescaped_buf_size, 0, 2326 AV_INPUT_BUFFER_PADDING_SIZE); 2327 } else { 2328 *unescaped_buf_ptr = *buf_ptr; 2329 *unescaped_buf_size = buf_end - *buf_ptr; 2330 } 2331 2332 return start_code; 2333} 2334 2335static void reset_icc_profile(MJpegDecodeContext *s) 2336{ 2337 int i; 2338 2339 if (s->iccentries) { 2340 for (i = 0; i < s->iccnum; i++) 2341 av_freep(&s->iccentries[i].data); 2342 av_freep(&s->iccentries); 2343 } 2344 2345 s->iccread = 0; 2346 s->iccnum = 0; 2347} 2348 2349// SMV JPEG just stacks several output frames into one JPEG picture 2350// we handle that by setting up the cropping parameters appropriately 2351static int smv_process_frame(AVCodecContext *avctx, AVFrame *frame) 2352{ 2353 MJpegDecodeContext *s = avctx->priv_data; 2354 int ret; 2355 2356 if (s->smv_next_frame > 0) { 2357 av_assert0(s->smv_frame->buf[0]); 2358 av_frame_unref(frame); 2359 ret = av_frame_ref(frame, s->smv_frame); 2360 if (ret < 0) 2361 return ret; 2362 } else { 2363 av_assert0(frame->buf[0]); 2364 av_frame_unref(s->smv_frame); 2365 ret = av_frame_ref(s->smv_frame, frame); 2366 if (ret < 0) 2367 return ret; 2368 } 2369 2370 av_assert0((s->smv_next_frame + 1) * avctx->height <= avctx->coded_height); 2371 2372 frame->width = avctx->coded_width; 2373 frame->height = avctx->coded_height; 2374 frame->crop_top = FFMIN(s->smv_next_frame * avctx->height, frame->height); 2375 frame->crop_bottom = frame->height - (s->smv_next_frame + 1) * avctx->height; 2376 2377 s->smv_next_frame = (s->smv_next_frame + 1) % s->smv_frames_per_jpeg; 2378 2379 if (s->smv_next_frame == 0) 2380 av_frame_unref(s->smv_frame); 2381 2382 return 0; 2383} 2384 2385static int mjpeg_get_packet(AVCodecContext *avctx) 2386{ 2387 MJpegDecodeContext *s = avctx->priv_data; 2388 int ret; 2389 2390 av_packet_unref(s->pkt); 2391 ret = ff_decode_get_packet(avctx, s->pkt); 2392 if (ret < 0) 2393 return ret; 2394 2395#if CONFIG_SP5X_DECODER || CONFIG_AMV_DECODER 2396 if (avctx->codec_id == AV_CODEC_ID_SP5X || 2397 avctx->codec_id == AV_CODEC_ID_AMV) { 2398 ret = ff_sp5x_process_packet(avctx, s->pkt); 2399 if (ret < 0) 2400 return ret; 2401 } 2402#endif 2403 2404 s->buf_size = s->pkt->size; 2405 2406 return 0; 2407} 2408 2409int ff_mjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame) 2410{ 2411 MJpegDecodeContext *s = avctx->priv_data; 2412 const uint8_t *buf_end, *buf_ptr; 2413 const uint8_t *unescaped_buf_ptr; 2414 int hshift, vshift; 2415 int unescaped_buf_size; 2416 int start_code; 2417 int i, index; 2418 int ret = 0; 2419 int is16bit; 2420 AVDictionaryEntry *e = NULL; 2421 2422 s->force_pal8 = 0; 2423 2424 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG && s->smv_next_frame > 0) 2425 return smv_process_frame(avctx, frame); 2426 2427 av_dict_free(&s->exif_metadata); 2428 av_freep(&s->stereo3d); 2429 s->adobe_transform = -1; 2430 2431 if (s->iccnum != 0) 2432 reset_icc_profile(s); 2433 2434 ret = mjpeg_get_packet(avctx); 2435 if (ret < 0) 2436 return ret; 2437redo_for_pal8: 2438 buf_ptr = s->pkt->data; 2439 buf_end = s->pkt->data + s->pkt->size; 2440 while (buf_ptr < buf_end) { 2441 /* find start next marker */ 2442 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end, 2443 &unescaped_buf_ptr, 2444 &unescaped_buf_size); 2445 /* EOF */ 2446 if (start_code < 0) { 2447 break; 2448 } else if (unescaped_buf_size > INT_MAX / 8) { 2449 av_log(avctx, AV_LOG_ERROR, 2450 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n", 2451 start_code, unescaped_buf_size, s->pkt->size); 2452 return AVERROR_INVALIDDATA; 2453 } 2454 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n", 2455 start_code, buf_end - buf_ptr); 2456 2457 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size); 2458 2459 if (ret < 0) { 2460 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n"); 2461 goto fail; 2462 } 2463 2464 s->start_code = start_code; 2465 if (s->avctx->debug & FF_DEBUG_STARTCODE) 2466 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code); 2467 2468 /* process markers */ 2469 if (start_code >= RST0 && start_code <= RST7) { 2470 av_log(avctx, AV_LOG_DEBUG, 2471 "restart marker: %d\n", start_code & 0x0f); 2472 /* APP fields */ 2473 } else if (start_code >= APP0 && start_code <= APP15) { 2474 if ((ret = mjpeg_decode_app(s)) < 0) 2475 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n", 2476 av_err2str(ret)); 2477 /* Comment */ 2478 } else if (start_code == COM) { 2479 ret = mjpeg_decode_com(s); 2480 if (ret < 0) 2481 return ret; 2482 } else if (start_code == DQT) { 2483 ret = ff_mjpeg_decode_dqt(s); 2484 if (ret < 0) 2485 return ret; 2486 } 2487 2488 ret = -1; 2489 2490 if (!CONFIG_JPEGLS_DECODER && 2491 (start_code == SOF48 || start_code == LSE)) { 2492 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n"); 2493 return AVERROR(ENOSYS); 2494 } 2495 2496 if (avctx->skip_frame == AVDISCARD_ALL) { 2497 switch(start_code) { 2498 case SOF0: 2499 case SOF1: 2500 case SOF2: 2501 case SOF3: 2502 case SOF48: 2503 case SOI: 2504 case SOS: 2505 case EOI: 2506 break; 2507 default: 2508 goto skip; 2509 } 2510 } 2511 2512 switch (start_code) { 2513 case SOI: 2514 s->restart_interval = 0; 2515 s->restart_count = 0; 2516 s->raw_image_buffer = buf_ptr; 2517 s->raw_image_buffer_size = buf_end - buf_ptr; 2518 /* nothing to do on SOI */ 2519 break; 2520 case DHT: 2521 if ((ret = ff_mjpeg_decode_dht(s)) < 0) { 2522 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n"); 2523 goto fail; 2524 } 2525 break; 2526 case SOF0: 2527 case SOF1: 2528 if (start_code == SOF0) 2529 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT; 2530 else 2531 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT; 2532 s->lossless = 0; 2533 s->ls = 0; 2534 s->progressive = 0; 2535 if ((ret = ff_mjpeg_decode_sof(s)) < 0) 2536 goto fail; 2537 break; 2538 case SOF2: 2539 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT; 2540 s->lossless = 0; 2541 s->ls = 0; 2542 s->progressive = 1; 2543 if ((ret = ff_mjpeg_decode_sof(s)) < 0) 2544 goto fail; 2545 break; 2546 case SOF3: 2547 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS; 2548 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS; 2549 s->lossless = 1; 2550 s->ls = 0; 2551 s->progressive = 0; 2552 if ((ret = ff_mjpeg_decode_sof(s)) < 0) 2553 goto fail; 2554 break; 2555 case SOF48: 2556 s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS; 2557 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS; 2558 s->lossless = 1; 2559 s->ls = 1; 2560 s->progressive = 0; 2561 if ((ret = ff_mjpeg_decode_sof(s)) < 0) 2562 goto fail; 2563 break; 2564 case LSE: 2565 if (!CONFIG_JPEGLS_DECODER || 2566 (ret = ff_jpegls_decode_lse(s)) < 0) 2567 goto fail; 2568 if (ret == 1) 2569 goto redo_for_pal8; 2570 break; 2571 case EOI: 2572eoi_parser: 2573 if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL && 2574 s->progressive && s->cur_scan && s->got_picture) 2575 mjpeg_idct_scan_progressive_ac(s); 2576 s->cur_scan = 0; 2577 if (!s->got_picture) { 2578 av_log(avctx, AV_LOG_WARNING, 2579 "Found EOI before any SOF, ignoring\n"); 2580 break; 2581 } 2582 if (s->interlaced) { 2583 s->bottom_field ^= 1; 2584 /* if not bottom field, do not output image yet */ 2585 if (s->bottom_field == !s->interlace_polarity) 2586 break; 2587 } 2588 if (avctx->skip_frame == AVDISCARD_ALL) { 2589 s->got_picture = 0; 2590 ret = AVERROR(EAGAIN); 2591 goto the_end_no_picture; 2592 } 2593 if (s->avctx->hwaccel) { 2594 ret = s->avctx->hwaccel->end_frame(s->avctx); 2595 if (ret < 0) 2596 return ret; 2597 2598 av_freep(&s->hwaccel_picture_private); 2599 } 2600 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0) 2601 return ret; 2602 s->got_picture = 0; 2603 2604 frame->pkt_dts = s->pkt->dts; 2605 2606 if (!s->lossless && avctx->debug & FF_DEBUG_QP) { 2607 int qp = FFMAX3(s->qscale[0], 2608 s->qscale[1], 2609 s->qscale[2]); 2610 2611 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp); 2612 } 2613 2614 goto the_end; 2615 case SOS: 2616 s->raw_scan_buffer = buf_ptr; 2617 s->raw_scan_buffer_size = buf_end - buf_ptr; 2618 2619 s->cur_scan++; 2620 if (avctx->skip_frame == AVDISCARD_ALL) { 2621 skip_bits(&s->gb, get_bits_left(&s->gb)); 2622 break; 2623 } 2624 2625 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 && 2626 (avctx->err_recognition & AV_EF_EXPLODE)) 2627 goto fail; 2628 break; 2629 case DRI: 2630 if ((ret = mjpeg_decode_dri(s)) < 0) 2631 return ret; 2632 break; 2633 case SOF5: 2634 case SOF6: 2635 case SOF7: 2636 case SOF9: 2637 case SOF10: 2638 case SOF11: 2639 case SOF13: 2640 case SOF14: 2641 case SOF15: 2642 case JPG: 2643 av_log(avctx, AV_LOG_ERROR, 2644 "mjpeg: unsupported coding type (%x)\n", start_code); 2645 break; 2646 } 2647 2648skip: 2649 /* eof process start code */ 2650 buf_ptr += (get_bits_count(&s->gb) + 7) / 8; 2651 av_log(avctx, AV_LOG_DEBUG, 2652 "marker parser used %d bytes (%d bits)\n", 2653 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb)); 2654 } 2655 if (s->got_picture && s->cur_scan) { 2656 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n"); 2657 goto eoi_parser; 2658 } 2659 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n"); 2660 return AVERROR_INVALIDDATA; 2661fail: 2662 s->got_picture = 0; 2663 return ret; 2664the_end: 2665 2666 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1; 2667 2668 if (AV_RB32(s->upscale_h)) { 2669 int p; 2670 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P || 2671 avctx->pix_fmt == AV_PIX_FMT_YUV444P || 2672 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P || 2673 avctx->pix_fmt == AV_PIX_FMT_YUV440P || 2674 avctx->pix_fmt == AV_PIX_FMT_YUVA444P || 2675 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P || 2676 avctx->pix_fmt == AV_PIX_FMT_YUV420P || 2677 avctx->pix_fmt == AV_PIX_FMT_YUV420P16|| 2678 avctx->pix_fmt == AV_PIX_FMT_YUVA420P || 2679 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16|| 2680 avctx->pix_fmt == AV_PIX_FMT_GBRP || 2681 avctx->pix_fmt == AV_PIX_FMT_GBRAP 2682 ); 2683 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift); 2684 if (ret) 2685 return ret; 2686 2687 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format)); 2688 for (p = 0; p<s->nb_components; p++) { 2689 uint8_t *line = s->picture_ptr->data[p]; 2690 int w = s->width; 2691 int h = s->height; 2692 if (!s->upscale_h[p]) 2693 continue; 2694 if (p==1 || p==2) { 2695 w = AV_CEIL_RSHIFT(w, hshift); 2696 h = AV_CEIL_RSHIFT(h, vshift); 2697 } 2698 if (s->upscale_v[p] == 1) 2699 h = (h+1)>>1; 2700 av_assert0(w > 0); 2701 for (i = 0; i < h; i++) { 2702 if (s->upscale_h[p] == 1) { 2703 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2]; 2704 else line[w - 1] = line[(w - 1) / 2]; 2705 for (index = w - 2; index > 0; index--) { 2706 if (is16bit) 2707 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1; 2708 else 2709 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1; 2710 } 2711 } else if (s->upscale_h[p] == 2) { 2712 if (is16bit) { 2713 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3]; 2714 if (w > 1) 2715 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1]; 2716 } else { 2717 line[w - 1] = line[(w - 1) / 3]; 2718 if (w > 1) 2719 line[w - 2] = line[w - 1]; 2720 } 2721 for (index = w - 3; index > 0; index--) { 2722 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3; 2723 } 2724 } 2725 line += s->linesize[p]; 2726 } 2727 } 2728 } 2729 if (AV_RB32(s->upscale_v)) { 2730 int p; 2731 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P || 2732 avctx->pix_fmt == AV_PIX_FMT_YUV444P || 2733 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P || 2734 avctx->pix_fmt == AV_PIX_FMT_YUV422P || 2735 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P || 2736 avctx->pix_fmt == AV_PIX_FMT_YUV420P || 2737 avctx->pix_fmt == AV_PIX_FMT_YUV440P || 2738 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P || 2739 avctx->pix_fmt == AV_PIX_FMT_YUVA444P || 2740 avctx->pix_fmt == AV_PIX_FMT_YUVA420P || 2741 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16|| 2742 avctx->pix_fmt == AV_PIX_FMT_GBRP || 2743 avctx->pix_fmt == AV_PIX_FMT_GBRAP 2744 ); 2745 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift); 2746 if (ret) 2747 return ret; 2748 2749 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format)); 2750 for (p = 0; p < s->nb_components; p++) { 2751 uint8_t *dst; 2752 int w = s->width; 2753 int h = s->height; 2754 if (!s->upscale_v[p]) 2755 continue; 2756 if (p==1 || p==2) { 2757 w = AV_CEIL_RSHIFT(w, hshift); 2758 h = AV_CEIL_RSHIFT(h, vshift); 2759 } 2760 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]]; 2761 for (i = h - 1; i; i--) { 2762 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]]; 2763 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]]; 2764 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) { 2765 memcpy(dst, src1, w); 2766 } else { 2767 for (index = 0; index < w; index++) 2768 dst[index] = (src1[index] + src2[index]) >> 1; 2769 } 2770 dst -= s->linesize[p]; 2771 } 2772 } 2773 } 2774 if (s->flipped && !s->rgb) { 2775 int j; 2776 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift); 2777 if (ret) 2778 return ret; 2779 2780 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format)); 2781 for (index=0; index<s->nb_components; index++) { 2782 uint8_t *dst = s->picture_ptr->data[index]; 2783 int w = s->picture_ptr->width; 2784 int h = s->picture_ptr->height; 2785 if(index && index<3){ 2786 w = AV_CEIL_RSHIFT(w, hshift); 2787 h = AV_CEIL_RSHIFT(h, vshift); 2788 } 2789 if(dst){ 2790 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1); 2791 for (i=0; i<h/2; i++) { 2792 for (j=0; j<w; j++) 2793 FFSWAP(int, dst[j], dst2[j]); 2794 dst += s->picture_ptr->linesize[index]; 2795 dst2 -= s->picture_ptr->linesize[index]; 2796 } 2797 } 2798 } 2799 } 2800 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) { 2801 int w = s->picture_ptr->width; 2802 int h = s->picture_ptr->height; 2803 av_assert0(s->nb_components == 4); 2804 for (i=0; i<h; i++) { 2805 int j; 2806 uint8_t *dst[4]; 2807 for (index=0; index<4; index++) { 2808 dst[index] = s->picture_ptr->data[index] 2809 + s->picture_ptr->linesize[index]*i; 2810 } 2811 for (j=0; j<w; j++) { 2812 int k = dst[3][j]; 2813 int r = dst[0][j] * k; 2814 int g = dst[1][j] * k; 2815 int b = dst[2][j] * k; 2816 dst[0][j] = g*257 >> 16; 2817 dst[1][j] = b*257 >> 16; 2818 dst[2][j] = r*257 >> 16; 2819 dst[3][j] = 255; 2820 } 2821 } 2822 } 2823 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) { 2824 int w = s->picture_ptr->width; 2825 int h = s->picture_ptr->height; 2826 av_assert0(s->nb_components == 4); 2827 for (i=0; i<h; i++) { 2828 int j; 2829 uint8_t *dst[4]; 2830 for (index=0; index<4; index++) { 2831 dst[index] = s->picture_ptr->data[index] 2832 + s->picture_ptr->linesize[index]*i; 2833 } 2834 for (j=0; j<w; j++) { 2835 int k = dst[3][j]; 2836 int r = (255 - dst[0][j]) * k; 2837 int g = (128 - dst[1][j]) * k; 2838 int b = (128 - dst[2][j]) * k; 2839 dst[0][j] = r*257 >> 16; 2840 dst[1][j] = (g*257 >> 16) + 128; 2841 dst[2][j] = (b*257 >> 16) + 128; 2842 dst[3][j] = 255; 2843 } 2844 } 2845 } 2846 2847 if (s->stereo3d) { 2848 AVStereo3D *stereo = av_stereo3d_create_side_data(frame); 2849 if (stereo) { 2850 stereo->type = s->stereo3d->type; 2851 stereo->flags = s->stereo3d->flags; 2852 } 2853 av_freep(&s->stereo3d); 2854 } 2855 2856 if (s->iccnum != 0 && s->iccnum == s->iccread) { 2857 AVFrameSideData *sd; 2858 size_t offset = 0; 2859 int total_size = 0; 2860 int i; 2861 2862 /* Sum size of all parts. */ 2863 for (i = 0; i < s->iccnum; i++) 2864 total_size += s->iccentries[i].length; 2865 2866 sd = av_frame_new_side_data(frame, AV_FRAME_DATA_ICC_PROFILE, total_size); 2867 if (!sd) { 2868 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n"); 2869 return AVERROR(ENOMEM); 2870 } 2871 2872 /* Reassemble the parts, which are now in-order. */ 2873 for (i = 0; i < s->iccnum; i++) { 2874 memcpy(sd->data + offset, s->iccentries[i].data, s->iccentries[i].length); 2875 offset += s->iccentries[i].length; 2876 } 2877 } 2878 2879 if (e = av_dict_get(s->exif_metadata, "Orientation", e, AV_DICT_IGNORE_SUFFIX)) { 2880 char *value = e->value + strspn(e->value, " \n\t\r"), *endptr; 2881 int orientation = strtol(value, &endptr, 0); 2882 2883 if (!*endptr) { 2884 AVFrameSideData *sd = NULL; 2885 2886 if (orientation >= 2 && orientation <= 8) { 2887 int32_t *matrix; 2888 2889 sd = av_frame_new_side_data(frame, AV_FRAME_DATA_DISPLAYMATRIX, sizeof(int32_t) * 9); 2890 if (!sd) { 2891 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n"); 2892 return AVERROR(ENOMEM); 2893 } 2894 2895 matrix = (int32_t *)sd->data; 2896 2897 switch (orientation) { 2898 case 2: 2899 av_display_rotation_set(matrix, 0.0); 2900 av_display_matrix_flip(matrix, 1, 0); 2901 break; 2902 case 3: 2903 av_display_rotation_set(matrix, 180.0); 2904 break; 2905 case 4: 2906 av_display_rotation_set(matrix, 180.0); 2907 av_display_matrix_flip(matrix, 1, 0); 2908 break; 2909 case 5: 2910 av_display_rotation_set(matrix, 90.0); 2911 av_display_matrix_flip(matrix, 1, 0); 2912 break; 2913 case 6: 2914 av_display_rotation_set(matrix, 90.0); 2915 break; 2916 case 7: 2917 av_display_rotation_set(matrix, -90.0); 2918 av_display_matrix_flip(matrix, 1, 0); 2919 break; 2920 case 8: 2921 av_display_rotation_set(matrix, -90.0); 2922 break; 2923 default: 2924 av_assert0(0); 2925 } 2926 } 2927 } 2928 } 2929 2930 av_dict_copy(&frame->metadata, s->exif_metadata, 0); 2931 av_dict_free(&s->exif_metadata); 2932 2933 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) { 2934 ret = smv_process_frame(avctx, frame); 2935 if (ret < 0) { 2936 av_frame_unref(frame); 2937 return ret; 2938 } 2939 } 2940 if ((avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') || 2941 avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) && 2942 avctx->coded_height > s->orig_height) { 2943 frame->height = AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres); 2944 frame->crop_top = frame->height - avctx->height; 2945 } 2946 2947 ret = 0; 2948 2949the_end_no_picture: 2950 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n", 2951 buf_end - buf_ptr); 2952 2953 return ret; 2954} 2955 2956/* mxpeg may call the following function (with a blank MJpegDecodeContext) 2957 * even without having called ff_mjpeg_decode_init(). */ 2958av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx) 2959{ 2960 MJpegDecodeContext *s = avctx->priv_data; 2961 int i, j; 2962 2963 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) { 2964 av_log(avctx, AV_LOG_INFO, "Single field\n"); 2965 } 2966 2967 if (s->picture) { 2968 av_frame_free(&s->picture); 2969 s->picture_ptr = NULL; 2970 } else if (s->picture_ptr) 2971 av_frame_unref(s->picture_ptr); 2972 2973 av_frame_free(&s->smv_frame); 2974 2975 av_freep(&s->buffer); 2976 av_freep(&s->stereo3d); 2977 av_freep(&s->ljpeg_buffer); 2978 s->ljpeg_buffer_size = 0; 2979 2980 for (i = 0; i < 3; i++) { 2981 for (j = 0; j < 4; j++) 2982 ff_free_vlc(&s->vlcs[i][j]); 2983 } 2984 for (i = 0; i < MAX_COMPONENTS; i++) { 2985 av_freep(&s->blocks[i]); 2986 av_freep(&s->last_nnz[i]); 2987 } 2988 av_dict_free(&s->exif_metadata); 2989 2990 reset_icc_profile(s); 2991 2992 av_freep(&s->hwaccel_picture_private); 2993 av_freep(&s->jls_state); 2994 2995 return 0; 2996} 2997 2998static void decode_flush(AVCodecContext *avctx) 2999{ 3000 MJpegDecodeContext *s = avctx->priv_data; 3001 s->got_picture = 0; 3002 3003 s->smv_next_frame = 0; 3004 av_frame_unref(s->smv_frame); 3005} 3006 3007#if CONFIG_MJPEG_DECODER 3008#define OFFSET(x) offsetof(MJpegDecodeContext, x) 3009#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM 3010static const AVOption options[] = { 3011 { "extern_huff", "Use external huffman table.", 3012 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD }, 3013 { NULL }, 3014}; 3015 3016static const AVClass mjpegdec_class = { 3017 .class_name = "MJPEG decoder", 3018 .item_name = av_default_item_name, 3019 .option = options, 3020 .version = LIBAVUTIL_VERSION_INT, 3021}; 3022 3023const FFCodec ff_mjpeg_decoder = { 3024 .p.name = "mjpeg", 3025 .p.long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"), 3026 .p.type = AVMEDIA_TYPE_VIDEO, 3027 .p.id = AV_CODEC_ID_MJPEG, 3028 .priv_data_size = sizeof(MJpegDecodeContext), 3029 .init = ff_mjpeg_decode_init, 3030 .close = ff_mjpeg_decode_end, 3031 FF_CODEC_RECEIVE_FRAME_CB(ff_mjpeg_receive_frame), 3032 .flush = decode_flush, 3033 .p.capabilities = AV_CODEC_CAP_DR1, 3034 .p.max_lowres = 3, 3035 .p.priv_class = &mjpegdec_class, 3036 .p.profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles), 3037 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP | 3038 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_SETS_PKT_DTS, 3039 .hw_configs = (const AVCodecHWConfigInternal *const []) { 3040#if CONFIG_MJPEG_NVDEC_HWACCEL 3041 HWACCEL_NVDEC(mjpeg), 3042#endif 3043#if CONFIG_MJPEG_VAAPI_HWACCEL 3044 HWACCEL_VAAPI(mjpeg), 3045#endif 3046 NULL 3047 }, 3048}; 3049#endif 3050#if CONFIG_THP_DECODER 3051const FFCodec ff_thp_decoder = { 3052 .p.name = "thp", 3053 .p.long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"), 3054 .p.type = AVMEDIA_TYPE_VIDEO, 3055 .p.id = AV_CODEC_ID_THP, 3056 .priv_data_size = sizeof(MJpegDecodeContext), 3057 .init = ff_mjpeg_decode_init, 3058 .close = ff_mjpeg_decode_end, 3059 FF_CODEC_RECEIVE_FRAME_CB(ff_mjpeg_receive_frame), 3060 .flush = decode_flush, 3061 .p.capabilities = AV_CODEC_CAP_DR1, 3062 .p.max_lowres = 3, 3063 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP | 3064 FF_CODEC_CAP_SETS_PKT_DTS, 3065}; 3066#endif 3067 3068#if CONFIG_SMVJPEG_DECODER 3069const FFCodec ff_smvjpeg_decoder = { 3070 .p.name = "smvjpeg", 3071 .p.long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"), 3072 .p.type = AVMEDIA_TYPE_VIDEO, 3073 .p.id = AV_CODEC_ID_SMVJPEG, 3074 .priv_data_size = sizeof(MJpegDecodeContext), 3075 .init = ff_mjpeg_decode_init, 3076 .close = ff_mjpeg_decode_end, 3077 FF_CODEC_RECEIVE_FRAME_CB(ff_mjpeg_receive_frame), 3078 .flush = decode_flush, 3079 .p.capabilities = AV_CODEC_CAP_DR1, 3080 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING | 3081 FF_CODEC_CAP_SETS_PKT_DTS | FF_CODEC_CAP_INIT_CLEANUP, 3082}; 3083#endif 3084