path: root/libavcodec/mjpegdec.c (plain)
blob: 5470b661c3781c7ea023a0e0c06dab7276d6b755

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