3 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2003 Alex Beregszaszi
5 * Copyright (c) 2003-2004 Michael Niedermayer
7 * Support for external huffman table, various fixes (AVID workaround),
8 * aspecting, new decode_frame mechanism and apple mjpeg-b support
11 * This file is part of FFmpeg.
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.
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.
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
33 #include "libavutil/imgutils.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/opt.h"
38 #include "copy_block.h"
43 #include "jpeglsdec.h"
46 #include "bytestream.h"
49 static int build_vlc(VLC
*vlc
, const uint8_t *bits_table
,
50 const uint8_t *val_table
, int nb_codes
,
51 int use_static
, int is_ac
)
53 uint8_t huff_size
[256] = { 0 };
54 uint16_t huff_code
[256];
55 uint16_t huff_sym
[256];
58 av_assert0(nb_codes
<= 256);
60 ff_mjpeg_build_huffman_codes(huff_size
, huff_code
, bits_table
, val_table
);
62 for (i
= 0; i
< 256; i
++)
63 huff_sym
[i
] = i
+ 16 * is_ac
;
66 huff_sym
[0] = 16 * 256;
68 return ff_init_vlc_sparse(vlc
, 9, nb_codes
, huff_size
, 1, 1,
69 huff_code
, 2, 2, huff_sym
, 2, 2, use_static
);
72 static void build_basic_mjpeg_vlc(MJpegDecodeContext
*s
)
74 build_vlc(&s
->vlcs
[0][0], avpriv_mjpeg_bits_dc_luminance
,
75 avpriv_mjpeg_val_dc
, 12, 0, 0);
76 build_vlc(&s
->vlcs
[0][1], avpriv_mjpeg_bits_dc_chrominance
,
77 avpriv_mjpeg_val_dc
, 12, 0, 0);
78 build_vlc(&s
->vlcs
[1][0], avpriv_mjpeg_bits_ac_luminance
,
79 avpriv_mjpeg_val_ac_luminance
, 251, 0, 1);
80 build_vlc(&s
->vlcs
[1][1], avpriv_mjpeg_bits_ac_chrominance
,
81 avpriv_mjpeg_val_ac_chrominance
, 251, 0, 1);
82 build_vlc(&s
->vlcs
[2][0], avpriv_mjpeg_bits_ac_luminance
,
83 avpriv_mjpeg_val_ac_luminance
, 251, 0, 0);
84 build_vlc(&s
->vlcs
[2][1], avpriv_mjpeg_bits_ac_chrominance
,
85 avpriv_mjpeg_val_ac_chrominance
, 251, 0, 0);
88 static void parse_avid(MJpegDecodeContext
*s
, uint8_t *buf
, int len
)
91 if (len
> 14 && buf
[12] == 1) /* 1 - NTSC */
92 s
->interlace_polarity
= 1;
93 if (len
> 14 && buf
[12] == 2) /* 2 - PAL */
94 s
->interlace_polarity
= 0;
95 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
96 av_log(s
->avctx
, AV_LOG_INFO
, "AVID: len:%d %d\n", len
, len
> 14 ? buf
[12] : -1);
99 av_cold
int ff_mjpeg_decode_init(AVCodecContext
*avctx
)
101 MJpegDecodeContext
*s
= avctx
->priv_data
;
103 if (!s
->picture_ptr
) {
104 s
->picture
= av_frame_alloc();
106 return AVERROR(ENOMEM
);
107 s
->picture_ptr
= s
->picture
;
111 ff_blockdsp_init(&s
->bdsp
, avctx
);
112 ff_hpeldsp_init(&s
->hdsp
, avctx
->flags
);
113 ff_idctdsp_init(&s
->idsp
, avctx
);
114 ff_init_scantable(s
->idsp
.idct_permutation
, &s
->scantable
,
119 s
->first_picture
= 1;
121 s
->org_height
= avctx
->coded_height
;
122 avctx
->chroma_sample_location
= AVCHROMA_LOC_CENTER
;
123 avctx
->colorspace
= AVCOL_SPC_BT470BG
;
125 build_basic_mjpeg_vlc(s
);
127 if (s
->extern_huff
) {
128 av_log(avctx
, AV_LOG_INFO
, "using external huffman table\n");
129 init_get_bits(&s
->gb
, avctx
->extradata
, avctx
->extradata_size
* 8);
130 if (ff_mjpeg_decode_dht(s
)) {
131 av_log(avctx
, AV_LOG_ERROR
,
132 "error using external huffman table, switching back to internal\n");
133 build_basic_mjpeg_vlc(s
);
136 if (avctx
->field_order
== AV_FIELD_BB
) { /* quicktime icefloe 019 */
137 s
->interlace_polarity
= 1; /* bottom field first */
138 av_log(avctx
, AV_LOG_DEBUG
, "bottom field first\n");
139 } else if (avctx
->field_order
== AV_FIELD_UNKNOWN
) {
140 if (avctx
->codec_tag
== AV_RL32("MJPG"))
141 s
->interlace_polarity
= 1;
144 if ( avctx
->extradata_size
> 8
145 && AV_RL32(avctx
->extradata
) == 0x2C
146 && AV_RL32(avctx
->extradata
+4) == 0x18) {
147 parse_avid(s
, avctx
->extradata
, avctx
->extradata_size
);
150 if (avctx
->codec
->id
== AV_CODEC_ID_AMV
)
157 /* quantize tables */
158 int ff_mjpeg_decode_dqt(MJpegDecodeContext
*s
)
160 int len
, index
, i
, j
;
162 len
= get_bits(&s
->gb
, 16) - 2;
165 int pr
= get_bits(&s
->gb
, 4);
167 av_log(s
->avctx
, AV_LOG_ERROR
, "dqt: invalid precision\n");
168 return AVERROR_INVALIDDATA
;
170 index
= get_bits(&s
->gb
, 4);
173 av_log(s
->avctx
, AV_LOG_DEBUG
, "index=%d\n", index
);
174 /* read quant table */
175 for (i
= 0; i
< 64; i
++) {
176 j
= s
->scantable
.permutated
[i
];
177 s
->quant_matrixes
[index
][j
] = get_bits(&s
->gb
, pr
? 16 : 8);
180 // XXX FIXME finetune, and perhaps add dc too
181 s
->qscale
[index
] = FFMAX(s
->quant_matrixes
[index
][s
->scantable
.permutated
[1]],
182 s
->quant_matrixes
[index
][s
->scantable
.permutated
[8]]) >> 1;
183 av_log(s
->avctx
, AV_LOG_DEBUG
, "qscale[%d]: %d\n",
184 index
, s
->qscale
[index
]);
190 /* decode huffman tables and build VLC decoders */
191 int ff_mjpeg_decode_dht(MJpegDecodeContext
*s
)
193 int len
, index
, i
, class, n
, v
, code_max
;
194 uint8_t bits_table
[17];
195 uint8_t val_table
[256];
198 len
= get_bits(&s
->gb
, 16) - 2;
202 return AVERROR_INVALIDDATA
;
203 class = get_bits(&s
->gb
, 4);
205 return AVERROR_INVALIDDATA
;
206 index
= get_bits(&s
->gb
, 4);
208 return AVERROR_INVALIDDATA
;
210 for (i
= 1; i
<= 16; i
++) {
211 bits_table
[i
] = get_bits(&s
->gb
, 8);
215 if (len
< n
|| n
> 256)
216 return AVERROR_INVALIDDATA
;
219 for (i
= 0; i
< n
; i
++) {
220 v
= get_bits(&s
->gb
, 8);
227 /* build VLC and flush previous vlc if present */
228 ff_free_vlc(&s
->vlcs
[class][index
]);
229 av_log(s
->avctx
, AV_LOG_DEBUG
, "class=%d index=%d nb_codes=%d\n",
230 class, index
, code_max
+ 1);
231 if ((ret
= build_vlc(&s
->vlcs
[class][index
], bits_table
, val_table
,
232 code_max
+ 1, 0, class > 0)) < 0)
236 ff_free_vlc(&s
->vlcs
[2][index
]);
237 if ((ret
= build_vlc(&s
->vlcs
[2][index
], bits_table
, val_table
,
238 code_max
+ 1, 0, 0)) < 0)
245 int ff_mjpeg_decode_sof(MJpegDecodeContext
*s
)
247 int len
, nb_components
, i
, width
, height
, bits
, pix_fmt_id
, ret
;
248 int h_count
[MAX_COMPONENTS
];
249 int v_count
[MAX_COMPONENTS
];
252 s
->upscale_h
= s
->upscale_v
= 0;
254 /* XXX: verify len field validity */
255 len
= get_bits(&s
->gb
, 16);
256 s
->avctx
->bits_per_raw_sample
=
257 bits
= get_bits(&s
->gb
, 8);
261 if (bits
== 9 && !s
->pegasus_rct
)
262 s
->rct
= 1; // FIXME ugly
264 if(s
->lossless
&& s
->avctx
->lowres
){
265 av_log(s
->avctx
, AV_LOG_ERROR
, "lowres is not possible with lossless jpeg\n");
269 height
= get_bits(&s
->gb
, 16);
270 width
= get_bits(&s
->gb
, 16);
272 if (s
->avctx
->codec_id
== AV_CODEC_ID_AMV
&& (height
&15))
273 avpriv_request_sample(s
->avctx
, "non mod 16 height AMV\n");
275 // HACK for odd_height.mov
276 if (s
->interlaced
&& s
->width
== width
&& s
->height
== height
+ 1)
279 av_log(s
->avctx
, AV_LOG_DEBUG
, "sof0: picture: %dx%d\n", width
, height
);
280 if (av_image_check_size(width
, height
, 0, s
->avctx
))
281 return AVERROR_INVALIDDATA
;
283 nb_components
= get_bits(&s
->gb
, 8);
284 if (nb_components
<= 0 ||
285 nb_components
> MAX_COMPONENTS
)
287 if (s
->interlaced
&& (s
->bottom_field
== !s
->interlace_polarity
)) {
288 if (nb_components
!= s
->nb_components
) {
289 av_log(s
->avctx
, AV_LOG_ERROR
,
290 "nb_components changing in interlaced picture\n");
291 return AVERROR_INVALIDDATA
;
294 if (s
->ls
&& !(bits
<= 8 || nb_components
== 1)) {
295 avpriv_report_missing_feature(s
->avctx
,
296 "JPEG-LS that is not <= 8 "
297 "bits/component or 16-bit gray");
298 return AVERROR_PATCHWELCOME
;
300 s
->nb_components
= nb_components
;
303 memset(h_count
, 0, sizeof(h_count
));
304 memset(v_count
, 0, sizeof(v_count
));
305 for (i
= 0; i
< nb_components
; i
++) {
307 s
->component_id
[i
] = get_bits(&s
->gb
, 8) - 1;
308 h_count
[i
] = get_bits(&s
->gb
, 4);
309 v_count
[i
] = get_bits(&s
->gb
, 4);
310 /* compute hmax and vmax (only used in interleaved case) */
311 if (h_count
[i
] > s
->h_max
)
312 s
->h_max
= h_count
[i
];
313 if (v_count
[i
] > s
->v_max
)
314 s
->v_max
= v_count
[i
];
315 s
->quant_index
[i
] = get_bits(&s
->gb
, 8);
316 if (s
->quant_index
[i
] >= 4) {
317 av_log(s
->avctx
, AV_LOG_ERROR
, "quant_index is invalid\n");
318 return AVERROR_INVALIDDATA
;
320 if (!h_count
[i
] || !v_count
[i
]) {
321 av_log(s
->avctx
, AV_LOG_ERROR
,
322 "Invalid sampling factor in component %d %d:%d\n",
323 i
, h_count
[i
], v_count
[i
]);
324 return AVERROR_INVALIDDATA
;
327 av_log(s
->avctx
, AV_LOG_DEBUG
, "component %d %d:%d id: %d quant:%d\n",
328 i
, h_count
[i
], v_count
[i
],
329 s
->component_id
[i
], s
->quant_index
[i
]);
332 if (s
->ls
&& (s
->h_max
> 1 || s
->v_max
> 1)) {
333 avpriv_report_missing_feature(s
->avctx
, "Subsampling in JPEG-LS");
334 return AVERROR_PATCHWELCOME
;
338 /* if different size, realloc/alloc picture */
339 if ( width
!= s
->width
|| height
!= s
->height
341 || memcmp(s
->h_count
, h_count
, sizeof(h_count
))
342 || memcmp(s
->v_count
, v_count
, sizeof(v_count
))) {
347 memcpy(s
->h_count
, h_count
, sizeof(h_count
));
348 memcpy(s
->v_count
, v_count
, sizeof(v_count
));
352 /* test interlaced mode */
353 if (s
->first_picture
&&
354 s
->org_height
!= 0 &&
355 s
->height
< ((s
->org_height
* 3) / 4)) {
357 s
->bottom_field
= s
->interlace_polarity
;
358 s
->picture_ptr
->interlaced_frame
= 1;
359 s
->picture_ptr
->top_field_first
= !s
->interlace_polarity
;
363 ret
= ff_set_dimensions(s
->avctx
, width
, height
);
367 s
->first_picture
= 0;
370 if (s
->got_picture
&& s
->interlaced
&& (s
->bottom_field
== !s
->interlace_polarity
)) {
371 if (s
->progressive
) {
372 avpriv_request_sample(s
->avctx
, "progressively coded interlaced picture");
373 return AVERROR_INVALIDDATA
;
376 if (s
->v_max
== 1 && s
->h_max
== 1 && s
->lossless
==1 && (nb_components
==3 || nb_components
==4))
378 else if (!s
->lossless
)
380 /* XXX: not complete test ! */
381 pix_fmt_id
= (s
->h_count
[0] << 28) | (s
->v_count
[0] << 24) |
382 (s
->h_count
[1] << 20) | (s
->v_count
[1] << 16) |
383 (s
->h_count
[2] << 12) | (s
->v_count
[2] << 8) |
384 (s
->h_count
[3] << 4) | s
->v_count
[3];
385 av_log(s
->avctx
, AV_LOG_DEBUG
, "pix fmt id %x\n", pix_fmt_id
);
386 /* NOTE we do not allocate pictures large enough for the possible
387 * padding of h/v_count being 4 */
388 if (!(pix_fmt_id
& 0xD0D0D0D0))
389 pix_fmt_id
-= (pix_fmt_id
& 0xF0F0F0F0) >> 1;
390 if (!(pix_fmt_id
& 0x0D0D0D0D))
391 pix_fmt_id
-= (pix_fmt_id
& 0x0F0F0F0F) >> 1;
393 for (i
= 0; i
< 8; i
++) {
394 int j
= 6 + (i
&1) - (i
&6);
395 int is
= (pix_fmt_id
>> (4*i
)) & 0xF;
396 int js
= (pix_fmt_id
>> (4*j
)) & 0xF;
398 if (is
== 1 && js
!= 2 && (i
< 2 || i
> 5))
399 js
= (pix_fmt_id
>> ( 8 + 4*(i
&1))) & 0xF;
400 if (is
== 1 && js
!= 2 && (i
< 2 || i
> 5))
401 js
= (pix_fmt_id
>> (16 + 4*(i
&1))) & 0xF;
403 if (is
== 1 && js
== 2) {
404 if (i
& 1) s
->upscale_h
|= 1 << (j
/2);
405 else s
->upscale_v
|= 1 << (j
/2);
409 switch (pix_fmt_id
) {
412 s
->avctx
->pix_fmt
= s
->bits
<= 9 ? AV_PIX_FMT_BGR24
: AV_PIX_FMT_BGR48
;
414 if (s
->component_id
[0] == 'Q' && s
->component_id
[1] == 'F' && s
->component_id
[2] == 'A') {
415 s
->avctx
->pix_fmt
= s
->bits
<= 8 ? AV_PIX_FMT_GBRP
: AV_PIX_FMT_GBRP16
;
417 if (s
->bits
<= 8) s
->avctx
->pix_fmt
= s
->cs_itu601
? AV_PIX_FMT_YUV444P
: AV_PIX_FMT_YUVJ444P
;
418 else s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV444P16
;
419 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
422 av_assert0(s
->nb_components
== 3);
426 s
->avctx
->pix_fmt
= s
->bits
<= 9 ? AV_PIX_FMT_ABGR
: AV_PIX_FMT_RGBA64
;
428 if (s
->adobe_transform
== 0 && s
->bits
<= 8) {
429 s
->avctx
->pix_fmt
= AV_PIX_FMT_GBRAP
;
431 s
->avctx
->pix_fmt
= s
->bits
<= 8 ? AV_PIX_FMT_YUVA444P
: AV_PIX_FMT_YUVA444P16
;
432 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
435 av_assert0(s
->nb_components
== 4);
438 if (s
->adobe_transform
== 0 && s
->bits
<= 8) {
439 s
->avctx
->pix_fmt
= AV_PIX_FMT_GBRAP
;
442 s
->chroma_height
= s
->height
;
443 } else if (s
->adobe_transform
== 2 && s
->bits
<= 8) {
444 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUVA444P
;
447 s
->chroma_height
= s
->height
;
448 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
450 if (s
->bits
<= 8) s
->avctx
->pix_fmt
= AV_PIX_FMT_YUVA420P
;
451 else s
->avctx
->pix_fmt
= AV_PIX_FMT_YUVA420P16
;
452 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
454 av_assert0(s
->nb_components
== 4);
460 if (s
->bits
<= 8) s
->avctx
->pix_fmt
= s
->cs_itu601
? AV_PIX_FMT_YUV444P
: AV_PIX_FMT_YUVJ444P
;
463 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
464 s
->chroma_height
= s
->height
;
469 if (s
->bits
<= 8) s
->avctx
->pix_fmt
= s
->cs_itu601
? AV_PIX_FMT_YUV444P
: AV_PIX_FMT_YUVJ444P
;
472 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
473 s
->chroma_height
= (s
->height
+ 1) / 2;
485 s
->avctx
->pix_fmt
= AV_PIX_FMT_GRAY8
;
487 s
->avctx
->pix_fmt
= AV_PIX_FMT_GRAY16
;
493 if (s
->bits
<= 8) s
->avctx
->pix_fmt
= s
->cs_itu601
? AV_PIX_FMT_YUV440P
: AV_PIX_FMT_YUVJ440P
;
496 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
497 s
->chroma_height
= (s
->height
+ 1) / 2;
500 if (s
->bits
<= 8) s
->avctx
->pix_fmt
= s
->cs_itu601
? AV_PIX_FMT_YUV422P
: AV_PIX_FMT_YUVJ422P
;
501 else s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV422P16
;
502 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
506 if (s
->bits
<= 8) s
->avctx
->pix_fmt
= s
->cs_itu601
? AV_PIX_FMT_YUV422P
: AV_PIX_FMT_YUVJ422P
;
509 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
513 if (s
->bits
<= 8) s
->avctx
->pix_fmt
= s
->cs_itu601
? AV_PIX_FMT_YUV420P
: AV_PIX_FMT_YUVJ420P
;
514 else s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV420P16
;
515 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
516 if (pix_fmt_id
== 0x42111100) {
518 s
->chroma_height
= (s
->height
+ 1) / 2;
522 if (s
->bits
<= 8) s
->avctx
->pix_fmt
= s
->cs_itu601
? AV_PIX_FMT_YUV411P
: AV_PIX_FMT_YUVJ411P
;
525 s
->avctx
->color_range
= s
->cs_itu601
? AVCOL_RANGE_MPEG
: AVCOL_RANGE_JPEG
;
529 av_log(s
->avctx
, AV_LOG_ERROR
, "Unhandled pixel format 0x%x\n", pix_fmt_id
);
530 s
->upscale_h
= s
->upscale_v
= 0;
531 return AVERROR_PATCHWELCOME
;
533 if ((s
->upscale_h
|| s
->upscale_v
) && s
->avctx
->lowres
) {
534 av_log(s
->avctx
, AV_LOG_ERROR
, "lowres not supported for weird subsampling\n");
535 return AVERROR_PATCHWELCOME
;
538 s
->upscale_h
= s
->upscale_v
= 0;
539 if (s
->nb_components
> 1)
540 s
->avctx
->pix_fmt
= AV_PIX_FMT_RGB24
;
541 else if (s
->palette_index
&& s
->bits
<= 8)
542 s
->avctx
->pix_fmt
= AV_PIX_FMT_PAL8
;
543 else if (s
->bits
<= 8)
544 s
->avctx
->pix_fmt
= AV_PIX_FMT_GRAY8
;
546 s
->avctx
->pix_fmt
= AV_PIX_FMT_GRAY16
;
549 s
->pix_desc
= av_pix_fmt_desc_get(s
->avctx
->pix_fmt
);
551 av_log(s
->avctx
, AV_LOG_ERROR
, "Could not get a pixel format descriptor.\n");
555 av_frame_unref(s
->picture_ptr
);
556 if (ff_get_buffer(s
->avctx
, s
->picture_ptr
, AV_GET_BUFFER_FLAG_REF
) < 0)
558 s
->picture_ptr
->pict_type
= AV_PICTURE_TYPE_I
;
559 s
->picture_ptr
->key_frame
= 1;
562 for (i
= 0; i
< 4; i
++)
563 s
->linesize
[i
] = s
->picture_ptr
->linesize
[i
] << s
->interlaced
;
565 av_dlog(s
->avctx
, "%d %d %d %d %d %d\n",
566 s
->width
, s
->height
, s
->linesize
[0], s
->linesize
[1],
567 s
->interlaced
, s
->avctx
->height
);
569 if (len
!= (8 + (3 * nb_components
)))
570 av_log(s
->avctx
, AV_LOG_DEBUG
, "decode_sof0: error, len(%d) mismatch\n", len
);
573 if (s
->rgb
&& !s
->lossless
&& !s
->ls
) {
574 av_log(s
->avctx
, AV_LOG_ERROR
, "Unsupported coding and pixel format combination\n");
575 return AVERROR_PATCHWELCOME
;
578 /* totally blank picture as progressive JPEG will only add details to it */
579 if (s
->progressive
) {
580 int bw
= (width
+ s
->h_max
* 8 - 1) / (s
->h_max
* 8);
581 int bh
= (height
+ s
->v_max
* 8 - 1) / (s
->v_max
* 8);
582 for (i
= 0; i
< s
->nb_components
; i
++) {
583 int size
= bw
* bh
* s
->h_count
[i
] * s
->v_count
[i
];
584 av_freep(&s
->blocks
[i
]);
585 av_freep(&s
->last_nnz
[i
]);
586 s
->blocks
[i
] = av_mallocz_array(size
, sizeof(**s
->blocks
));
587 s
->last_nnz
[i
] = av_mallocz_array(size
, sizeof(**s
->last_nnz
));
588 if (!s
->blocks
[i
] || !s
->last_nnz
[i
])
589 return AVERROR(ENOMEM
);
590 s
->block_stride
[i
] = bw
* s
->h_count
[i
];
592 memset(s
->coefs_finished
, 0, sizeof(s
->coefs_finished
));
597 static inline int mjpeg_decode_dc(MJpegDecodeContext
*s
, int dc_index
)
600 code
= get_vlc2(&s
->gb
, s
->vlcs
[0][dc_index
].table
, 9, 2);
601 if (code
< 0 || code
> 16) {
602 av_log(s
->avctx
, AV_LOG_WARNING
,
603 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
604 0, dc_index
, &s
->vlcs
[0][dc_index
]);
609 return get_xbits(&s
->gb
, code
);
614 /* decode block and dequantize */
615 static int decode_block(MJpegDecodeContext
*s
, int16_t *block
, int component
,
616 int dc_index
, int ac_index
, int16_t *quant_matrix
)
618 int code
, i
, j
, level
, val
;
621 val
= mjpeg_decode_dc(s
, dc_index
);
622 if (val
== 0xfffff) {
623 av_log(s
->avctx
, AV_LOG_ERROR
, "error dc\n");
624 return AVERROR_INVALIDDATA
;
626 val
= val
* quant_matrix
[0] + s
->last_dc
[component
];
627 s
->last_dc
[component
] = val
;
631 {OPEN_READER(re
, &s
->gb
);
633 UPDATE_CACHE(re
, &s
->gb
);
634 GET_VLC(code
, re
, &s
->gb
, s
->vlcs
[1][ac_index
].table
, 9, 2);
636 i
+= ((unsigned)code
) >> 4;
639 if (code
> MIN_CACHE_BITS
- 16)
640 UPDATE_CACHE(re
, &s
->gb
);
643 int cache
= GET_CACHE(re
, &s
->gb
);
644 int sign
= (~cache
) >> 31;
645 level
= (NEG_USR32(sign
^ cache
,code
) ^ sign
) - sign
;
648 LAST_SKIP_BITS(re
, &s
->gb
, code
);
651 av_log(s
->avctx
, AV_LOG_ERROR
, "error count: %d\n", i
);
652 return AVERROR_INVALIDDATA
;
654 j
= s
->scantable
.permutated
[i
];
655 block
[j
] = level
* quant_matrix
[j
];
658 CLOSE_READER(re
, &s
->gb
);}
663 static int decode_dc_progressive(MJpegDecodeContext
*s
, int16_t *block
,
664 int component
, int dc_index
,
665 int16_t *quant_matrix
, int Al
)
668 s
->bdsp
.clear_block(block
);
669 val
= mjpeg_decode_dc(s
, dc_index
);
670 if (val
== 0xfffff) {
671 av_log(s
->avctx
, AV_LOG_ERROR
, "error dc\n");
672 return AVERROR_INVALIDDATA
;
674 val
= (val
* quant_matrix
[0] << Al
) + s
->last_dc
[component
];
675 s
->last_dc
[component
] = val
;
680 /* decode block and dequantize - progressive JPEG version */
681 static int decode_block_progressive(MJpegDecodeContext
*s
, int16_t *block
,
682 uint8_t *last_nnz
, int ac_index
,
683 int16_t *quant_matrix
,
684 int ss
, int se
, int Al
, int *EOBRUN
)
686 int code
, i
, j
, level
, val
, run
;
694 OPEN_READER(re
, &s
->gb
);
695 for (i
= ss
; ; i
++) {
696 UPDATE_CACHE(re
, &s
->gb
);
697 GET_VLC(code
, re
, &s
->gb
, s
->vlcs
[2][ac_index
].table
, 9, 2);
699 run
= ((unsigned) code
) >> 4;
703 if (code
> MIN_CACHE_BITS
- 16)
704 UPDATE_CACHE(re
, &s
->gb
);
707 int cache
= GET_CACHE(re
, &s
->gb
);
708 int sign
= (~cache
) >> 31;
709 level
= (NEG_USR32(sign
^ cache
,code
) ^ sign
) - sign
;
712 LAST_SKIP_BITS(re
, &s
->gb
, code
);
716 j
= s
->scantable
.permutated
[se
];
717 block
[j
] = level
* quant_matrix
[j
] << Al
;
720 av_log(s
->avctx
, AV_LOG_ERROR
, "error count: %d\n", i
);
721 return AVERROR_INVALIDDATA
;
723 j
= s
->scantable
.permutated
[i
];
724 block
[j
] = level
* quant_matrix
[j
] << Al
;
726 if (run
== 0xF) {// ZRL - skip 15 coefficients
729 av_log(s
->avctx
, AV_LOG_ERROR
, "ZRL overflow: %d\n", i
);
730 return AVERROR_INVALIDDATA
;
735 UPDATE_CACHE(re
, &s
->gb
);
736 val
+= NEG_USR32(GET_CACHE(re
, &s
->gb
), run
);
737 LAST_SKIP_BITS(re
, &s
->gb
, run
);
744 CLOSE_READER(re
, &s
->gb
);
753 #define REFINE_BIT(j) { \
754 UPDATE_CACHE(re, &s->gb); \
755 sign = block[j] >> 15; \
756 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
757 ((quant_matrix[j] ^ sign) - sign) << Al; \
758 LAST_SKIP_BITS(re, &s->gb, 1); \
766 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
771 j = s->scantable.permutated[i]; \
774 else if (run-- == 0) \
778 /* decode block and dequantize - progressive JPEG refinement pass */
779 static int decode_block_refinement(MJpegDecodeContext
*s
, int16_t *block
,
781 int ac_index
, int16_t *quant_matrix
,
782 int ss
, int se
, int Al
, int *EOBRUN
)
784 int code
, i
= ss
, j
, sign
, val
, run
;
785 int last
= FFMIN(se
, *last_nnz
);
787 OPEN_READER(re
, &s
->gb
);
792 UPDATE_CACHE(re
, &s
->gb
);
793 GET_VLC(code
, re
, &s
->gb
, s
->vlcs
[2][ac_index
].table
, 9, 2);
796 run
= ((unsigned) code
) >> 4;
797 UPDATE_CACHE(re
, &s
->gb
);
798 val
= SHOW_UBITS(re
, &s
->gb
, 1);
799 LAST_SKIP_BITS(re
, &s
->gb
, 1);
801 j
= s
->scantable
.permutated
[i
];
803 block
[j
] = ((quant_matrix
[j
]^val
) - val
) << Al
;
807 CLOSE_READER(re
, &s
->gb
);
811 run
= ((unsigned) code
) >> 4;
818 UPDATE_CACHE(re
, &s
->gb
);
819 run
+= SHOW_UBITS(re
, &s
->gb
, val
);
820 LAST_SKIP_BITS(re
, &s
->gb
, val
);
832 for (; i
<= last
; i
++) {
833 j
= s
->scantable
.permutated
[i
];
837 CLOSE_READER(re
, &s
->gb
);
844 static int handle_rstn(MJpegDecodeContext
*s
, int nb_components
)
849 if (s
->restart_interval
) {
851 if(s
->restart_count
== 0 && s
->avctx
->codec_id
== AV_CODEC_ID_THP
){
852 align_get_bits(&s
->gb
);
853 for (i
= 0; i
< nb_components
; i
++) /* reset dc */
854 s
->last_dc
[i
] = (4 << s
->bits
);
857 i
= 8 + ((-get_bits_count(&s
->gb
)) & 7);
859 if (s
->restart_count
== 0) {
860 if( show_bits(&s
->gb
, i
) == (1 << i
) - 1
861 || show_bits(&s
->gb
, i
) == 0xFF) {
862 int pos
= get_bits_count(&s
->gb
);
863 align_get_bits(&s
->gb
);
864 while (get_bits_left(&s
->gb
) >= 8 && show_bits(&s
->gb
, 8) == 0xFF)
865 skip_bits(&s
->gb
, 8);
866 if (get_bits_left(&s
->gb
) >= 8 && (get_bits(&s
->gb
, 8) & 0xF8) == 0xD0) {
867 for (i
= 0; i
< nb_components
; i
++) /* reset dc */
868 s
->last_dc
[i
] = (4 << s
->bits
);
871 skip_bits_long(&s
->gb
, pos
- get_bits_count(&s
->gb
));
878 static int ljpeg_decode_rgb_scan(MJpegDecodeContext
*s
, int nb_components
, int predictor
, int point_transform
)
881 uint16_t (*buffer
)[4];
882 int left
[4], top
[4], topleft
[4];
883 const int linesize
= s
->linesize
[0];
884 const int mask
= ((1 << s
->bits
) - 1) << point_transform
;
888 if (s
->nb_components
!= 3 && s
->nb_components
!= 4)
889 return AVERROR_INVALIDDATA
;
890 if (s
->v_max
!= 1 || s
->h_max
!= 1 || !s
->lossless
)
891 return AVERROR_INVALIDDATA
;
894 s
->restart_count
= s
->restart_interval
;
896 av_fast_malloc(&s
->ljpeg_buffer
, &s
->ljpeg_buffer_size
,
897 (unsigned)s
->mb_width
* 4 * sizeof(s
->ljpeg_buffer
[0][0]));
898 buffer
= s
->ljpeg_buffer
;
900 for (i
= 0; i
< 4; i
++)
901 buffer
[0][i
] = 1 << (s
->bits
- 1);
903 for (mb_y
= 0; mb_y
< s
->mb_height
; mb_y
++) {
904 uint8_t *ptr
= s
->picture_ptr
->data
[0] + (linesize
* mb_y
);
906 if (s
->interlaced
&& s
->bottom_field
)
907 ptr
+= linesize
>> 1;
909 for (i
= 0; i
< 4; i
++)
910 top
[i
] = left
[i
] = topleft
[i
] = buffer
[0][i
];
912 for (mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
913 int modified_predictor
= predictor
;
915 if (s
->restart_interval
&& !s
->restart_count
){
916 s
->restart_count
= s
->restart_interval
;
920 top
[i
] = left
[i
]= topleft
[i
]= 1 << (s
->bits
- 1);
922 if (mb_y
== resync_mb_y
|| mb_y
== resync_mb_y
+1 && mb_x
< resync_mb_x
|| !mb_x
)
923 modified_predictor
= 1;
925 for (i
=0;i
<nb_components
;i
++) {
929 top
[i
] = buffer
[mb_x
][i
];
931 PREDICT(pred
, topleft
[i
], top
[i
], left
[i
], modified_predictor
);
933 dc
= mjpeg_decode_dc(s
, s
->dc_index
[i
]);
937 left
[i
] = buffer
[mb_x
][i
] =
938 mask
& (pred
+ (dc
<< point_transform
));
941 if (s
->restart_interval
&& !--s
->restart_count
) {
942 align_get_bits(&s
->gb
);
943 skip_bits(&s
->gb
, 16); /* skip RSTn */
946 if (s
->nb_components
== 4) {
947 for(i
=0; i
<nb_components
; i
++) {
948 int c
= s
->comp_index
[i
];
950 for(mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
951 ptr
[4*mb_x
+3-c
] = buffer
[mb_x
][i
];
953 } else if(s
->bits
== 9) {
954 return AVERROR_PATCHWELCOME
;
956 for(mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
957 ((uint16_t*)ptr
)[4*mb_x
+c
] = buffer
[mb_x
][i
];
962 for (mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
963 ptr
[3*mb_x
+ 1] = buffer
[mb_x
][0] - ((buffer
[mb_x
][1] + buffer
[mb_x
][2] - 0x200) >> 2);
964 ptr
[3*mb_x
+ 0] = buffer
[mb_x
][1] + ptr
[3*mb_x
+ 1];
965 ptr
[3*mb_x
+ 2] = buffer
[mb_x
][2] + ptr
[3*mb_x
+ 1];
967 } else if (s
->pegasus_rct
) {
968 for (mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
969 ptr
[3*mb_x
+ 1] = buffer
[mb_x
][0] - ((buffer
[mb_x
][1] + buffer
[mb_x
][2]) >> 2);
970 ptr
[3*mb_x
+ 0] = buffer
[mb_x
][1] + ptr
[3*mb_x
+ 1];
971 ptr
[3*mb_x
+ 2] = buffer
[mb_x
][2] + ptr
[3*mb_x
+ 1];
974 for(i
=0; i
<nb_components
; i
++) {
975 int c
= s
->comp_index
[i
];
977 for(mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
978 ptr
[3*mb_x
+2-c
] = buffer
[mb_x
][i
];
980 } else if(s
->bits
== 9) {
981 return AVERROR_PATCHWELCOME
;
983 for(mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
984 ((uint16_t*)ptr
)[3*mb_x
+2-c
] = buffer
[mb_x
][i
];
993 static int ljpeg_decode_yuv_scan(MJpegDecodeContext
*s
, int predictor
,
994 int point_transform
, int nb_components
)
996 int i
, mb_x
, mb_y
, mask
;
997 int bits
= (s
->bits
+7)&~7;
1001 point_transform
+= bits
- s
->bits
;
1002 mask
= ((1 << s
->bits
) - 1) << point_transform
;
1004 av_assert0(nb_components
>=1 && nb_components
<=4);
1006 for (mb_y
= 0; mb_y
< s
->mb_height
; mb_y
++) {
1007 for (mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
1008 if (s
->restart_interval
&& !s
->restart_count
){
1009 s
->restart_count
= s
->restart_interval
;
1014 if(!mb_x
|| mb_y
== resync_mb_y
|| mb_y
== resync_mb_y
+1 && mb_x
< resync_mb_x
|| s
->interlaced
){
1015 int toprow
= mb_y
== resync_mb_y
|| mb_y
== resync_mb_y
+1 && mb_x
< resync_mb_x
;
1016 int leftcol
= !mb_x
|| mb_y
== resync_mb_y
&& mb_x
== resync_mb_x
;
1017 for (i
= 0; i
< nb_components
; i
++) {
1020 int n
, h
, v
, x
, y
, c
, j
, linesize
;
1021 n
= s
->nb_blocks
[i
];
1022 c
= s
->comp_index
[i
];
1027 linesize
= s
->linesize
[c
];
1029 if(bits
>8) linesize
/= 2;
1031 for(j
=0; j
<n
; j
++) {
1034 dc
= mjpeg_decode_dc(s
, s
->dc_index
[i
]);
1038 ptr
= s
->picture_ptr
->data
[c
] + (linesize
* (v
* mb_y
+ y
)) + (h
* mb_x
+ x
); //FIXME optimize this crap
1040 if(x
==0 && leftcol
){
1041 pred
= 1 << (bits
- 1);
1046 if(x
==0 && leftcol
){
1047 pred
= ptr
[-linesize
];
1049 PREDICT(pred
, ptr
[-linesize
-1], ptr
[-linesize
], ptr
[-1], predictor
);
1053 if (s
->interlaced
&& s
->bottom_field
)
1054 ptr
+= linesize
>> 1;
1056 *ptr
= pred
+ (dc
<< point_transform
);
1058 ptr16
= (uint16_t*)(s
->picture_ptr
->data
[c
] + 2*(linesize
* (v
* mb_y
+ y
)) + 2*(h
* mb_x
+ x
)); //FIXME optimize this crap
1060 if(x
==0 && leftcol
){
1061 pred
= 1 << (bits
- 1);
1066 if(x
==0 && leftcol
){
1067 pred
= ptr16
[-linesize
];
1069 PREDICT(pred
, ptr16
[-linesize
-1], ptr16
[-linesize
], ptr16
[-1], predictor
);
1073 if (s
->interlaced
&& s
->bottom_field
)
1074 ptr16
+= linesize
>> 1;
1076 *ptr16
= pred
+ (dc
<< point_transform
);
1085 for (i
= 0; i
< nb_components
; i
++) {
1088 int n
, h
, v
, x
, y
, c
, j
, linesize
, dc
;
1089 n
= s
->nb_blocks
[i
];
1090 c
= s
->comp_index
[i
];
1095 linesize
= s
->linesize
[c
];
1097 if(bits
>8) linesize
/= 2;
1099 for (j
= 0; j
< n
; j
++) {
1102 dc
= mjpeg_decode_dc(s
, s
->dc_index
[i
]);
1106 ptr
= s
->picture_ptr
->data
[c
] +
1107 (linesize
* (v
* mb_y
+ y
)) +
1108 (h
* mb_x
+ x
); //FIXME optimize this crap
1109 PREDICT(pred
, ptr
[-linesize
-1], ptr
[-linesize
], ptr
[-1], predictor
);
1112 *ptr
= pred
+ (dc
<< point_transform
);
1114 ptr16
= (uint16_t*)(s
->picture_ptr
->data
[c
] + 2*(linesize
* (v
* mb_y
+ y
)) + 2*(h
* mb_x
+ x
)); //FIXME optimize this crap
1115 PREDICT(pred
, ptr16
[-linesize
-1], ptr16
[-linesize
], ptr16
[-1], predictor
);
1118 *ptr16
= pred
+ (dc
<< point_transform
);
1128 if (s
->restart_interval
&& !--s
->restart_count
) {
1129 align_get_bits(&s
->gb
);
1130 skip_bits(&s
->gb
, 16); /* skip RSTn */
1137 static av_always_inline
void mjpeg_copy_block(MJpegDecodeContext
*s
,
1138 uint8_t *dst
, const uint8_t *src
,
1139 int linesize
, int lowres
)
1142 case 0: s
->hdsp
.put_pixels_tab
[1][0](dst
, src
, linesize
, 8);
1144 case 1: copy_block4(dst
, src
, linesize
, linesize
, 4);
1146 case 2: copy_block2(dst
, src
, linesize
, linesize
, 2);
1148 case 3: *dst
= *src
;
1153 static void shift_output(MJpegDecodeContext
*s
, uint8_t *ptr
, int linesize
)
1155 int block_x
, block_y
;
1156 int size
= 8 >> s
->avctx
->lowres
;
1158 for (block_y
=0; block_y
<size
; block_y
++)
1159 for (block_x
=0; block_x
<size
; block_x
++)
1160 *(uint16_t*)(ptr
+ 2*block_x
+ block_y
*linesize
) <<= 16 - s
->bits
;
1162 for (block_y
=0; block_y
<size
; block_y
++)
1163 for (block_x
=0; block_x
<size
; block_x
++)
1164 *(ptr
+ block_x
+ block_y
*linesize
) <<= 8 - s
->bits
;
1168 static int mjpeg_decode_scan(MJpegDecodeContext
*s
, int nb_components
, int Ah
,
1169 int Al
, const uint8_t *mb_bitmask
,
1170 int mb_bitmask_size
,
1171 const AVFrame
*reference
)
1174 uint8_t *data
[MAX_COMPONENTS
];
1175 const uint8_t *reference_data
[MAX_COMPONENTS
];
1176 int linesize
[MAX_COMPONENTS
];
1177 GetBitContext mb_bitmask_gb
= {0}; // initialize to silence gcc warning
1178 int bytes_per_pixel
= 1 + (s
->bits
> 8);
1181 if (mb_bitmask_size
!= (s
->mb_width
* s
->mb_height
+ 7)>>3) {
1182 av_log(s
->avctx
, AV_LOG_ERROR
, "mb_bitmask_size mismatches\n");
1183 return AVERROR_INVALIDDATA
;
1185 init_get_bits(&mb_bitmask_gb
, mb_bitmask
, s
->mb_width
* s
->mb_height
);
1188 s
->restart_count
= 0;
1190 for (i
= 0; i
< nb_components
; i
++) {
1191 int c
= s
->comp_index
[i
];
1192 data
[c
] = s
->picture_ptr
->data
[c
];
1193 reference_data
[c
] = reference
? reference
->data
[c
] : NULL
;
1194 linesize
[c
] = s
->linesize
[c
];
1195 s
->coefs_finished
[c
] |= 1;
1198 for (mb_y
= 0; mb_y
< s
->mb_height
; mb_y
++) {
1199 for (mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++) {
1200 const int copy_mb
= mb_bitmask
&& !get_bits1(&mb_bitmask_gb
);
1202 if (s
->restart_interval
&& !s
->restart_count
)
1203 s
->restart_count
= s
->restart_interval
;
1205 if (get_bits_left(&s
->gb
) < 0) {
1206 av_log(s
->avctx
, AV_LOG_ERROR
, "overread %d\n",
1207 -get_bits_left(&s
->gb
));
1208 return AVERROR_INVALIDDATA
;
1210 for (i
= 0; i
< nb_components
; i
++) {
1212 int n
, h
, v
, x
, y
, c
, j
;
1214 n
= s
->nb_blocks
[i
];
1215 c
= s
->comp_index
[i
];
1220 for (j
= 0; j
< n
; j
++) {
1221 block_offset
= (((linesize
[c
] * (v
* mb_y
+ y
) * 8) +
1222 (h
* mb_x
+ x
) * 8 * bytes_per_pixel
) >> s
->avctx
->lowres
);
1224 if (s
->interlaced
&& s
->bottom_field
)
1225 block_offset
+= linesize
[c
] >> 1;
1226 ptr
= data
[c
] + block_offset
;
1227 if (!s
->progressive
) {
1229 mjpeg_copy_block(s
, ptr
, reference_data
[c
] + block_offset
,
1230 linesize
[c
], s
->avctx
->lowres
);
1233 s
->bdsp
.clear_block(s
->block
);
1234 if (decode_block(s
, s
->block
, i
,
1235 s
->dc_index
[i
], s
->ac_index
[i
],
1236 s
->quant_matrixes
[s
->quant_sindex
[i
]]) < 0) {
1237 av_log(s
->avctx
, AV_LOG_ERROR
,
1238 "error y=%d x=%d\n", mb_y
, mb_x
);
1239 return AVERROR_INVALIDDATA
;
1241 s
->idsp
.idct_put(ptr
, linesize
[c
], s
->block
);
1243 shift_output(s
, ptr
, linesize
[c
]);
1246 int block_idx
= s
->block_stride
[c
] * (v
* mb_y
+ y
) +
1248 int16_t *block
= s
->blocks
[c
][block_idx
];
1250 block
[0] += get_bits1(&s
->gb
) *
1251 s
->quant_matrixes
[s
->quant_sindex
[i
]][0] << Al
;
1252 else if (decode_dc_progressive(s
, block
, i
, s
->dc_index
[i
],
1253 s
->quant_matrixes
[s
->quant_sindex
[i
]],
1255 av_log(s
->avctx
, AV_LOG_ERROR
,
1256 "error y=%d x=%d\n", mb_y
, mb_x
);
1257 return AVERROR_INVALIDDATA
;
1260 av_dlog(s
->avctx
, "mb: %d %d processed\n", mb_y
, mb_x
);
1261 av_dlog(s
->avctx
, "%d %d %d %d %d %d %d %d \n",
1262 mb_x
, mb_y
, x
, y
, c
, s
->bottom_field
,
1263 (v
* mb_y
+ y
) * 8, (h
* mb_x
+ x
) * 8);
1271 handle_rstn(s
, nb_components
);
1277 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext
*s
, int ss
,
1278 int se
, int Ah
, int Al
)
1282 int c
= s
->comp_index
[0];
1283 uint8_t *data
= s
->picture_ptr
->data
[c
];
1284 int linesize
= s
->linesize
[c
];
1286 int16_t *quant_matrix
= s
->quant_matrixes
[s
->quant_sindex
[0]];
1287 int bytes_per_pixel
= 1 + (s
->bits
> 8);
1289 av_assert0(ss
>=0 && Ah
>=0 && Al
>=0);
1290 if (se
< ss
|| se
> 63) {
1291 av_log(s
->avctx
, AV_LOG_ERROR
, "SS/SE %d/%d is invalid\n", ss
, se
);
1292 return AVERROR_INVALIDDATA
;
1296 s
->coefs_finished
[c
] |= (2ULL << se
) - (1ULL << ss
);
1297 last_scan
= !~s
->coefs_finished
[c
];
1300 if (s
->interlaced
&& s
->bottom_field
)
1301 data
+= linesize
>> 1;
1303 s
->restart_count
= 0;
1305 for (mb_y
= 0; mb_y
< s
->mb_height
; mb_y
++) {
1306 uint8_t *ptr
= data
+ (mb_y
* linesize
* 8 >> s
->avctx
->lowres
);
1307 int block_idx
= mb_y
* s
->block_stride
[c
];
1308 int16_t (*block
)[64] = &s
->blocks
[c
][block_idx
];
1309 uint8_t *last_nnz
= &s
->last_nnz
[c
][block_idx
];
1310 for (mb_x
= 0; mb_x
< s
->mb_width
; mb_x
++, block
++, last_nnz
++) {
1312 if (s
->restart_interval
&& !s
->restart_count
)
1313 s
->restart_count
= s
->restart_interval
;
1316 ret
= decode_block_refinement(s
, *block
, last_nnz
, s
->ac_index
[0],
1317 quant_matrix
, ss
, se
, Al
, &EOBRUN
);
1319 ret
= decode_block_progressive(s
, *block
, last_nnz
, s
->ac_index
[0],
1320 quant_matrix
, ss
, se
, Al
, &EOBRUN
);
1322 av_log(s
->avctx
, AV_LOG_ERROR
,
1323 "error y=%d x=%d\n", mb_y
, mb_x
);
1324 return AVERROR_INVALIDDATA
;
1328 s
->idsp
.idct_put(ptr
, linesize
, *block
);
1330 shift_output(s
, ptr
, linesize
);
1331 ptr
+= bytes_per_pixel
*8 >> s
->avctx
->lowres
;
1333 if (handle_rstn(s
, 0))
1340 int ff_mjpeg_decode_sos(MJpegDecodeContext
*s
, const uint8_t *mb_bitmask
,
1341 int mb_bitmask_size
, const AVFrame
*reference
)
1343 int len
, nb_components
, i
, h
, v
, predictor
, point_transform
;
1345 const int block_size
= s
->lossless
? 1 : 8;
1346 int ilv
, prev_shift
;
1348 if (!s
->got_picture
) {
1349 av_log(s
->avctx
, AV_LOG_WARNING
,
1350 "Can not process SOS before SOF, skipping\n");
1354 av_assert0(s
->picture_ptr
->data
[0]);
1355 /* XXX: verify len field validity */
1356 len
= get_bits(&s
->gb
, 16);
1357 nb_components
= get_bits(&s
->gb
, 8);
1358 if (nb_components
== 0 || nb_components
> MAX_COMPONENTS
) {
1359 av_log(s
->avctx
, AV_LOG_ERROR
,
1360 "decode_sos: nb_components (%d) unsupported\n", nb_components
);
1361 return AVERROR_PATCHWELCOME
;
1363 if (len
!= 6 + 2 * nb_components
) {
1364 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_sos: invalid len (%d)\n", len
);
1365 return AVERROR_INVALIDDATA
;
1367 for (i
= 0; i
< nb_components
; i
++) {
1368 id
= get_bits(&s
->gb
, 8) - 1;
1369 av_log(s
->avctx
, AV_LOG_DEBUG
, "component: %d\n", id
);
1370 /* find component index */
1371 for (index
= 0; index
< s
->nb_components
; index
++)
1372 if (id
== s
->component_id
[index
])
1374 if (index
== s
->nb_components
) {
1375 av_log(s
->avctx
, AV_LOG_ERROR
,
1376 "decode_sos: index(%d) out of components\n", index
);
1377 return AVERROR_INVALIDDATA
;
1379 /* Metasoft MJPEG codec has Cb and Cr swapped */
1380 if (s
->avctx
->codec_tag
== MKTAG('M', 'T', 'S', 'J')
1381 && nb_components
== 3 && s
->nb_components
== 3 && i
)
1384 s
->quant_sindex
[i
] = s
->quant_index
[index
];
1385 s
->nb_blocks
[i
] = s
->h_count
[index
] * s
->v_count
[index
];
1386 s
->h_scount
[i
] = s
->h_count
[index
];
1387 s
->v_scount
[i
] = s
->v_count
[index
];
1389 if(nb_components
== 3 && s
->nb_components
== 3 && s
->avctx
->pix_fmt
== AV_PIX_FMT_GBR24P
)
1391 if(nb_components
== 1 && s
->nb_components
== 3 && s
->avctx
->pix_fmt
== AV_PIX_FMT_GBR24P
)
1392 index
= (index
+2)%3;
1394 s
->comp_index
[i
] = index
;
1396 s
->dc_index
[i
] = get_bits(&s
->gb
, 4);
1397 s
->ac_index
[i
] = get_bits(&s
->gb
, 4);
1399 if (s
->dc_index
[i
] < 0 || s
->ac_index
[i
] < 0 ||
1400 s
->dc_index
[i
] >= 4 || s
->ac_index
[i
] >= 4)
1402 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
))
1406 predictor
= get_bits(&s
->gb
, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1407 ilv
= get_bits(&s
->gb
, 8); /* JPEG Se / JPEG-LS ILV */
1408 if(s
->avctx
->codec_tag
!= AV_RL32("CJPG")){
1409 prev_shift
= get_bits(&s
->gb
, 4); /* Ah */
1410 point_transform
= get_bits(&s
->gb
, 4); /* Al */
1412 prev_shift
= point_transform
= 0;
1414 if (nb_components
> 1) {
1415 /* interleaved stream */
1416 s
->mb_width
= (s
->width
+ s
->h_max
* block_size
- 1) / (s
->h_max
* block_size
);
1417 s
->mb_height
= (s
->height
+ s
->v_max
* block_size
- 1) / (s
->v_max
* block_size
);
1418 } else if (!s
->ls
) { /* skip this for JPEG-LS */
1419 h
= s
->h_max
/ s
->h_scount
[0];
1420 v
= s
->v_max
/ s
->v_scount
[0];
1421 s
->mb_width
= (s
->width
+ h
* block_size
- 1) / (h
* block_size
);
1422 s
->mb_height
= (s
->height
+ v
* block_size
- 1) / (v
* block_size
);
1423 s
->nb_blocks
[0] = 1;
1428 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1429 av_log(s
->avctx
, AV_LOG_DEBUG
, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1430 s
->lossless
? "lossless" : "sequential DCT", s
->rgb
? "RGB" : "",
1431 predictor
, point_transform
, ilv
, s
->bits
, s
->mjpb_skiptosod
,
1432 s
->pegasus_rct
? "PRCT" : (s
->rct
? "RCT" : ""), nb_components
);
1435 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1436 for (i
= s
->mjpb_skiptosod
; i
> 0; i
--)
1437 skip_bits(&s
->gb
, 8);
1440 for (i
= 0; i
< nb_components
; i
++)
1441 s
->last_dc
[i
] = (4 << s
->bits
);
1444 av_assert0(s
->picture_ptr
== s
->picture
);
1445 if (CONFIG_JPEGLS_DECODER
&& s
->ls
) {
1447 // reset_ls_coding_parameters(s, 0);
1449 if ((ret
= ff_jpegls_decode_picture(s
, predictor
,
1450 point_transform
, ilv
)) < 0)
1454 if ((ret
= ljpeg_decode_rgb_scan(s
, nb_components
, predictor
, point_transform
)) < 0)
1457 if ((ret
= ljpeg_decode_yuv_scan(s
, predictor
,
1459 nb_components
)) < 0)
1464 if (s
->progressive
&& predictor
) {
1465 av_assert0(s
->picture_ptr
== s
->picture
);
1466 if ((ret
= mjpeg_decode_scan_progressive_ac(s
, predictor
,
1468 point_transform
)) < 0)
1471 if ((ret
= mjpeg_decode_scan(s
, nb_components
,
1472 prev_shift
, point_transform
,
1473 mb_bitmask
, mb_bitmask_size
, reference
)) < 0)
1478 if (s
->interlaced
&&
1479 get_bits_left(&s
->gb
) > 32 &&
1480 show_bits(&s
->gb
, 8) == 0xFF) {
1481 GetBitContext bak
= s
->gb
;
1482 align_get_bits(&bak
);
1483 if (show_bits(&bak
, 16) == 0xFFD1) {
1484 av_log(s
->avctx
, AV_LOG_DEBUG
, "AVRn interlaced picture marker found\n");
1486 skip_bits(&s
->gb
, 16);
1487 s
->bottom_field
^= 1;
1496 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_sos: ac/dc index out of range\n");
1497 return AVERROR_INVALIDDATA
;
1500 static int mjpeg_decode_dri(MJpegDecodeContext
*s
)
1502 if (get_bits(&s
->gb
, 16) != 4)
1503 return AVERROR_INVALIDDATA
;
1504 s
->restart_interval
= get_bits(&s
->gb
, 16);
1505 s
->restart_count
= 0;
1506 av_log(s
->avctx
, AV_LOG_DEBUG
, "restart interval: %d\n",
1507 s
->restart_interval
);
1512 static int mjpeg_decode_app(MJpegDecodeContext
*s
)
1516 len
= get_bits(&s
->gb
, 16);
1518 return AVERROR_INVALIDDATA
;
1519 if (8 * len
> get_bits_left(&s
->gb
))
1520 return AVERROR_INVALIDDATA
;
1522 id
= get_bits_long(&s
->gb
, 32);
1525 if (s
->avctx
->debug
& FF_DEBUG_STARTCODE
) {
1527 av_get_codec_tag_string(id_str
, sizeof(id_str
), av_bswap32(id
));
1528 av_log(s
->avctx
, AV_LOG_DEBUG
, "APPx (%s / %8X) len=%d\n", id_str
, id
, len
);
1531 /* Buggy AVID, it puts EOI only at every 10th frame. */
1532 /* Also, this fourcc is used by non-avid files too, it holds some
1533 information, but it's always present in AVID-created files. */
1534 if (id
== AV_RB32("AVI1")) {
1540 4bytes field_size_less_padding
1543 i
= get_bits(&s
->gb
, 8); len
--;
1544 av_log(s
->avctx
, AV_LOG_DEBUG
, "polarity %d\n", i
);
1546 skip_bits(&s
->gb
, 8);
1547 skip_bits(&s
->gb
, 32);
1548 skip_bits(&s
->gb
, 32);
1556 if (id
== AV_RB32("JFIF")) {
1557 int t_w
, t_h
, v1
, v2
;
1558 skip_bits(&s
->gb
, 8); /* the trailing zero-byte */
1559 v1
= get_bits(&s
->gb
, 8);
1560 v2
= get_bits(&s
->gb
, 8);
1561 skip_bits(&s
->gb
, 8);
1563 s
->avctx
->sample_aspect_ratio
.num
= get_bits(&s
->gb
, 16);
1564 s
->avctx
->sample_aspect_ratio
.den
= get_bits(&s
->gb
, 16);
1565 ff_set_sar(s
->avctx
, s
->avctx
->sample_aspect_ratio
);
1567 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1568 av_log(s
->avctx
, AV_LOG_INFO
,
1569 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1571 s
->avctx
->sample_aspect_ratio
.num
,
1572 s
->avctx
->sample_aspect_ratio
.den
);
1574 t_w
= get_bits(&s
->gb
, 8);
1575 t_h
= get_bits(&s
->gb
, 8);
1577 /* skip thumbnail */
1578 if (len
-10 - (t_w
* t_h
* 3) > 0)
1579 len
-= t_w
* t_h
* 3;
1585 if (id
== AV_RB32("Adob") && (get_bits(&s
->gb
, 8) == 'e')) {
1586 skip_bits(&s
->gb
, 16); /* version */
1587 skip_bits(&s
->gb
, 16); /* flags0 */
1588 skip_bits(&s
->gb
, 16); /* flags1 */
1589 s
->adobe_transform
= get_bits(&s
->gb
, 8);
1590 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1591 av_log(s
->avctx
, AV_LOG_INFO
, "mjpeg: Adobe header found, transform=%d\n", s
->adobe_transform
);
1596 if (id
== AV_RB32("LJIF")) {
1597 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1598 av_log(s
->avctx
, AV_LOG_INFO
,
1599 "Pegasus lossless jpeg header found\n");
1600 skip_bits(&s
->gb
, 16); /* version ? */
1601 skip_bits(&s
->gb
, 16); /* unknown always 0? */
1602 skip_bits(&s
->gb
, 16); /* unknown always 0? */
1603 skip_bits(&s
->gb
, 16); /* unknown always 0? */
1604 switch (i
=get_bits(&s
->gb
, 8)) {
1614 av_log(s
->avctx
, AV_LOG_ERROR
, "unknown colorspace %d\n", i
);
1619 if (id
== AV_RL32("colr") && len
> 0) {
1620 s
->colr
= get_bits(&s
->gb
, 8);
1621 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1622 av_log(s
->avctx
, AV_LOG_INFO
, "COLR %d\n", s
->colr
);
1626 if (id
== AV_RL32("xfrm") && len
> 0) {
1627 s
->xfrm
= get_bits(&s
->gb
, 8);
1628 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1629 av_log(s
->avctx
, AV_LOG_INFO
, "XFRM %d\n", s
->xfrm
);
1634 /* JPS extension by VRex */
1635 if (s
->start_code
== APP3
&& id
== AV_RB32("_JPS") && len
>= 10) {
1636 int flags
, layout
, type
;
1637 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1638 av_log(s
->avctx
, AV_LOG_INFO
, "_JPSJPS_\n");
1640 skip_bits(&s
->gb
, 32); len
-= 4; /* JPS_ */
1641 skip_bits(&s
->gb
, 16); len
-= 2; /* block length */
1642 skip_bits(&s
->gb
, 8); /* reserved */
1643 flags
= get_bits(&s
->gb
, 8);
1644 layout
= get_bits(&s
->gb
, 8);
1645 type
= get_bits(&s
->gb
, 8);
1648 s
->stereo3d
= av_stereo3d_alloc();
1653 s
->stereo3d
->type
= AV_STEREO3D_2D
;
1654 } else if (type
== 1) {
1657 s
->stereo3d
->type
= AV_STEREO3D_LINES
;
1660 s
->stereo3d
->type
= AV_STEREO3D_SIDEBYSIDE
;
1663 s
->stereo3d
->type
= AV_STEREO3D_TOPBOTTOM
;
1666 if (!(flags
& 0x04)) {
1667 s
->stereo3d
->flags
= AV_STEREO3D_FLAG_INVERT
;
1674 if (s
->start_code
== APP1
&& id
== AV_RB32("Exif") && len
>= 2) {
1675 GetByteContext gbytes
;
1676 int ret
, le
, ifd_offset
, bytes_read
;
1677 const uint8_t *aligned
;
1679 skip_bits(&s
->gb
, 16); // skip padding
1682 // init byte wise reading
1683 aligned
= align_get_bits(&s
->gb
);
1684 bytestream2_init(&gbytes
, aligned
, len
);
1687 ret
= ff_tdecode_header(&gbytes
, &le
, &ifd_offset
);
1689 av_log(s
->avctx
, AV_LOG_ERROR
, "mjpeg: invalid TIFF header in EXIF data\n");
1691 bytestream2_seek(&gbytes
, ifd_offset
, SEEK_SET
);
1693 // read 0th IFD and store the metadata
1694 // (return values > 0 indicate the presence of subimage metadata)
1695 ret
= avpriv_exif_decode_ifd(s
->avctx
, &gbytes
, le
, 0, &s
->exif_metadata
);
1697 av_log(s
->avctx
, AV_LOG_ERROR
, "mjpeg: error decoding EXIF data\n");
1701 bytes_read
= bytestream2_tell(&gbytes
);
1702 skip_bits(&s
->gb
, bytes_read
<< 3);
1709 if ((s
->start_code
== APP1
) && (len
> (0x28 - 8))) {
1710 id
= get_bits_long(&s
->gb
, 32);
1713 if (id
== AV_RB32("mjpg")) {
1715 skip_bits(&s
->gb
, 32); /* field size */
1716 skip_bits(&s
->gb
, 32); /* pad field size */
1717 skip_bits(&s
->gb
, 32); /* next off */
1718 skip_bits(&s
->gb
, 32); /* quant off */
1719 skip_bits(&s
->gb
, 32); /* huff off */
1720 skip_bits(&s
->gb
, 32); /* image off */
1721 skip_bits(&s
->gb
, 32); /* scan off */
1722 skip_bits(&s
->gb
, 32); /* data off */
1724 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1725 av_log(s
->avctx
, AV_LOG_INFO
, "mjpeg: Apple MJPEG-A header found\n");
1730 /* slow but needed for extreme adobe jpegs */
1732 av_log(s
->avctx
, AV_LOG_ERROR
,
1733 "mjpeg: error, decode_app parser read over the end\n");
1735 skip_bits(&s
->gb
, 8);
1740 static int mjpeg_decode_com(MJpegDecodeContext
*s
)
1742 int len
= get_bits(&s
->gb
, 16);
1743 if (len
>= 2 && 8 * len
- 16 <= get_bits_left(&s
->gb
)) {
1744 char *cbuf
= av_malloc(len
- 1);
1747 for (i
= 0; i
< len
- 2; i
++)
1748 cbuf
[i
] = get_bits(&s
->gb
, 8);
1749 if (i
> 0 && cbuf
[i
- 1] == '\n')
1754 if (s
->avctx
->debug
& FF_DEBUG_PICT_INFO
)
1755 av_log(s
->avctx
, AV_LOG_INFO
, "comment: '%s'\n", cbuf
);
1757 /* buggy avid, it puts EOI only at every 10th frame */
1758 if (!strncmp(cbuf
, "AVID", 4)) {
1759 parse_avid(s
, cbuf
, len
);
1760 } else if (!strcmp(cbuf
, "CS=ITU601"))
1762 else if ((!strncmp(cbuf
, "Intel(R) JPEG Library, version 1", 32) && s
->avctx
->codec_tag
) ||
1763 (!strncmp(cbuf
, "Metasoft MJPEG Codec", 20)))
1773 /* return the 8 bit start code value and update the search
1774 state. Return -1 if no start code found */
1775 static int find_marker(const uint8_t **pbuf_ptr
, const uint8_t *buf_end
)
1777 const uint8_t *buf_ptr
;
1782 buf_ptr
= *pbuf_ptr
;
1783 while (buf_end
- buf_ptr
> 1) {
1786 if ((v
== 0xff) && (v2
>= 0xc0) && (v2
<= 0xfe) && buf_ptr
< buf_end
) {
1795 av_dlog(NULL
, "find_marker skipped %d bytes\n", skipped
);
1796 *pbuf_ptr
= buf_ptr
;
1800 int ff_mjpeg_find_marker(MJpegDecodeContext
*s
,
1801 const uint8_t **buf_ptr
, const uint8_t *buf_end
,
1802 const uint8_t **unescaped_buf_ptr
,
1803 int *unescaped_buf_size
)
1806 start_code
= find_marker(buf_ptr
, buf_end
);
1808 av_fast_padded_malloc(&s
->buffer
, &s
->buffer_size
, buf_end
- *buf_ptr
);
1810 return AVERROR(ENOMEM
);
1812 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1813 if (start_code
== SOS
&& !s
->ls
) {
1814 const uint8_t *src
= *buf_ptr
;
1815 uint8_t *dst
= s
->buffer
;
1817 while (src
< buf_end
) {
1818 uint8_t x
= *(src
++);
1821 if (s
->avctx
->codec_id
!= AV_CODEC_ID_THP
) {
1823 while (src
< buf_end
&& x
== 0xff)
1826 if (x
>= 0xd0 && x
<= 0xd7)
1833 *unescaped_buf_ptr
= s
->buffer
;
1834 *unescaped_buf_size
= dst
- s
->buffer
;
1835 memset(s
->buffer
+ *unescaped_buf_size
, 0,
1836 FF_INPUT_BUFFER_PADDING_SIZE
);
1838 av_log(s
->avctx
, AV_LOG_DEBUG
, "escaping removed %"PTRDIFF_SPECIFIER
" bytes\n",
1839 (buf_end
- *buf_ptr
) - (dst
- s
->buffer
));
1840 } else if (start_code
== SOS
&& s
->ls
) {
1841 const uint8_t *src
= *buf_ptr
;
1842 uint8_t *dst
= s
->buffer
;
1848 while (src
+ t
< buf_end
) {
1849 uint8_t x
= src
[t
++];
1851 while ((src
+ t
< buf_end
) && x
== 0xff)
1860 init_put_bits(&pb
, dst
, t
);
1862 /* unescape bitstream */
1864 uint8_t x
= src
[b
++];
1865 put_bits(&pb
, 8, x
);
1868 put_bits(&pb
, 7, x
);
1872 flush_put_bits(&pb
);
1874 *unescaped_buf_ptr
= dst
;
1875 *unescaped_buf_size
= (bit_count
+ 7) >> 3;
1876 memset(s
->buffer
+ *unescaped_buf_size
, 0,
1877 FF_INPUT_BUFFER_PADDING_SIZE
);
1879 *unescaped_buf_ptr
= *buf_ptr
;
1880 *unescaped_buf_size
= buf_end
- *buf_ptr
;
1886 int ff_mjpeg_decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
1889 AVFrame
*frame
= data
;
1890 const uint8_t *buf
= avpkt
->data
;
1891 int buf_size
= avpkt
->size
;
1892 MJpegDecodeContext
*s
= avctx
->priv_data
;
1893 const uint8_t *buf_end
, *buf_ptr
;
1894 const uint8_t *unescaped_buf_ptr
;
1896 int unescaped_buf_size
;
1902 av_dict_free(&s
->exif_metadata
);
1903 av_freep(&s
->stereo3d
);
1904 s
->adobe_transform
= -1;
1907 buf_end
= buf
+ buf_size
;
1908 while (buf_ptr
< buf_end
) {
1909 /* find start next marker */
1910 start_code
= ff_mjpeg_find_marker(s
, &buf_ptr
, buf_end
,
1912 &unescaped_buf_size
);
1914 if (start_code
< 0) {
1916 } else if (unescaped_buf_size
> INT_MAX
/ 8) {
1917 av_log(avctx
, AV_LOG_ERROR
,
1918 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
1919 start_code
, unescaped_buf_size
, buf_size
);
1920 return AVERROR_INVALIDDATA
;
1922 av_log(avctx
, AV_LOG_DEBUG
, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER
"\n",
1923 start_code
, buf_end
- buf_ptr
);
1925 ret
= init_get_bits8(&s
->gb
, unescaped_buf_ptr
, unescaped_buf_size
);
1928 av_log(avctx
, AV_LOG_ERROR
, "invalid buffer\n");
1932 s
->start_code
= start_code
;
1933 if (s
->avctx
->debug
& FF_DEBUG_STARTCODE
)
1934 av_log(avctx
, AV_LOG_DEBUG
, "startcode: %X\n", start_code
);
1936 /* process markers */
1937 if (start_code
>= 0xd0 && start_code
<= 0xd7)
1938 av_log(avctx
, AV_LOG_DEBUG
,
1939 "restart marker: %d\n", start_code
& 0x0f);
1941 else if (start_code
>= APP0
&& start_code
<= APP15
)
1942 mjpeg_decode_app(s
);
1944 else if (start_code
== COM
)
1945 mjpeg_decode_com(s
);
1949 if (!CONFIG_JPEGLS_DECODER
&&
1950 (start_code
== SOF48
|| start_code
== LSE
)) {
1951 av_log(avctx
, AV_LOG_ERROR
, "JPEG-LS support not enabled.\n");
1952 return AVERROR(ENOSYS
);
1955 switch (start_code
) {
1957 s
->restart_interval
= 0;
1958 s
->restart_count
= 0;
1959 /* nothing to do on SOI */
1962 ff_mjpeg_decode_dqt(s
);
1965 if ((ret
= ff_mjpeg_decode_dht(s
)) < 0) {
1966 av_log(avctx
, AV_LOG_ERROR
, "huffman table decode error\n");
1975 if ((ret
= ff_mjpeg_decode_sof(s
)) < 0)
1982 if ((ret
= ff_mjpeg_decode_sof(s
)) < 0)
1989 if ((ret
= ff_mjpeg_decode_sof(s
)) < 0)
1996 if ((ret
= ff_mjpeg_decode_sof(s
)) < 0)
2000 if (!CONFIG_JPEGLS_DECODER
||
2001 (ret
= ff_jpegls_decode_lse(s
)) < 0)
2007 if (!s
->got_picture
) {
2008 av_log(avctx
, AV_LOG_WARNING
,
2009 "Found EOI before any SOF, ignoring\n");
2012 if (s
->interlaced
) {
2013 s
->bottom_field
^= 1;
2014 /* if not bottom field, do not output image yet */
2015 if (s
->bottom_field
== !s
->interlace_polarity
)
2018 if ((ret
= av_frame_ref(frame
, s
->picture_ptr
)) < 0)
2024 int qp
= FFMAX3(s
->qscale
[0],
2027 int qpw
= (s
->width
+ 15) / 16;
2028 AVBufferRef
*qp_table_buf
= av_buffer_alloc(qpw
);
2030 memset(qp_table_buf
->data
, qp
, qpw
);
2031 av_frame_set_qp_table(data
, qp_table_buf
, 0, FF_QSCALE_TYPE_MPEG1
);
2034 if(avctx
->debug
& FF_DEBUG_QP
)
2035 av_log(avctx
, AV_LOG_DEBUG
, "QP: %d\n", qp
);
2041 if ((ret
= ff_mjpeg_decode_sos(s
, NULL
, 0, NULL
)) < 0 &&
2042 (avctx
->err_recognition
& AV_EF_EXPLODE
))
2046 mjpeg_decode_dri(s
);
2058 av_log(avctx
, AV_LOG_ERROR
,
2059 "mjpeg: unsupported coding type (%x)\n", start_code
);
2063 /* eof process start code */
2064 buf_ptr
+= (get_bits_count(&s
->gb
) + 7) / 8;
2065 av_log(avctx
, AV_LOG_DEBUG
,
2066 "marker parser used %d bytes (%d bits)\n",
2067 (get_bits_count(&s
->gb
) + 7) / 8, get_bits_count(&s
->gb
));
2069 if (s
->got_picture
&& s
->cur_scan
) {
2070 av_log(avctx
, AV_LOG_WARNING
, "EOI missing, emulating\n");
2073 av_log(avctx
, AV_LOG_FATAL
, "No JPEG data found in image\n");
2074 return AVERROR_INVALIDDATA
;
2080 is16bit
= av_pix_fmt_desc_get(s
->avctx
->pix_fmt
)->comp
[0].step_minus1
;
2084 av_assert0(avctx
->pix_fmt
== AV_PIX_FMT_YUVJ444P
||
2085 avctx
->pix_fmt
== AV_PIX_FMT_YUV444P
||
2086 avctx
->pix_fmt
== AV_PIX_FMT_YUVJ440P
||
2087 avctx
->pix_fmt
== AV_PIX_FMT_YUV440P
||
2088 avctx
->pix_fmt
== AV_PIX_FMT_YUVA444P
||
2089 avctx
->pix_fmt
== AV_PIX_FMT_YUVJ420P
||
2090 avctx
->pix_fmt
== AV_PIX_FMT_YUV420P
||
2091 avctx
->pix_fmt
== AV_PIX_FMT_YUV420P16
||
2092 avctx
->pix_fmt
== AV_PIX_FMT_GBRAP
2094 avcodec_get_chroma_sub_sample(s
->avctx
->pix_fmt
, &hshift
, &vshift
);
2095 for (p
= 0; p
<4; p
++) {
2096 uint8_t *line
= s
->picture_ptr
->data
[p
];
2098 if (!(s
->upscale_h
& (1<<p
)))
2103 for (i
= 0; i
< s
->chroma_height
; i
++) {
2104 if (is16bit
) ((uint16_t*)line
)[w
- 1] = ((uint16_t*)line
)[(w
- 1) / 2];
2105 else line
[w
- 1] = line
[(w
- 1) / 2];
2106 for (index
= w
- 2; index
> 0; index
--) {
2108 ((uint16_t*)line
)[index
] = (((uint16_t*)line
)[index
/ 2] + ((uint16_t*)line
)[(index
+ 1) / 2]) >> 1;
2110 line
[index
] = (line
[index
/ 2] + line
[(index
+ 1) / 2]) >> 1;
2112 line
+= s
->linesize
[p
];
2118 av_assert0(avctx
->pix_fmt
== AV_PIX_FMT_YUVJ444P
||
2119 avctx
->pix_fmt
== AV_PIX_FMT_YUV444P
||
2120 avctx
->pix_fmt
== AV_PIX_FMT_YUVJ422P
||
2121 avctx
->pix_fmt
== AV_PIX_FMT_YUV422P
||
2122 avctx
->pix_fmt
== AV_PIX_FMT_YUVA444P
||
2123 avctx
->pix_fmt
== AV_PIX_FMT_GBRAP
2125 avcodec_get_chroma_sub_sample(s
->avctx
->pix_fmt
, &hshift
, &vshift
);
2126 for (p
= 0; p
< 4; p
++) {
2127 uint8_t *dst
= &((uint8_t *)s
->picture_ptr
->data
[p
])[(s
->height
- 1) * s
->linesize
[p
]];
2129 if (!(s
->upscale_v
& (1<<p
)))
2132 w
= FF_CEIL_RSHIFT(w
, hshift
);
2133 for (i
= s
->height
- 1; i
; i
--) {
2134 uint8_t *src1
= &((uint8_t *)s
->picture_ptr
->data
[p
])[i
/ 2 * s
->linesize
[p
]];
2135 uint8_t *src2
= &((uint8_t *)s
->picture_ptr
->data
[p
])[(i
+ 1) / 2 * s
->linesize
[p
]];
2136 if (src1
== src2
|| i
== s
->height
- 1) {
2137 memcpy(dst
, src1
, w
);
2139 for (index
= 0; index
< w
; index
++)
2140 dst
[index
] = (src1
[index
] + src2
[index
]) >> 1;
2142 dst
-= s
->linesize
[p
];
2148 avcodec_get_chroma_sub_sample(s
->avctx
->pix_fmt
, &hshift
, &vshift
);
2149 for (index
=0; index
<4; index
++) {
2150 uint8_t *dst
= s
->picture_ptr
->data
[index
];
2151 int w
= s
->picture_ptr
->width
;
2152 int h
= s
->picture_ptr
->height
;
2153 if(index
&& index
<3){
2154 w
= FF_CEIL_RSHIFT(w
, hshift
);
2155 h
= FF_CEIL_RSHIFT(h
, vshift
);
2158 uint8_t *dst2
= dst
+ s
->picture_ptr
->linesize
[index
]*(h
-1);
2159 for (i
=0; i
<h
/2; i
++) {
2161 FFSWAP(int, dst
[j
], dst2
[j
]);
2162 dst
+= s
->picture_ptr
->linesize
[index
];
2163 dst2
-= s
->picture_ptr
->linesize
[index
];
2168 if (s
->adobe_transform
== 0 && s
->avctx
->pix_fmt
== AV_PIX_FMT_GBRAP
) {
2169 int w
= s
->picture_ptr
->width
;
2170 int h
= s
->picture_ptr
->height
;
2171 for (i
=0; i
<h
; i
++) {
2174 for (index
=0; index
<4; index
++) {
2175 dst
[index
] = s
->picture_ptr
->data
[index
]
2176 + s
->picture_ptr
->linesize
[index
]*i
;
2178 for (j
=0; j
<w
; j
++) {
2180 int r
= dst
[0][j
] * k
;
2181 int g
= dst
[1][j
] * k
;
2182 int b
= dst
[2][j
] * k
;
2183 dst
[0][j
] = g
*257 >> 16;
2184 dst
[1][j
] = b
*257 >> 16;
2185 dst
[2][j
] = r
*257 >> 16;
2190 if (s
->adobe_transform
== 2 && s
->avctx
->pix_fmt
== AV_PIX_FMT_YUVA444P
) {
2191 int w
= s
->picture_ptr
->width
;
2192 int h
= s
->picture_ptr
->height
;
2193 for (i
=0; i
<h
; i
++) {
2196 for (index
=0; index
<4; index
++) {
2197 dst
[index
] = s
->picture_ptr
->data
[index
]
2198 + s
->picture_ptr
->linesize
[index
]*i
;
2200 for (j
=0; j
<w
; j
++) {
2202 int r
= (255 - dst
[0][j
]) * k
;
2203 int g
= (128 - dst
[1][j
]) * k
;
2204 int b
= (128 - dst
[2][j
]) * k
;
2205 dst
[0][j
] = r
*257 >> 16;
2206 dst
[1][j
] = (g
*257 >> 16) + 128;
2207 dst
[2][j
] = (b
*257 >> 16) + 128;
2214 AVStereo3D
*stereo
= av_stereo3d_create_side_data(data
);
2216 stereo
->type
= s
->stereo3d
->type
;
2217 stereo
->flags
= s
->stereo3d
->flags
;
2219 av_freep(&s
->stereo3d
);
2222 av_dict_copy(avpriv_frame_get_metadatap(data
), s
->exif_metadata
, 0);
2223 av_dict_free(&s
->exif_metadata
);
2225 av_log(avctx
, AV_LOG_DEBUG
, "decode frame unused %"PTRDIFF_SPECIFIER
" bytes\n",
2227 // return buf_end - buf_ptr;
2228 return buf_ptr
- buf
;
2231 av_cold
int ff_mjpeg_decode_end(AVCodecContext
*avctx
)
2233 MJpegDecodeContext
*s
= avctx
->priv_data
;
2236 if (s
->interlaced
&& s
->bottom_field
== !s
->interlace_polarity
&& s
->got_picture
&& !avctx
->frame_number
) {
2237 av_log(avctx
, AV_LOG_INFO
, "Single field\n");
2241 av_frame_free(&s
->picture
);
2242 s
->picture_ptr
= NULL
;
2243 } else if (s
->picture_ptr
)
2244 av_frame_unref(s
->picture_ptr
);
2246 av_freep(&s
->buffer
);
2247 av_freep(&s
->stereo3d
);
2248 av_freep(&s
->ljpeg_buffer
);
2249 s
->ljpeg_buffer_size
= 0;
2251 for (i
= 0; i
< 3; i
++) {
2252 for (j
= 0; j
< 4; j
++)
2253 ff_free_vlc(&s
->vlcs
[i
][j
]);
2255 for (i
= 0; i
< MAX_COMPONENTS
; i
++) {
2256 av_freep(&s
->blocks
[i
]);
2257 av_freep(&s
->last_nnz
[i
]);
2259 av_dict_free(&s
->exif_metadata
);
2263 static void decode_flush(AVCodecContext
*avctx
)
2265 MJpegDecodeContext
*s
= avctx
->priv_data
;
2269 #if CONFIG_MJPEG_DECODER
2270 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2271 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2272 static const AVOption options
[] = {
2273 { "extern_huff", "Use external huffman table.",
2274 OFFSET(extern_huff
), AV_OPT_TYPE_INT
, { .i64
= 0 }, 0, 1, VD
},
2278 static const AVClass mjpegdec_class
= {
2279 .class_name
= "MJPEG decoder",
2280 .item_name
= av_default_item_name
,
2282 .version
= LIBAVUTIL_VERSION_INT
,
2285 AVCodec ff_mjpeg_decoder
= {
2287 .long_name
= NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2288 .type
= AVMEDIA_TYPE_VIDEO
,
2289 .id
= AV_CODEC_ID_MJPEG
,
2290 .priv_data_size
= sizeof(MJpegDecodeContext
),
2291 .init
= ff_mjpeg_decode_init
,
2292 .close
= ff_mjpeg_decode_end
,
2293 .decode
= ff_mjpeg_decode_frame
,
2294 .flush
= decode_flush
,
2295 .capabilities
= CODEC_CAP_DR1
,
2297 .priv_class
= &mjpegdec_class
,
2300 #if CONFIG_THP_DECODER
2301 AVCodec ff_thp_decoder
= {
2303 .long_name
= NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2304 .type
= AVMEDIA_TYPE_VIDEO
,
2305 .id
= AV_CODEC_ID_THP
,
2306 .priv_data_size
= sizeof(MJpegDecodeContext
),
2307 .init
= ff_mjpeg_decode_init
,
2308 .close
= ff_mjpeg_decode_end
,
2309 .decode
= ff_mjpeg_decode_frame
,
2310 .flush
= decode_flush
,
2311 .capabilities
= CODEC_CAP_DR1
,