Mercurial > libavcodec.hg
annotate mjpeg.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | f67b63ed036d |
children | e25782262d7d |
rev | line source |
---|---|
0 | 1 /* |
23 | 2 * MJPEG encoder and decoder |
427 | 3 * Copyright (c) 2000, 2001 Fabrice Bellard. |
2181 | 4 * Copyright (c) 2003 Alex Beregszaszi |
5 * Copyright (c) 2003-2004 Michael Niedermayer | |
0 | 6 * |
427 | 7 * This library is free software; you can redistribute it and/or |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2 of the License, or (at your option) any later version. | |
0 | 11 * |
427 | 12 * This library is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
427 | 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 * Lesser General Public License for more details. | |
0 | 16 * |
427 | 17 * You should have received a copy of the GNU Lesser General Public |
18 * License along with this library; if not, write to the Free Software | |
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
20 * |
672 | 21 * Support for external huffman table, various fixes (AVID workaround), |
881 | 22 * aspecting, new decode_frame mechanism and apple mjpeg-b support |
672 | 23 * by Alex Beregszaszi <alex@naxine.org> |
0 | 24 */ |
1106 | 25 |
26 /** | |
27 * @file mjpeg.c | |
28 * MJPEG encoder and decoder. | |
29 */ | |
30 | |
776 | 31 //#define DEBUG |
1307 | 32 #include <assert.h> |
33 | |
0 | 34 #include "avcodec.h" |
35 #include "dsputil.h" | |
36 #include "mpegvideo.h" | |
37 | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
38 /* use two quantizer tables (one for luminance and one for chrominance) */ |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
39 /* not yet working */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
40 #undef TWOMATRIXES |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
41 |
0 | 42 typedef struct MJpegContext { |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
43 uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing |
1064 | 44 uint16_t huff_code_dc_luminance[12]; |
45 uint8_t huff_size_dc_chrominance[12]; | |
46 uint16_t huff_code_dc_chrominance[12]; | |
0 | 47 |
1064 | 48 uint8_t huff_size_ac_luminance[256]; |
49 uint16_t huff_code_ac_luminance[256]; | |
50 uint8_t huff_size_ac_chrominance[256]; | |
51 uint16_t huff_code_ac_chrominance[256]; | |
0 | 52 } MJpegContext; |
53 | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
54 /* JPEG marker codes */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
55 typedef enum { |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
56 /* start of frame */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
57 SOF0 = 0xc0, /* baseline */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
58 SOF1 = 0xc1, /* extended sequential, huffman */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
59 SOF2 = 0xc2, /* progressive, huffman */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
60 SOF3 = 0xc3, /* lossless, huffman */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
61 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
62 SOF5 = 0xc5, /* differential sequential, huffman */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
63 SOF6 = 0xc6, /* differential progressive, huffman */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
64 SOF7 = 0xc7, /* differential lossless, huffman */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
65 JPG = 0xc8, /* reserved for JPEG extension */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
66 SOF9 = 0xc9, /* extended sequential, arithmetic */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
67 SOF10 = 0xca, /* progressive, arithmetic */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
68 SOF11 = 0xcb, /* lossless, arithmetic */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
69 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
70 SOF13 = 0xcd, /* differential sequential, arithmetic */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
71 SOF14 = 0xce, /* differential progressive, arithmetic */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
72 SOF15 = 0xcf, /* differential lossless, arithmetic */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
73 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
74 DHT = 0xc4, /* define huffman tables */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
75 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
76 DAC = 0xcc, /* define arithmetic-coding conditioning */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
77 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
78 /* restart with modulo 8 count "m" */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
79 RST0 = 0xd0, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
80 RST1 = 0xd1, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
81 RST2 = 0xd2, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
82 RST3 = 0xd3, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
83 RST4 = 0xd4, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
84 RST5 = 0xd5, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
85 RST6 = 0xd6, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
86 RST7 = 0xd7, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
87 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
88 SOI = 0xd8, /* start of image */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
89 EOI = 0xd9, /* end of image */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
90 SOS = 0xda, /* start of scan */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
91 DQT = 0xdb, /* define quantization tables */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
92 DNL = 0xdc, /* define number of lines */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
93 DRI = 0xdd, /* define restart interval */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
94 DHP = 0xde, /* define hierarchical progression */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
95 EXP = 0xdf, /* expand reference components */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
96 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
97 APP0 = 0xe0, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
98 APP1 = 0xe1, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
99 APP2 = 0xe2, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
100 APP3 = 0xe3, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
101 APP4 = 0xe4, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
102 APP5 = 0xe5, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
103 APP6 = 0xe6, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
104 APP7 = 0xe7, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
105 APP8 = 0xe8, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
106 APP9 = 0xe9, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
107 APP10 = 0xea, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
108 APP11 = 0xeb, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
109 APP12 = 0xec, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
110 APP13 = 0xed, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
111 APP14 = 0xee, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
112 APP15 = 0xef, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
113 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
114 JPG0 = 0xf0, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
115 JPG1 = 0xf1, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
116 JPG2 = 0xf2, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
117 JPG3 = 0xf3, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
118 JPG4 = 0xf4, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
119 JPG5 = 0xf5, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
120 JPG6 = 0xf6, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
121 JPG7 = 0xf7, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
122 JPG8 = 0xf8, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
123 JPG9 = 0xf9, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
124 JPG10 = 0xfa, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
125 JPG11 = 0xfb, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
126 JPG12 = 0xfc, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
127 JPG13 = 0xfd, |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
128 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
129 COM = 0xfe, /* comment */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
130 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
131 TEM = 0x01, /* temporary private use for arithmetic coding */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
132 |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
133 /* 0x02 -> 0xbf reserved */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
134 } JPEG_MARKER; |
0 | 135 |
136 #if 0 | |
137 /* These are the sample quantization tables given in JPEG spec section K.1. | |
138 * The spec says that the values given produce "good" quality, and | |
139 * when divided by 2, "very good" quality. | |
140 */ | |
141 static const unsigned char std_luminance_quant_tbl[64] = { | |
142 16, 11, 10, 16, 24, 40, 51, 61, | |
143 12, 12, 14, 19, 26, 58, 60, 55, | |
144 14, 13, 16, 24, 40, 57, 69, 56, | |
145 14, 17, 22, 29, 51, 87, 80, 62, | |
146 18, 22, 37, 56, 68, 109, 103, 77, | |
147 24, 35, 55, 64, 81, 104, 113, 92, | |
148 49, 64, 78, 87, 103, 121, 120, 101, | |
149 72, 92, 95, 98, 112, 100, 103, 99 | |
150 }; | |
151 static const unsigned char std_chrominance_quant_tbl[64] = { | |
152 17, 18, 24, 47, 99, 99, 99, 99, | |
153 18, 21, 26, 66, 99, 99, 99, 99, | |
154 24, 26, 56, 99, 99, 99, 99, 99, | |
155 47, 66, 99, 99, 99, 99, 99, 99, | |
156 99, 99, 99, 99, 99, 99, 99, 99, | |
157 99, 99, 99, 99, 99, 99, 99, 99, | |
158 99, 99, 99, 99, 99, 99, 99, 99, | |
159 99, 99, 99, 99, 99, 99, 99, 99 | |
160 }; | |
161 #endif | |
162 | |
163 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */ | |
164 /* IMPORTANT: these are only valid for 8-bit data precision! */ | |
1064 | 165 static const uint8_t bits_dc_luminance[17] = |
0 | 166 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 }; |
1064 | 167 static const uint8_t val_dc_luminance[] = |
0 | 168 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; |
169 | |
1064 | 170 static const uint8_t bits_dc_chrominance[17] = |
0 | 171 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }; |
1064 | 172 static const uint8_t val_dc_chrominance[] = |
0 | 173 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; |
174 | |
1064 | 175 static const uint8_t bits_ac_luminance[17] = |
0 | 176 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d }; |
1064 | 177 static const uint8_t val_ac_luminance[] = |
0 | 178 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, |
179 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, | |
180 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, | |
181 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, | |
182 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, | |
183 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, | |
184 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, | |
185 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, | |
186 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, | |
187 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, | |
188 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, | |
189 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, | |
190 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, | |
191 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, | |
192 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, | |
193 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, | |
194 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, | |
195 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, | |
196 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, | |
197 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, | |
198 0xf9, 0xfa | |
199 }; | |
200 | |
1064 | 201 static const uint8_t bits_ac_chrominance[17] = |
0 | 202 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 }; |
203 | |
1064 | 204 static const uint8_t val_ac_chrominance[] = |
0 | 205 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, |
206 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, | |
207 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, | |
208 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, | |
209 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, | |
210 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, | |
211 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, | |
212 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, | |
213 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, | |
214 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, | |
215 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, | |
216 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, | |
217 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, | |
218 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, | |
219 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, | |
220 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, | |
221 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, | |
222 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, | |
223 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, | |
224 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, | |
225 0xf9, 0xfa | |
226 }; | |
227 | |
228 /* isn't this function nicer than the one in the libjpeg ? */ | |
1064 | 229 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code, |
230 const uint8_t *bits_table, const uint8_t *val_table) | |
0 | 231 { |
232 int i, j, k,nb, code, sym; | |
233 | |
234 code = 0; | |
235 k = 0; | |
236 for(i=1;i<=16;i++) { | |
237 nb = bits_table[i]; | |
238 for(j=0;j<nb;j++) { | |
239 sym = val_table[k++]; | |
240 huff_size[sym] = i; | |
241 huff_code[sym] = code; | |
242 code++; | |
243 } | |
244 code <<= 1; | |
245 } | |
246 } | |
247 | |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1522
diff
changeset
|
248 #ifdef CONFIG_ENCODERS |
0 | 249 int mjpeg_init(MpegEncContext *s) |
250 { | |
251 MJpegContext *m; | |
252 | |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
375
diff
changeset
|
253 m = av_malloc(sizeof(MJpegContext)); |
0 | 254 if (!m) |
255 return -1; | |
344 | 256 |
257 s->min_qcoeff=-1023; | |
258 s->max_qcoeff= 1023; | |
0 | 259 |
260 /* build all the huffman tables */ | |
261 build_huffman_codes(m->huff_size_dc_luminance, | |
262 m->huff_code_dc_luminance, | |
263 bits_dc_luminance, | |
264 val_dc_luminance); | |
265 build_huffman_codes(m->huff_size_dc_chrominance, | |
266 m->huff_code_dc_chrominance, | |
267 bits_dc_chrominance, | |
268 val_dc_chrominance); | |
269 build_huffman_codes(m->huff_size_ac_luminance, | |
270 m->huff_code_ac_luminance, | |
271 bits_ac_luminance, | |
272 val_ac_luminance); | |
273 build_huffman_codes(m->huff_size_ac_chrominance, | |
274 m->huff_code_ac_chrominance, | |
275 bits_ac_chrominance, | |
276 val_ac_chrominance); | |
277 | |
278 s->mjpeg_ctx = m; | |
279 return 0; | |
280 } | |
281 | |
282 void mjpeg_close(MpegEncContext *s) | |
283 { | |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
375
diff
changeset
|
284 av_free(s->mjpeg_ctx); |
0 | 285 } |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1522
diff
changeset
|
286 #endif //CONFIG_ENCODERS |
0 | 287 |
1310 | 288 #define PREDICT(ret, topleft, top, left, predictor)\ |
289 switch(predictor){\ | |
290 case 1: ret= left; break;\ | |
291 case 2: ret= top; break;\ | |
292 case 3: ret= topleft; break;\ | |
293 case 4: ret= left + top - topleft; break;\ | |
294 case 5: ret= left + ((top - topleft)>>1); break;\ | |
295 case 6: ret= top + ((left - topleft)>>1); break;\ | |
1455 | 296 default:\ |
1310 | 297 case 7: ret= (left + top)>>1; break;\ |
1307 | 298 } |
299 | |
1325 | 300 #ifdef CONFIG_ENCODERS |
0 | 301 static inline void put_marker(PutBitContext *p, int code) |
302 { | |
303 put_bits(p, 8, 0xff); | |
304 put_bits(p, 8, code); | |
305 } | |
306 | |
307 /* table_class: 0 = DC coef, 1 = AC coefs */ | |
308 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id, | |
1064 | 309 const uint8_t *bits_table, const uint8_t *value_table) |
0 | 310 { |
311 PutBitContext *p = &s->pb; | |
312 int n, i; | |
313 | |
314 put_bits(p, 4, table_class); | |
315 put_bits(p, 4, table_id); | |
316 | |
317 n = 0; | |
318 for(i=1;i<=16;i++) { | |
319 n += bits_table[i]; | |
320 put_bits(p, 8, bits_table[i]); | |
321 } | |
322 | |
323 for(i=0;i<n;i++) | |
324 put_bits(p, 8, value_table[i]); | |
325 | |
326 return n + 17; | |
327 } | |
328 | |
329 static void jpeg_table_header(MpegEncContext *s) | |
330 { | |
331 PutBitContext *p = &s->pb; | |
37 | 332 int i, j, size; |
1064 | 333 uint8_t *ptr; |
0 | 334 |
335 /* quant matrixes */ | |
336 put_marker(p, DQT); | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
337 #ifdef TWOMATRIXES |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
338 put_bits(p, 16, 2 + 2 * (1 + 64)); |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
339 #else |
0 | 340 put_bits(p, 16, 2 + 1 * (1 + 64)); |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
341 #endif |
0 | 342 put_bits(p, 4, 0); /* 8 bit precision */ |
343 put_bits(p, 4, 0); /* table 0 */ | |
344 for(i=0;i<64;i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
345 j = s->intra_scantable.permutated[i]; |
37 | 346 put_bits(p, 8, s->intra_matrix[j]); |
0 | 347 } |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
348 #ifdef TWOMATRIXES |
0 | 349 put_bits(p, 4, 0); /* 8 bit precision */ |
350 put_bits(p, 4, 1); /* table 1 */ | |
351 for(i=0;i<64;i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
352 j = s->intra_scantable.permutated[i]; |
37 | 353 put_bits(p, 8, s->chroma_intra_matrix[j]); |
0 | 354 } |
355 #endif | |
356 | |
357 /* huffman table */ | |
358 put_marker(p, DHT); | |
359 flush_put_bits(p); | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
229
diff
changeset
|
360 ptr = pbBufPtr(p); |
0 | 361 put_bits(p, 16, 0); /* patched later */ |
362 size = 2; | |
363 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance); | |
364 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance); | |
365 | |
366 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance); | |
367 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance); | |
368 ptr[0] = size >> 8; | |
369 ptr[1] = size; | |
370 } | |
371 | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
372 static void jpeg_put_comments(MpegEncContext *s) |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
373 { |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
374 PutBitContext *p = &s->pb; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
375 int size; |
1064 | 376 uint8_t *ptr; |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
377 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
378 if (s->aspect_ratio_info /* && !lossless */) |
672 | 379 { |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
380 /* JFIF header */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
381 put_marker(p, APP0); |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
382 put_bits(p, 16, 16); |
1795 | 383 put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */ |
672 | 384 put_bits(p, 16, 0x0201); /* v 1.02 */ |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
385 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */ |
1548 | 386 put_bits(p, 16, s->avctx->sample_aspect_ratio.num); |
387 put_bits(p, 16, s->avctx->sample_aspect_ratio.den); | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
388 put_bits(p, 8, 0); /* thumbnail width */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
389 put_bits(p, 8, 0); /* thumbnail height */ |
672 | 390 } |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
391 |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
392 /* comment */ |
1092 | 393 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
676 | 394 put_marker(p, COM); |
395 flush_put_bits(p); | |
396 ptr = pbBufPtr(p); | |
397 put_bits(p, 16, 0); /* patched later */ | |
1795 | 398 put_string(p, LIBAVCODEC_IDENT, 1); |
1118 | 399 size = strlen(LIBAVCODEC_IDENT)+3; |
676 | 400 ptr[0] = size >> 8; |
401 ptr[1] = size; | |
402 } | |
2442 | 403 |
404 if( s->avctx->pix_fmt == PIX_FMT_YUV420P | |
405 ||s->avctx->pix_fmt == PIX_FMT_YUV422P | |
406 ||s->avctx->pix_fmt == PIX_FMT_YUV444P){ | |
407 put_marker(p, COM); | |
408 flush_put_bits(p); | |
409 ptr = pbBufPtr(p); | |
410 put_bits(p, 16, 0); /* patched later */ | |
411 put_string(p, "CS=ITU601", 1); | |
412 size = strlen("CS=ITU601")+3; | |
413 ptr[0] = size >> 8; | |
414 ptr[1] = size; | |
415 } | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
416 } |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
417 |
0 | 418 void mjpeg_picture_header(MpegEncContext *s) |
419 { | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
420 const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
421 |
0 | 422 put_marker(&s->pb, SOI); |
423 | |
370
0eca28d16cbd
clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents:
369
diff
changeset
|
424 if (!s->mjpeg_data_only_frames) |
0eca28d16cbd
clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents:
369
diff
changeset
|
425 { |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
426 jpeg_put_comments(s); |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
427 |
229 | 428 if (s->mjpeg_write_tables) jpeg_table_header(s); |
0 | 429 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
430 put_marker(&s->pb, lossless ? SOF3 : SOF0); |
0 | 431 |
432 put_bits(&s->pb, 16, 17); | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
433 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32) |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
434 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
435 else |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
436 put_bits(&s->pb, 8, 8); /* 8 bits/component */ |
0 | 437 put_bits(&s->pb, 16, s->height); |
438 put_bits(&s->pb, 16, s->width); | |
439 put_bits(&s->pb, 8, 3); /* 3 components */ | |
440 | |
441 /* Y component */ | |
442 put_bits(&s->pb, 8, 1); /* component number */ | |
229 | 443 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */ |
444 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */ | |
0 | 445 put_bits(&s->pb, 8, 0); /* select matrix */ |
446 | |
447 /* Cb component */ | |
448 put_bits(&s->pb, 8, 2); /* component number */ | |
229 | 449 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */ |
450 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */ | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
451 #ifdef TWOMATRIXES |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
452 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */ |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
453 #else |
0 | 454 put_bits(&s->pb, 8, 0); /* select matrix */ |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
455 #endif |
0 | 456 |
457 /* Cr component */ | |
458 put_bits(&s->pb, 8, 3); /* component number */ | |
229 | 459 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */ |
460 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */ | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
461 #ifdef TWOMATRIXES |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
462 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */ |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
463 #else |
0 | 464 put_bits(&s->pb, 8, 0); /* select matrix */ |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
465 #endif |
370
0eca28d16cbd
clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents:
369
diff
changeset
|
466 } |
0 | 467 |
468 /* scan header */ | |
469 put_marker(&s->pb, SOS); | |
470 put_bits(&s->pb, 16, 12); /* length */ | |
471 put_bits(&s->pb, 8, 3); /* 3 components */ | |
472 | |
473 /* Y component */ | |
474 put_bits(&s->pb, 8, 1); /* index */ | |
475 put_bits(&s->pb, 4, 0); /* DC huffman table index */ | |
476 put_bits(&s->pb, 4, 0); /* AC huffman table index */ | |
477 | |
478 /* Cb component */ | |
479 put_bits(&s->pb, 8, 2); /* index */ | |
480 put_bits(&s->pb, 4, 1); /* DC huffman table index */ | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
481 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */ |
0 | 482 |
483 /* Cr component */ | |
484 put_bits(&s->pb, 8, 3); /* index */ | |
485 put_bits(&s->pb, 4, 1); /* DC huffman table index */ | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
486 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */ |
0 | 487 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
488 put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
489 put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */ |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
490 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */ |
0 | 491 } |
492 | |
841 | 493 static void escape_FF(MpegEncContext *s, int start) |
840 | 494 { |
1786 | 495 int size= put_bits_count(&s->pb) - start*8; |
840 | 496 int i, ff_count; |
841 | 497 uint8_t *buf= s->pb.buf + start; |
1266 | 498 int align= (-(size_t)(buf))&3; |
840 | 499 |
500 assert((size&7) == 0); | |
501 size >>= 3; | |
502 | |
503 ff_count=0; | |
504 for(i=0; i<size && i<align; i++){ | |
505 if(buf[i]==0xFF) ff_count++; | |
506 } | |
507 for(; i<size-15; i+=16){ | |
508 int acc, v; | |
509 | |
510 v= *(uint32_t*)(&buf[i]); | |
511 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
512 v= *(uint32_t*)(&buf[i+4]); | |
513 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
514 v= *(uint32_t*)(&buf[i+8]); | |
515 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
516 v= *(uint32_t*)(&buf[i+12]); | |
517 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
518 | |
519 acc>>=4; | |
520 acc+= (acc>>16); | |
521 acc+= (acc>>8); | |
522 ff_count+= acc&0xFF; | |
523 } | |
524 for(; i<size; i++){ | |
525 if(buf[i]==0xFF) ff_count++; | |
526 } | |
527 | |
528 if(ff_count==0) return; | |
529 | |
530 /* skip put bits */ | |
531 for(i=0; i<ff_count-3; i+=4) | |
532 put_bits(&s->pb, 32, 0); | |
533 put_bits(&s->pb, (ff_count-i)*8, 0); | |
534 flush_put_bits(&s->pb); | |
535 | |
536 for(i=size-1; ff_count; i--){ | |
537 int v= buf[i]; | |
538 | |
539 if(v==0xFF){ | |
540 //printf("%d %d\n", i, ff_count); | |
541 buf[i+ff_count]= 0; | |
542 ff_count--; | |
543 } | |
544 | |
545 buf[i+ff_count]= v; | |
546 } | |
547 } | |
548 | |
1799 | 549 void ff_mjpeg_stuffing(PutBitContext * pbc) |
550 { | |
551 int length; | |
552 length= (-put_bits_count(pbc))&7; | |
553 if(length) put_bits(pbc, length, (1<<length)-1); | |
554 } | |
555 | |
0 | 556 void mjpeg_picture_trailer(MpegEncContext *s) |
557 { | |
1799 | 558 ff_mjpeg_stuffing(&s->pb); |
840 | 559 flush_put_bits(&s->pb); |
560 | |
841 | 561 assert((s->header_bits&7)==0); |
562 | |
563 escape_FF(s, s->header_bits>>3); | |
840 | 564 |
0 | 565 put_marker(&s->pb, EOI); |
566 } | |
567 | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
568 static inline void mjpeg_encode_dc(MpegEncContext *s, int val, |
1064 | 569 uint8_t *huff_size, uint16_t *huff_code) |
0 | 570 { |
571 int mant, nbits; | |
572 | |
573 if (val == 0) { | |
840 | 574 put_bits(&s->pb, huff_size[0], huff_code[0]); |
0 | 575 } else { |
576 mant = val; | |
577 if (val < 0) { | |
578 val = -val; | |
579 mant--; | |
580 } | |
581 | |
1325 | 582 nbits= av_log2_16bit(val) + 1; |
0 | 583 |
840 | 584 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]); |
0 | 585 |
840 | 586 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1)); |
0 | 587 } |
588 } | |
589 | |
590 static void encode_block(MpegEncContext *s, DCTELEM *block, int n) | |
591 { | |
592 int mant, nbits, code, i, j; | |
593 int component, dc, run, last_index, val; | |
594 MJpegContext *m = s->mjpeg_ctx; | |
1064 | 595 uint8_t *huff_size_ac; |
596 uint16_t *huff_code_ac; | |
0 | 597 |
598 /* DC coef */ | |
599 component = (n <= 3 ? 0 : n - 4 + 1); | |
600 dc = block[0]; /* overflow is impossible */ | |
601 val = dc - s->last_dc[component]; | |
602 if (n < 4) { | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
603 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance); |
0 | 604 huff_size_ac = m->huff_size_ac_luminance; |
605 huff_code_ac = m->huff_code_ac_luminance; | |
606 } else { | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
607 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance); |
0 | 608 huff_size_ac = m->huff_size_ac_chrominance; |
609 huff_code_ac = m->huff_code_ac_chrominance; | |
610 } | |
611 s->last_dc[component] = dc; | |
612 | |
613 /* AC coefs */ | |
614 | |
615 run = 0; | |
616 last_index = s->block_last_index[n]; | |
617 for(i=1;i<=last_index;i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
618 j = s->intra_scantable.permutated[i]; |
0 | 619 val = block[j]; |
620 if (val == 0) { | |
621 run++; | |
622 } else { | |
623 while (run >= 16) { | |
840 | 624 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]); |
0 | 625 run -= 16; |
626 } | |
627 mant = val; | |
628 if (val < 0) { | |
629 val = -val; | |
630 mant--; | |
631 } | |
632 | |
1280 | 633 nbits= av_log2(val) + 1; |
0 | 634 code = (run << 4) | nbits; |
635 | |
840 | 636 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]); |
0 | 637 |
840 | 638 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1)); |
0 | 639 run = 0; |
640 } | |
641 } | |
642 | |
643 /* output EOB only if not already 64 values */ | |
644 if (last_index < 63 || run != 0) | |
840 | 645 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]); |
0 | 646 } |
647 | |
648 void mjpeg_encode_mb(MpegEncContext *s, | |
649 DCTELEM block[6][64]) | |
650 { | |
651 int i; | |
652 for(i=0;i<6;i++) { | |
653 encode_block(s, block[i], i); | |
654 } | |
655 } | |
23 | 656 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
657 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
658 MpegEncContext * const s = avctx->priv_data; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
659 MJpegContext * const m = s->mjpeg_ctx; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
660 AVFrame *pict = data; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
661 const int width= s->width; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
662 const int height= s->height; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
663 AVFrame * const p= (AVFrame*)&s->current_picture; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
664 const int predictor= avctx->prediction_method+1; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
665 |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1519
diff
changeset
|
666 init_put_bits(&s->pb, buf, buf_size); |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
667 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
668 *p = *pict; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
669 p->pict_type= FF_I_TYPE; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
670 p->key_frame= 1; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
671 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
672 mjpeg_picture_header(s); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
673 |
1786 | 674 s->header_bits= put_bits_count(&s->pb); |
2422 | 675 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
676 if(avctx->pix_fmt == PIX_FMT_RGBA32){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
677 int x, y, i; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
678 const int linesize= p->linesize[0]; |
2422 | 679 uint16_t (*buffer)[4]= s->rd_scratchpad; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
680 int left[3], top[3], topleft[3]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
681 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
682 for(i=0; i<3; i++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
683 buffer[0][i]= 1 << (9 - 1); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
684 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
685 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
686 for(y = 0; y < height; y++) { |
1363 | 687 const int modified_predictor= y ? predictor : 1; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
688 uint8_t *ptr = p->data[0] + (linesize * y); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
689 |
2422 | 690 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){ |
691 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
692 return -1; | |
693 } | |
694 | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
695 for(i=0; i<3; i++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
696 top[i]= left[i]= topleft[i]= buffer[0][i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
697 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
698 for(x = 0; x < width; x++) { |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
699 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
700 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
701 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
702 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
703 for(i=0;i<3;i++) { |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
704 int pred, diff; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
705 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
706 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
707 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
708 topleft[i]= top[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
709 top[i]= buffer[x+1][i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
710 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
711 left[i]= buffer[x][i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
712 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
713 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
714 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
715 if(i==0) |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
716 mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
717 else |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
718 mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
719 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
720 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
721 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
722 }else{ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
723 int mb_x, mb_y, i; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
724 const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
725 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
726 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
727 for(mb_y = 0; mb_y < mb_height; mb_y++) { |
2422 | 728 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < mb_width * 4 * 3 * s->mjpeg_hsample[0] * s->mjpeg_vsample[0]){ |
729 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
730 return -1; | |
731 } | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
732 for(mb_x = 0; mb_x < mb_width; mb_x++) { |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
733 if(mb_x==0 || mb_y==0){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
734 for(i=0;i<3;i++) { |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
735 uint8_t *ptr; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
736 int x, y, h, v, linesize; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
737 h = s->mjpeg_hsample[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
738 v = s->mjpeg_vsample[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
739 linesize= p->linesize[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
740 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
741 for(y=0; y<v; y++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
742 for(x=0; x<h; x++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
743 int pred; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
744 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
745 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
746 if(y==0 && mb_y==0){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
747 if(x==0 && mb_x==0){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
748 pred= 128; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
749 }else{ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
750 pred= ptr[-1]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
751 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
752 }else{ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
753 if(x==0 && mb_x==0){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
754 pred= ptr[-linesize]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
755 }else{ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
756 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
757 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
758 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
759 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
760 if(i==0) |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
761 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
762 else |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
763 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
764 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
765 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
766 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
767 }else{ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
768 for(i=0;i<3;i++) { |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
769 uint8_t *ptr; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
770 int x, y, h, v, linesize; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
771 h = s->mjpeg_hsample[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
772 v = s->mjpeg_vsample[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
773 linesize= p->linesize[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
774 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
775 for(y=0; y<v; y++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
776 for(x=0; x<h; x++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
777 int pred; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
778 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
779 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
780 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
781 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
782 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
783 if(i==0) |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
784 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
785 else |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
786 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
787 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
788 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
789 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
790 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
791 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
792 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
793 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
794 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
795 emms_c(); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
796 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
797 mjpeg_picture_trailer(s); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
798 s->picture_number++; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
799 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
800 flush_put_bits(&s->pb); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
801 return pbBufPtr(&s->pb) - s->pb.buf; |
1786 | 802 // return (put_bits_count(&f->pb)+7)/8; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
803 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
804 |
1325 | 805 #endif //CONFIG_ENCODERS |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
806 |
23 | 807 /******************************************/ |
808 /* decoding */ | |
809 | |
810 #define MAX_COMPONENTS 4 | |
811 | |
812 typedef struct MJpegDecodeContext { | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
813 AVCodecContext *avctx; |
23 | 814 GetBitContext gb; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
815 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */ |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
816 |
23 | 817 int start_code; /* current start code */ |
818 int buffer_size; | |
1064 | 819 uint8_t *buffer; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
820 |
1064 | 821 int16_t quant_matrixes[4][64]; |
23 | 822 VLC vlcs[2][4]; |
1358 | 823 int qscale[4]; ///< quantizer scale calculated from quant_matrixes |
53 | 824 |
1679
55c03fa692a9
set AVCodecContext.width/height before get_buffer()
michael
parents:
1619
diff
changeset
|
825 int org_height; /* size given at codec init */ |
53 | 826 int first_picture; /* true if decoding first picture */ |
827 int interlaced; /* true if interlaced */ | |
828 int bottom_field; /* true if bottom field */ | |
1307 | 829 int lossless; |
830 int rgb; | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
831 int rct; /* standard rct */ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
832 int pegasus_rct; /* pegasus reversible colorspace transform */ |
1310 | 833 int bits; /* bits per component */ |
53 | 834 |
23 | 835 int width, height; |
1359 | 836 int mb_width, mb_height; |
26 | 837 int nb_components; |
838 int component_id[MAX_COMPONENTS]; | |
23 | 839 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */ |
840 int v_count[MAX_COMPONENTS]; | |
1359 | 841 int comp_index[MAX_COMPONENTS]; |
842 int dc_index[MAX_COMPONENTS]; | |
843 int ac_index[MAX_COMPONENTS]; | |
844 int nb_blocks[MAX_COMPONENTS]; | |
845 int h_scount[MAX_COMPONENTS]; | |
846 int v_scount[MAX_COMPONENTS]; | |
23 | 847 int h_max, v_max; /* maximum h and v counts */ |
848 int quant_index[4]; /* quant table index for each component */ | |
849 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */ | |
1513 | 850 AVFrame picture; /* picture structure */ |
851 int linesize[MAX_COMPONENTS]; ///< linesize << interlaced | |
2367
c353719836af
fix some type mismatches patch by (Jeff Muizelaar <muizelaar rogers com>)
michael
parents:
2360
diff
changeset
|
852 int8_t *qscale_table; |
23 | 853 DCTELEM block[64] __align8; |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
854 ScanTable scantable; |
1064 | 855 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/); |
354 | 856 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
857 int restart_interval; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
858 int restart_count; |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
859 |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
860 int buggy_avid; |
2442 | 861 int cs_itu601; |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
862 int interlace_polarity; |
2333
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
863 |
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
864 int mjpb_skiptosod; |
23 | 865 } MJpegDecodeContext; |
866 | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
867 static int mjpeg_decode_dht(MJpegDecodeContext *s); |
375 | 868 |
1351 | 869 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2367
diff
changeset
|
870 int nb_codes, int use_static) |
29 | 871 { |
1064 | 872 uint8_t huff_size[256]; |
873 uint16_t huff_code[256]; | |
29 | 874 |
875 memset(huff_size, 0, sizeof(huff_size)); | |
876 build_huffman_codes(huff_size, huff_code, bits_table, val_table); | |
877 | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2367
diff
changeset
|
878 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static); |
29 | 879 } |
880 | |
23 | 881 static int mjpeg_decode_init(AVCodecContext *avctx) |
882 { | |
883 MJpegDecodeContext *s = avctx->priv_data; | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
884 MpegEncContext s2; |
23 | 885 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
886 s->avctx = avctx; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
887 |
1092 | 888 /* ugly way to get the idct & scantable FIXME */ |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
889 memset(&s2, 0, sizeof(MpegEncContext)); |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
890 s2.avctx= avctx; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
891 // s2->out_format = FMT_MJPEG; |
1892 | 892 dsputil_init(&s2.dsp, avctx); |
893 DCT_common_init(&s2); | |
894 | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
895 s->scantable= s2.intra_scantable; |
1092 | 896 s->idct_put= s2.dsp.idct_put; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
897 |
23 | 898 s->mpeg_enc_ctx_allocated = 0; |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
899 s->buffer_size = 102400; /* smaller buffer should be enough, |
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
900 but photojpg files could ahive bigger sizes */ |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
901 s->buffer = av_malloc(s->buffer_size); |
935 | 902 if (!s->buffer) |
903 return -1; | |
23 | 904 s->start_code = -1; |
53 | 905 s->first_picture = 1; |
2270 | 906 s->org_height = avctx->coded_height; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
907 |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2367
diff
changeset
|
908 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2367
diff
changeset
|
909 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2367
diff
changeset
|
910 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2367
diff
changeset
|
911 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0); |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
912 |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
913 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF) |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
914 { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
915 av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n"); |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
949
diff
changeset
|
916 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8); |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
917 mjpeg_decode_dht(s); |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
918 /* should check for error - but dunno */ |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
919 } |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
920 |
23 | 921 return 0; |
922 } | |
923 | |
2319 | 924 |
925 /** | |
926 * finds the end of the current frame in the bitstream. | |
927 * @return the position of the first byte of the next frame, or -1 | |
928 */ | |
929 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){ | |
930 int vop_found, i; | |
931 uint16_t state; | |
932 | |
933 vop_found= pc->frame_start_found; | |
934 state= pc->state; | |
935 | |
936 i=0; | |
937 if(!vop_found){ | |
938 for(i=0; i<buf_size; i++){ | |
939 state= (state<<8) | buf[i]; | |
940 if(state == 0xFFD8){ | |
941 i++; | |
942 vop_found=1; | |
943 break; | |
944 } | |
945 } | |
946 } | |
947 | |
948 if(vop_found){ | |
949 /* EOF considered as end of frame */ | |
950 if (buf_size == 0) | |
951 return 0; | |
952 for(; i<buf_size; i++){ | |
953 state= (state<<8) | buf[i]; | |
954 if(state == 0xFFD8){ | |
955 pc->frame_start_found=0; | |
956 pc->state=0; | |
957 return i-1; | |
958 } | |
959 } | |
960 } | |
961 pc->frame_start_found= vop_found; | |
962 pc->state= state; | |
963 return END_NOT_FOUND; | |
964 } | |
965 | |
966 static int jpeg_parse(AVCodecParserContext *s, | |
967 AVCodecContext *avctx, | |
968 uint8_t **poutbuf, int *poutbuf_size, | |
969 const uint8_t *buf, int buf_size) | |
970 { | |
971 ParseContext *pc = s->priv_data; | |
972 int next; | |
973 | |
974 next= find_frame_end(pc, buf, buf_size); | |
975 | |
976 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
977 *poutbuf = NULL; | |
978 *poutbuf_size = 0; | |
979 return buf_size; | |
980 } | |
981 | |
982 *poutbuf = (uint8_t *)buf; | |
983 *poutbuf_size = buf_size; | |
984 return next; | |
985 } | |
986 | |
23 | 987 /* quantize tables */ |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
988 static int mjpeg_decode_dqt(MJpegDecodeContext *s) |
23 | 989 { |
37 | 990 int len, index, i, j; |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
991 |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
992 len = get_bits(&s->gb, 16) - 2; |
23 | 993 |
994 while (len >= 65) { | |
995 /* only 8 bit precision handled */ | |
996 if (get_bits(&s->gb, 4) != 0) | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
997 { |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
998 dprintf("dqt: 16bit precision\n"); |
23 | 999 return -1; |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1000 } |
23 | 1001 index = get_bits(&s->gb, 4); |
1002 if (index >= 4) | |
1003 return -1; | |
1004 dprintf("index=%d\n", index); | |
1005 /* read quant table */ | |
37 | 1006 for(i=0;i<64;i++) { |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
1007 j = s->scantable.permutated[i]; |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1008 s->quant_matrixes[index][j] = get_bits(&s->gb, 8); |
37 | 1009 } |
1358 | 1010 |
1011 //XXX FIXME finetune, and perhaps add dc too | |
1012 s->qscale[index]= FFMAX( | |
1013 s->quant_matrixes[index][s->scantable.permutated[1]], | |
1014 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1; | |
1519 | 1015 dprintf("qscale[%d]: %d\n", index, s->qscale[index]); |
23 | 1016 len -= 65; |
1017 } | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1018 |
23 | 1019 return 0; |
1020 } | |
1021 | |
1022 /* decode huffman tables and build VLC decoders */ | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1023 static int mjpeg_decode_dht(MJpegDecodeContext *s) |
23 | 1024 { |
1025 int len, index, i, class, n, v, code_max; | |
1064 | 1026 uint8_t bits_table[17]; |
1027 uint8_t val_table[256]; | |
23 | 1028 |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1029 len = get_bits(&s->gb, 16) - 2; |
23 | 1030 |
1031 while (len > 0) { | |
1032 if (len < 17) | |
1033 return -1; | |
1034 class = get_bits(&s->gb, 4); | |
1035 if (class >= 2) | |
1036 return -1; | |
1037 index = get_bits(&s->gb, 4); | |
1038 if (index >= 4) | |
1039 return -1; | |
1040 n = 0; | |
1041 for(i=1;i<=16;i++) { | |
1042 bits_table[i] = get_bits(&s->gb, 8); | |
1043 n += bits_table[i]; | |
1044 } | |
1045 len -= 17; | |
1046 if (len < n || n > 256) | |
1047 return -1; | |
1048 | |
1049 code_max = 0; | |
1050 for(i=0;i<n;i++) { | |
1051 v = get_bits(&s->gb, 8); | |
1052 if (v > code_max) | |
1053 code_max = v; | |
1054 val_table[i] = v; | |
1055 } | |
1056 len -= n; | |
1057 | |
1058 /* build VLC and flush previous vlc if present */ | |
1059 free_vlc(&s->vlcs[class][index]); | |
1060 dprintf("class=%d index=%d nb_codes=%d\n", | |
1061 class, index, code_max + 1); | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2367
diff
changeset
|
1062 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0) < 0){ |
1351 | 1063 return -1; |
1064 } | |
23 | 1065 } |
1066 return 0; | |
1067 } | |
1068 | |
1307 | 1069 static int mjpeg_decode_sof(MJpegDecodeContext *s) |
23 | 1070 { |
26 | 1071 int len, nb_components, i, width, height; |
23 | 1072 |
1073 /* XXX: verify len field validity */ | |
1074 len = get_bits(&s->gb, 16); | |
1310 | 1075 s->bits= get_bits(&s->gb, 8); |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
1076 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
1077 if(s->pegasus_rct) s->bits=9; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
1078 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly |
1310 | 1079 |
1080 if (s->bits != 8 && !s->lossless){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1081 av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n"); |
23 | 1082 return -1; |
1307 | 1083 } |
23 | 1084 height = get_bits(&s->gb, 16); |
1085 width = get_bits(&s->gb, 16); | |
2422 | 1086 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1087 dprintf("sof0: picture: %dx%d\n", width, height); |
2422 | 1088 if(avcodec_check_dimensions(s->avctx, width, height)) |
1089 return -1; | |
23 | 1090 |
1091 nb_components = get_bits(&s->gb, 8); | |
1092 if (nb_components <= 0 || | |
1093 nb_components > MAX_COMPONENTS) | |
1094 return -1; | |
26 | 1095 s->nb_components = nb_components; |
23 | 1096 s->h_max = 1; |
1097 s->v_max = 1; | |
1098 for(i=0;i<nb_components;i++) { | |
1099 /* component id */ | |
26 | 1100 s->component_id[i] = get_bits(&s->gb, 8) - 1; |
23 | 1101 s->h_count[i] = get_bits(&s->gb, 4); |
1102 s->v_count[i] = get_bits(&s->gb, 4); | |
1103 /* compute hmax and vmax (only used in interleaved case) */ | |
1104 if (s->h_count[i] > s->h_max) | |
1105 s->h_max = s->h_count[i]; | |
1106 if (s->v_count[i] > s->v_max) | |
1107 s->v_max = s->v_count[i]; | |
1108 s->quant_index[i] = get_bits(&s->gb, 8); | |
1109 if (s->quant_index[i] >= 4) | |
1110 return -1; | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1111 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i], |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1112 s->v_count[i], s->component_id[i], s->quant_index[i]); |
23 | 1113 } |
1310 | 1114 |
1115 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1; | |
23 | 1116 |
1117 /* if different size, realloc/alloc picture */ | |
1118 /* XXX: also check h_count and v_count */ | |
1119 if (width != s->width || height != s->height) { | |
1358 | 1120 av_freep(&s->qscale_table); |
1121 | |
23 | 1122 s->width = width; |
1123 s->height = height; | |
2270 | 1124 avcodec_set_dimensions(s->avctx, width, height); |
1679
55c03fa692a9
set AVCodecContext.width/height before get_buffer()
michael
parents:
1619
diff
changeset
|
1125 |
53 | 1126 /* test interlaced mode */ |
1127 if (s->first_picture && | |
1128 s->org_height != 0 && | |
1129 s->height < ((s->org_height * 3) / 4)) { | |
1130 s->interlaced = 1; | |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1131 // s->bottom_field = (s->interlace_polarity) ? 1 : 0; |
1679
55c03fa692a9
set AVCodecContext.width/height before get_buffer()
michael
parents:
1619
diff
changeset
|
1132 s->bottom_field = 0; |
55c03fa692a9
set AVCodecContext.width/height before get_buffer()
michael
parents:
1619
diff
changeset
|
1133 s->avctx->height *= 2; |
53 | 1134 } |
1135 | |
1358 | 1136 s->qscale_table= av_mallocz((s->width+15)/16); |
1137 | |
53 | 1138 s->first_picture = 0; |
23 | 1139 } |
1513 | 1140 |
1141 if(s->interlaced && s->bottom_field) | |
1142 return 0; | |
1143 | |
1144 /* XXX: not complete test ! */ | |
1145 switch((s->h_count[0] << 4) | s->v_count[0]) { | |
1146 case 0x11: | |
1147 if(s->rgb){ | |
1148 s->avctx->pix_fmt = PIX_FMT_RGBA32; | |
1740
0c686b4cd576
grayscale mjpeg decoding support based upon a patch by (Leon Bottou (leonb))
michael
parents:
1679
diff
changeset
|
1149 }else if(s->nb_components==3) |
2442 | 1150 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P; |
1740
0c686b4cd576
grayscale mjpeg decoding support based upon a patch by (Leon Bottou (leonb))
michael
parents:
1679
diff
changeset
|
1151 else |
0c686b4cd576
grayscale mjpeg decoding support based upon a patch by (Leon Bottou (leonb))
michael
parents:
1679
diff
changeset
|
1152 s->avctx->pix_fmt = PIX_FMT_GRAY8; |
1513 | 1153 break; |
1154 case 0x21: | |
2442 | 1155 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P; |
1513 | 1156 break; |
1157 default: | |
1158 case 0x22: | |
2442 | 1159 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P; |
1513 | 1160 break; |
1161 } | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1162 |
1513 | 1163 if(s->picture.data[0]) |
1164 s->avctx->release_buffer(s->avctx, &s->picture); | |
1165 | |
1166 s->picture.reference= 0; | |
1167 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1168 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
1513 | 1169 return -1; |
1170 } | |
1171 s->picture.pict_type= I_TYPE; | |
1172 s->picture.key_frame= 1; | |
1173 | |
1174 for(i=0; i<3; i++){ | |
1175 s->linesize[i]= s->picture.linesize[i] << s->interlaced; | |
1176 } | |
1177 | |
1178 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height); | |
1179 | |
354 | 1180 if (len != (8+(3*nb_components))) |
1181 { | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1182 dprintf("decode_sof0: error, len(%d) mismatch\n", len); |
354 | 1183 } |
53 | 1184 |
23 | 1185 return 0; |
1186 } | |
1187 | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
1188 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index) |
23 | 1189 { |
1280 | 1190 int code; |
780 | 1191 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2); |
23 | 1192 if (code < 0) |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1193 { |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
1194 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index, |
427 | 1195 &s->vlcs[0][dc_index]); |
23 | 1196 return 0xffff; |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1197 } |
1280 | 1198 |
1199 if(code) | |
1200 return get_xbits(&s->gb, code); | |
1201 else | |
1202 return 0; | |
23 | 1203 } |
1204 | |
1205 /* decode block and dequantize */ | |
1206 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, | |
1207 int component, int dc_index, int ac_index, int quant_index) | |
1208 { | |
1280 | 1209 int code, i, j, level, val; |
23 | 1210 VLC *ac_vlc; |
1064 | 1211 int16_t *quant_matrix; |
23 | 1212 |
1213 /* DC coef */ | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
1214 val = mjpeg_decode_dc(s, dc_index); |
23 | 1215 if (val == 0xffff) { |
1216 dprintf("error dc\n"); | |
1217 return -1; | |
1218 } | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1219 quant_matrix = s->quant_matrixes[quant_index]; |
23 | 1220 val = val * quant_matrix[0] + s->last_dc[component]; |
1221 s->last_dc[component] = val; | |
1222 block[0] = val; | |
1223 /* AC coefs */ | |
1224 ac_vlc = &s->vlcs[1][ac_index]; | |
1225 i = 1; | |
1226 for(;;) { | |
780 | 1227 code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2); |
1275 | 1228 |
23 | 1229 if (code < 0) { |
1230 dprintf("error ac\n"); | |
1231 return -1; | |
1232 } | |
1233 /* EOB */ | |
1234 if (code == 0) | |
1235 break; | |
1236 if (code == 0xf0) { | |
1237 i += 16; | |
1238 } else { | |
1280 | 1239 level = get_xbits(&s->gb, code & 0xf); |
1240 i += code >> 4; | |
23 | 1241 if (i >= 64) { |
1242 dprintf("error count: %d\n", i); | |
1243 return -1; | |
1244 } | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
1245 j = s->scantable.permutated[i]; |
23 | 1246 block[j] = level * quant_matrix[j]; |
1247 i++; | |
28
b611fafddf9e
added 422P and 444P support - fixed block parsing error
glantau
parents:
26
diff
changeset
|
1248 if (i >= 64) |
b611fafddf9e
added 422P and 444P support - fixed block parsing error
glantau
parents:
26
diff
changeset
|
1249 break; |
23 | 1250 } |
1251 } | |
1252 return 0; | |
1253 } | |
1254 | |
1359 | 1255 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){ |
1256 int i, mb_x, mb_y; | |
2422 | 1257 uint16_t buffer[32768][4]; |
1359 | 1258 int left[3], top[3], topleft[3]; |
1259 const int linesize= s->linesize[0]; | |
1260 const int mask= (1<<s->bits)-1; | |
1261 | |
2422 | 1262 if((unsigned)s->mb_width > 32768) //dynamic alloc |
1263 return -1; | |
1264 | |
1359 | 1265 for(i=0; i<3; i++){ |
1266 buffer[0][i]= 1 << (s->bits + point_transform - 1); | |
1267 } | |
1268 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
1363 | 1269 const int modified_predictor= mb_y ? predictor : 1; |
1513 | 1270 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y); |
1359 | 1271 |
1272 if (s->interlaced && s->bottom_field) | |
1273 ptr += linesize >> 1; | |
1274 | |
1275 for(i=0; i<3; i++){ | |
1276 top[i]= left[i]= topleft[i]= buffer[0][i]; | |
1277 } | |
1278 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1279 if (s->restart_interval && !s->restart_count) | |
1280 s->restart_count = s->restart_interval; | |
1281 | |
1282 for(i=0;i<3;i++) { | |
1283 int pred; | |
1284 | |
1285 topleft[i]= top[i]; | |
1286 top[i]= buffer[mb_x][i]; | |
1287 | |
1288 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); | |
1289 | |
1290 left[i]= | |
1291 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform)); | |
1292 } | |
1293 | |
1294 if (s->restart_interval && !--s->restart_count) { | |
1295 align_get_bits(&s->gb); | |
1296 skip_bits(&s->gb, 16); /* skip RSTn */ | |
1297 } | |
1298 } | |
1299 | |
1300 if(s->rct){ | |
1301 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1302 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2); | |
1303 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; | |
1304 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; | |
1305 } | |
1306 }else if(s->pegasus_rct){ | |
1307 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1308 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2); | |
1309 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; | |
1310 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; | |
1311 } | |
1312 }else{ | |
1313 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1314 ptr[4*mb_x+0] = buffer[mb_x][0]; | |
1315 ptr[4*mb_x+1] = buffer[mb_x][1]; | |
1316 ptr[4*mb_x+2] = buffer[mb_x][2]; | |
1317 } | |
1318 } | |
1319 } | |
1320 return 0; | |
1321 } | |
1322 | |
1323 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){ | |
1324 int i, mb_x, mb_y; | |
1325 const int nb_components=3; | |
1326 | |
1327 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
1328 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1329 if (s->restart_interval && !s->restart_count) | |
1330 s->restart_count = s->restart_interval; | |
1331 | |
1332 if(mb_x==0 || mb_y==0 || s->interlaced){ | |
1333 for(i=0;i<nb_components;i++) { | |
1334 uint8_t *ptr; | |
1335 int n, h, v, x, y, c, j, linesize; | |
1336 n = s->nb_blocks[i]; | |
1337 c = s->comp_index[i]; | |
1338 h = s->h_scount[i]; | |
1339 v = s->v_scount[i]; | |
1340 x = 0; | |
1341 y = 0; | |
1342 linesize= s->linesize[c]; | |
1343 | |
1344 for(j=0; j<n; j++) { | |
1345 int pred; | |
1346 | |
1513 | 1347 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap |
1359 | 1348 if(y==0 && mb_y==0){ |
1349 if(x==0 && mb_x==0){ | |
1350 pred= 128 << point_transform; | |
1351 }else{ | |
1352 pred= ptr[-1]; | |
1353 } | |
1354 }else{ | |
1355 if(x==0 && mb_x==0){ | |
1356 pred= ptr[-linesize]; | |
1357 }else{ | |
1358 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); | |
1359 } | |
1360 } | |
1361 | |
1362 if (s->interlaced && s->bottom_field) | |
1363 ptr += linesize >> 1; | |
1364 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); | |
1365 | |
1366 if (++x == h) { | |
1367 x = 0; | |
1368 y++; | |
1369 } | |
1370 } | |
1371 } | |
1372 }else{ | |
1373 for(i=0;i<nb_components;i++) { | |
1374 uint8_t *ptr; | |
1375 int n, h, v, x, y, c, j, linesize; | |
1376 n = s->nb_blocks[i]; | |
1377 c = s->comp_index[i]; | |
1378 h = s->h_scount[i]; | |
1379 v = s->v_scount[i]; | |
1380 x = 0; | |
1381 y = 0; | |
1382 linesize= s->linesize[c]; | |
1383 | |
1384 for(j=0; j<n; j++) { | |
1385 int pred; | |
1386 | |
1513 | 1387 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap |
1359 | 1388 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); |
1389 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); | |
1390 if (++x == h) { | |
1391 x = 0; | |
1392 y++; | |
1393 } | |
1394 } | |
1395 } | |
1396 } | |
1397 if (s->restart_interval && !--s->restart_count) { | |
1398 align_get_bits(&s->gb); | |
1399 skip_bits(&s->gb, 16); /* skip RSTn */ | |
1400 } | |
1401 } | |
1402 } | |
1403 return 0; | |
1404 } | |
1405 | |
1406 static int mjpeg_decode_scan(MJpegDecodeContext *s){ | |
1407 int i, mb_x, mb_y; | |
1408 const int nb_components=3; | |
1409 | |
1410 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
1411 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1412 if (s->restart_interval && !s->restart_count) | |
1413 s->restart_count = s->restart_interval; | |
1414 | |
1415 for(i=0;i<nb_components;i++) { | |
1416 uint8_t *ptr; | |
1417 int n, h, v, x, y, c, j; | |
1418 n = s->nb_blocks[i]; | |
1419 c = s->comp_index[i]; | |
1420 h = s->h_scount[i]; | |
1421 v = s->v_scount[i]; | |
1422 x = 0; | |
1423 y = 0; | |
1424 for(j=0;j<n;j++) { | |
1425 memset(s->block, 0, sizeof(s->block)); | |
1426 if (decode_block(s, s->block, i, | |
1427 s->dc_index[i], s->ac_index[i], | |
1428 s->quant_index[c]) < 0) { | |
1429 dprintf("error y=%d x=%d\n", mb_y, mb_x); | |
1430 return -1; | |
1431 } | |
1432 // dprintf("mb: %d %d processed\n", mb_y, mb_x); | |
1513 | 1433 ptr = s->picture.data[c] + |
2258 | 1434 (((s->linesize[c] * (v * mb_y + y) * 8) + |
1435 (h * mb_x + x) * 8) >> s->avctx->lowres); | |
1359 | 1436 if (s->interlaced && s->bottom_field) |
1437 ptr += s->linesize[c] >> 1; | |
1994 | 1438 //av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8); |
1359 | 1439 s->idct_put(ptr, s->linesize[c], s->block); |
1440 if (++x == h) { | |
1441 x = 0; | |
1442 y++; | |
1443 } | |
1444 } | |
1445 } | |
1446 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */ | |
1447 if (s->restart_interval && (s->restart_interval < 1350) && | |
1448 !--s->restart_count) { | |
1449 align_get_bits(&s->gb); | |
1450 skip_bits(&s->gb, 16); /* skip RSTn */ | |
1451 for (i=0; i<nb_components; i++) /* reset dc */ | |
1452 s->last_dc[i] = 1024; | |
1453 } | |
1454 } | |
1455 } | |
1456 return 0; | |
1457 } | |
1458 | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1459 static int mjpeg_decode_sos(MJpegDecodeContext *s) |
23 | 1460 { |
1455 | 1461 int len, nb_components, i, h, v, predictor, point_transform; |
1359 | 1462 int vmax, hmax, index, id; |
1307 | 1463 const int block_size= s->lossless ? 1 : 8; |
1464 | |
23 | 1465 /* XXX: verify len field validity */ |
1466 len = get_bits(&s->gb, 16); | |
1467 nb_components = get_bits(&s->gb, 8); | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1468 if (len != 6+2*nb_components) |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1469 { |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1470 dprintf("decode_sos: invalid len (%d)\n", len); |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1471 return -1; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1472 } |
23 | 1473 /* XXX: only interleaved scan accepted */ |
1740
0c686b4cd576
grayscale mjpeg decoding support based upon a patch by (Leon Bottou (leonb))
michael
parents:
1679
diff
changeset
|
1474 if (nb_components != s->nb_components) |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1475 { |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1476 dprintf("decode_sos: components(%d) mismatch\n", nb_components); |
23 | 1477 return -1; |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1478 } |
23 | 1479 vmax = 0; |
1480 hmax = 0; | |
1481 for(i=0;i<nb_components;i++) { | |
26 | 1482 id = get_bits(&s->gb, 8) - 1; |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1483 dprintf("component: %d\n", id); |
26 | 1484 /* find component index */ |
1485 for(index=0;index<s->nb_components;index++) | |
1486 if (id == s->component_id[index]) | |
1487 break; | |
1488 if (index == s->nb_components) | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1489 { |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1490 dprintf("decode_sos: index(%d) out of components\n", index); |
23 | 1491 return -1; |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1492 } |
26 | 1493 |
1359 | 1494 s->comp_index[i] = index; |
1310 | 1495 |
1359 | 1496 s->nb_blocks[i] = s->h_count[index] * s->v_count[index]; |
1497 s->h_scount[i] = s->h_count[index]; | |
1498 s->v_scount[i] = s->v_count[index]; | |
28
b611fafddf9e
added 422P and 444P support - fixed block parsing error
glantau
parents:
26
diff
changeset
|
1499 |
1359 | 1500 s->dc_index[i] = get_bits(&s->gb, 4); |
1501 s->ac_index[i] = get_bits(&s->gb, 4); | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1502 |
1359 | 1503 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 || |
1504 s->dc_index[i] >= 4 || s->ac_index[i] >= 4) | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1505 goto out_of_range; |
1359 | 1506 #if 0 //buggy |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1507 switch(s->start_code) |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1508 { |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1509 case SOF0: |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1510 if (dc_index[i] > 1 || ac_index[i] > 1) |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1511 goto out_of_range; |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1512 break; |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1513 case SOF1: |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1514 case SOF2: |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1515 if (dc_index[i] > 3 || ac_index[i] > 3) |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1516 goto out_of_range; |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1517 break; |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1518 case SOF3: |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1519 if (dc_index[i] > 3 || ac_index[i] != 0) |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1520 goto out_of_range; |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1521 break; |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1522 } |
1359 | 1523 #endif |
23 | 1524 } |
1310 | 1525 |
1307 | 1526 predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */ |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1527 skip_bits(&s->gb, 8); /* Se */ |
1307 | 1528 skip_bits(&s->gb, 4); /* Ah */ |
1529 point_transform= get_bits(&s->gb, 4); /* Al */ | |
23 | 1530 |
1531 for(i=0;i<nb_components;i++) | |
1532 s->last_dc[i] = 1024; | |
1533 | |
1534 if (nb_components > 1) { | |
1535 /* interleaved stream */ | |
1359 | 1536 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size); |
1537 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size); | |
23 | 1538 } else { |
1359 | 1539 h = s->h_max / s->h_scount[s->comp_index[0]]; |
1540 v = s->v_max / s->v_scount[s->comp_index[0]]; | |
1541 s->mb_width = (s->width + h * block_size - 1) / (h * block_size); | |
1542 s->mb_height = (s->height + v * block_size - 1) / (v * block_size); | |
1543 s->nb_blocks[0] = 1; | |
1544 s->h_scount[0] = 1; | |
1545 s->v_scount[0] = 1; | |
23 | 1546 } |
1307 | 1547 |
1310 | 1548 if(s->avctx->debug & FF_DEBUG_PICT_INFO) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1549 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform); |
1310 | 1550 |
2333
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
1551 /* mjpeg-b can have padding bytes between sos and image data, skip them */ |
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
1552 for (i = s->mjpb_skiptosod; i > 0; i--) |
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
1553 skip_bits(&s->gb, 8); |
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
1554 |
1307 | 1555 if(s->lossless){ |
1359 | 1556 if(s->rgb){ |
1557 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0) | |
1558 return -1; | |
1559 }else{ | |
1560 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0) | |
1561 return -1; | |
1307 | 1562 } |
1563 }else{ | |
1359 | 1564 if(mjpeg_decode_scan(s) < 0) |
1565 return -1; | |
23 | 1566 } |
44
92d51f683931
added forgotten emms() - fix various segmentation faults when using mjpeg
glantau
parents:
37
diff
changeset
|
1567 emms_c(); |
1359 | 1568 return 0; |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1569 out_of_range: |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1570 dprintf("decode_sos: ac/dc index out of range\n"); |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1571 return -1; |
23 | 1572 } |
1573 | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1574 static int mjpeg_decode_dri(MJpegDecodeContext *s) |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1575 { |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1576 if (get_bits(&s->gb, 16) != 4) |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1577 return -1; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1578 s->restart_interval = get_bits(&s->gb, 16); |
507
b5b91e89b88c
* turned into debug message - it's annoying when watching mjpeg files
kabi
parents:
477
diff
changeset
|
1579 dprintf("restart interval: %d\n", s->restart_interval); |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1580 |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1581 return 0; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1582 } |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1583 |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1584 static int mjpeg_decode_app(MJpegDecodeContext *s) |
354 | 1585 { |
1586 int len, id; | |
1587 | |
1588 /* XXX: verify len field validity */ | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1589 len = get_bits(&s->gb, 16); |
354 | 1590 if (len < 5) |
1591 return -1; | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1592 |
811 | 1593 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16); |
1594 id = be2me_32(id); | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1595 len -= 6; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1596 |
1310 | 1597 if(s->avctx->debug & FF_DEBUG_STARTCODE){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1598 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); |
1310 | 1599 } |
1600 | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1601 /* buggy AVID, it puts EOI only at every 10th frame */ |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1602 /* also this fourcc is used by non-avid files too, it holds some |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1603 informations, but it's always present in AVID creates files */ |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1604 if (id == ff_get_fourcc("AVI1")) |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1605 { |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1606 /* structure: |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1607 4bytes AVI1 |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1608 1bytes polarity |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1609 1bytes always zero |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1610 4bytes field_size |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1611 4bytes field_size_less_padding |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1612 */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1613 s->buggy_avid = 1; |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1614 // if (s->first_picture) |
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1615 // printf("mjpeg: workarounding buggy AVID\n"); |
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1616 s->interlace_polarity = get_bits(&s->gb, 8); |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1617 #if 0 |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1618 skip_bits(&s->gb, 8); |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1619 skip_bits(&s->gb, 32); |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1620 skip_bits(&s->gb, 32); |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1621 len -= 10; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1622 #endif |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1623 // if (s->interlace_polarity) |
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1624 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity); |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1625 goto out; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1626 } |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1627 |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1628 // len -= 2; |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1629 |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1630 if (id == ff_get_fourcc("JFIF")) |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1631 { |
1911 | 1632 int t_w, t_h, v1, v2; |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1633 skip_bits(&s->gb, 8); /* the trailing zero-byte */ |
1911 | 1634 v1= get_bits(&s->gb, 8); |
1635 v2= get_bits(&s->gb, 8); | |
1548 | 1636 skip_bits(&s->gb, 8); |
903 | 1637 |
1548 | 1638 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16); |
1639 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16); | |
935 | 1640 |
1911 | 1641 if (s->avctx->debug & FF_DEBUG_PICT_INFO) |
1642 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n", | |
1643 v1, v2, | |
1644 s->avctx->sample_aspect_ratio.num, | |
1645 s->avctx->sample_aspect_ratio.den | |
1646 ); | |
1647 | |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1648 t_w = get_bits(&s->gb, 8); |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1649 t_h = get_bits(&s->gb, 8); |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1650 if (t_w && t_h) |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1651 { |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1652 /* skip thumbnail */ |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1653 if (len-10-(t_w*t_h*3) > 0) |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1654 len -= t_w*t_h*3; |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1655 } |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1656 len -= 10; |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1657 goto out; |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1658 } |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1659 |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1660 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e')) |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1661 { |
1906
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1662 if (s->avctx->debug & FF_DEBUG_PICT_INFO) |
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1663 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n"); |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1664 skip_bits(&s->gb, 16); /* version */ |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1665 skip_bits(&s->gb, 16); /* flags0 */ |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1666 skip_bits(&s->gb, 16); /* flags1 */ |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1667 skip_bits(&s->gb, 8); /* transform */ |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1668 len -= 7; |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1669 goto out; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1670 } |
1310 | 1671 |
1672 if (id == ff_get_fourcc("LJIF")){ | |
1906
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1673 if (s->avctx->debug & FF_DEBUG_PICT_INFO) |
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1674 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n"); |
1310 | 1675 skip_bits(&s->gb, 16); /* version ? */ |
1676 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
1677 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
1678 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
1679 switch( get_bits(&s->gb, 8)){ | |
1680 case 1: | |
1681 s->rgb= 1; | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
1682 s->pegasus_rct=0; |
1310 | 1683 break; |
1684 case 2: | |
1685 s->rgb= 1; | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
1686 s->pegasus_rct=1; |
1310 | 1687 break; |
1688 default: | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1689 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n"); |
1310 | 1690 } |
1691 len -= 9; | |
1692 goto out; | |
1693 } | |
354 | 1694 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1695 /* Apple MJPEG-A */ |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1696 if ((s->start_code == APP1) && (len > (0x28 - 8))) |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1697 { |
811 | 1698 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16); |
1699 id = be2me_32(id); | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1700 len -= 4; |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1701 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */ |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1702 { |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1703 #if 0 |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1704 skip_bits(&s->gb, 32); /* field size */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1705 skip_bits(&s->gb, 32); /* pad field size */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1706 skip_bits(&s->gb, 32); /* next off */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1707 skip_bits(&s->gb, 32); /* quant off */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1708 skip_bits(&s->gb, 32); /* huff off */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1709 skip_bits(&s->gb, 32); /* image off */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1710 skip_bits(&s->gb, 32); /* scan off */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1711 skip_bits(&s->gb, 32); /* data off */ |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1712 #endif |
1906
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1713 if (s->avctx->debug & FF_DEBUG_PICT_INFO) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1714 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n"); |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1715 } |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1716 } |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1717 |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1718 out: |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1719 /* slow but needed for extreme adobe jpegs */ |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1720 if (len < 0) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1721 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n"); |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1722 while(--len > 0) |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1723 skip_bits(&s->gb, 8); |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1724 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1725 return 0; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1726 } |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1727 |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1728 static int mjpeg_decode_com(MJpegDecodeContext *s) |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1729 { |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1730 /* XXX: verify len field validity */ |
1322 | 1731 int len = get_bits(&s->gb, 16); |
1061 | 1732 if (len >= 2 && len < 32768) { |
1733 /* XXX: any better upper bound */ | |
1064 | 1734 uint8_t *cbuf = av_malloc(len - 1); |
1061 | 1735 if (cbuf) { |
1736 int i; | |
1737 for (i = 0; i < len - 2; i++) | |
1738 cbuf[i] = get_bits(&s->gb, 8); | |
1739 if (i > 0 && cbuf[i-1] == '\n') | |
1740 cbuf[i-1] = 0; | |
1741 else | |
1742 cbuf[i] = 0; | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1743 |
1911 | 1744 if(s->avctx->debug & FF_DEBUG_PICT_INFO) |
1745 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf); | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1746 |
1061 | 1747 /* buggy avid, it puts EOI only at every 10th frame */ |
1748 if (!strcmp(cbuf, "AVID")) | |
1749 { | |
1750 s->buggy_avid = 1; | |
1751 // if (s->first_picture) | |
1752 // printf("mjpeg: workarounding buggy AVID\n"); | |
1753 } | |
2442 | 1754 else if(!strcmp(cbuf, "CS=ITU601")){ |
1755 s->cs_itu601= 1; | |
1756 } | |
1061 | 1757 |
1758 av_free(cbuf); | |
1759 } | |
354 | 1760 } |
1761 | |
1762 return 0; | |
1763 } | |
1764 | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1765 #if 0 |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1766 static int valid_marker_list[] = |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1767 { |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1768 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */ |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1769 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1770 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1771 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1772 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1773 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1774 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1775 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1776 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1777 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1778 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1779 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1780 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1781 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1782 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1783 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1784 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1785 } |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1786 #endif |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1787 |
23 | 1788 /* return the 8 bit start code value and update the search |
1789 state. Return -1 if no start code found */ | |
1064 | 1790 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end) |
23 | 1791 { |
1064 | 1792 uint8_t *buf_ptr; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1793 unsigned int v, v2; |
23 | 1794 int val; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1795 #ifdef DEBUG |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1796 int skipped=0; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1797 #endif |
23 | 1798 |
1799 buf_ptr = *pbuf_ptr; | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1800 while (buf_ptr < buf_end) { |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1801 v = *buf_ptr++; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1802 v2 = *buf_ptr; |
1619 | 1803 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) { |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1804 val = *buf_ptr++; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1805 goto found; |
23 | 1806 } |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1807 #ifdef DEBUG |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1808 skipped++; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1809 #endif |
23 | 1810 } |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1811 val = -1; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1812 found: |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1813 #ifdef DEBUG |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1814 dprintf("find_marker skipped %d bytes\n", skipped); |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1815 #endif |
23 | 1816 *pbuf_ptr = buf_ptr; |
1817 return val; | |
1818 } | |
1819 | |
1820 static int mjpeg_decode_frame(AVCodecContext *avctx, | |
1821 void *data, int *data_size, | |
1064 | 1822 uint8_t *buf, int buf_size) |
23 | 1823 { |
1824 MJpegDecodeContext *s = avctx->priv_data; | |
1064 | 1825 uint8_t *buf_end, *buf_ptr; |
1519 | 1826 int start_code; |
1358 | 1827 AVFrame *picture = data; |
23 | 1828 |
1829 buf_ptr = buf; | |
1830 buf_end = buf + buf_size; | |
1831 while (buf_ptr < buf_end) { | |
1832 /* find start next marker */ | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1833 start_code = find_marker(&buf_ptr, buf_end); |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1834 { |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1835 /* EOF */ |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1836 if (start_code < 0) { |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1837 goto the_end; |
354 | 1838 } else { |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1839 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr); |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1840 |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1841 if ((buf_end - buf_ptr) > s->buffer_size) |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1842 { |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1843 av_free(s->buffer); |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1844 s->buffer_size = buf_end-buf_ptr; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1845 s->buffer = av_malloc(s->buffer_size); |
786
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1846 dprintf("buffer too small, expanding to %d bytes\n", |
62faac9a4c3d
FOURCC removed, using ff_get_fourcc instead (should be big-endian safe), workarounded a restart interval bug (Spectralfan.mov) (rst support should be rewritten and moved from decode_sos)
al3x
parents:
780
diff
changeset
|
1847 s->buffer_size); |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1848 } |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1849 |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1850 /* unescape buffer of SOS */ |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1851 if (start_code == SOS) |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1852 { |
1064 | 1853 uint8_t *src = buf_ptr; |
1854 uint8_t *dst = s->buffer; | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1855 |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1856 while (src<buf_end) |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1857 { |
1064 | 1858 uint8_t x = *(src++); |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1859 |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1860 *(dst++) = x; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1861 if (x == 0xff) |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1862 { |
2360
0fcb4d572719
workaround apps which dont provided correctly padded streams
michael
parents:
2333
diff
changeset
|
1863 while(src<buf_end && x == 0xff) |
0fcb4d572719
workaround apps which dont provided correctly padded streams
michael
parents:
2333
diff
changeset
|
1864 x = *(src++); |
840 | 1865 |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1866 if (x >= 0xd0 && x <= 0xd7) |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1867 *(dst++) = x; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1868 else if (x) |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1869 break; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1870 } |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1871 } |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
949
diff
changeset
|
1872 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8); |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1873 |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1874 dprintf("escaping removed %d bytes\n", |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1875 (buf_end - buf_ptr) - (dst - s->buffer)); |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1876 } |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1877 else |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
949
diff
changeset
|
1878 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8); |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1879 |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1880 s->start_code = start_code; |
1310 | 1881 if(s->avctx->debug & FF_DEBUG_STARTCODE){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1882 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code); |
1310 | 1883 } |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1884 |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1885 /* process markers */ |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1886 if (start_code >= 0xd0 && start_code <= 0xd7) { |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1887 dprintf("restart marker: %d\n", start_code&0x0f); |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1888 /* APP fields */ |
1906
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1889 } else if (start_code >= APP0 && start_code <= APP15) { |
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1890 mjpeg_decode_app(s); |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1891 /* Comment */ |
1906
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1892 } else if (start_code == COM){ |
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1893 mjpeg_decode_com(s); |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1894 } |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1895 |
23 | 1896 switch(start_code) { |
1897 case SOI: | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1898 s->restart_interval = 0; |
23 | 1899 /* nothing to do on SOI */ |
1900 break; | |
1901 case DQT: | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1902 mjpeg_decode_dqt(s); |
23 | 1903 break; |
1904 case DHT: | |
1351 | 1905 if(mjpeg_decode_dht(s) < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1906 av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n"); |
1351 | 1907 return -1; |
1908 } | |
23 | 1909 break; |
1910 case SOF0: | |
1307 | 1911 s->lossless=0; |
1912 if (mjpeg_decode_sof(s) < 0) | |
1913 return -1; | |
1914 break; | |
1915 case SOF3: | |
1916 s->lossless=1; | |
1917 if (mjpeg_decode_sof(s) < 0) | |
901 | 1918 return -1; |
23 | 1919 break; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1920 case EOI: |
1358 | 1921 if ((s->buggy_avid && !s->interlaced) || s->restart_interval) |
1922 break; | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1923 eoi_parser: |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1924 { |
53 | 1925 if (s->interlaced) { |
1926 s->bottom_field ^= 1; | |
1927 /* if not bottom field, do not output image yet */ | |
1928 if (s->bottom_field) | |
540
4cee7ce37e10
don't exit decoder after decoding first field -> fixes angels.avi interlacing
arpi_esp
parents:
527
diff
changeset
|
1929 goto not_the_end; |
53 | 1930 } |
1513 | 1931 *picture = s->picture; |
1358 | 1932 *data_size = sizeof(AVFrame); |
1933 | |
1934 if(!s->lossless){ | |
1935 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); | |
1936 picture->qstride= 0; | |
1937 picture->qscale_table= s->qscale_table; | |
1938 memset(picture->qscale_table, picture->quality, (s->width+15)/16); | |
1939 if(avctx->debug & FF_DEBUG_QP) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1940 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality); |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
1941 picture->quality*= FF_QP2LAMBDA; |
1358 | 1942 } |
1943 | |
23 | 1944 goto the_end; |
1945 } | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1946 break; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1947 case SOS: |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1948 mjpeg_decode_sos(s); |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1949 /* buggy avid puts EOI every 10-20th frame */ |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1950 /* if restart period is over process EOI */ |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1951 if ((s->buggy_avid && !s->interlaced) || s->restart_interval) |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1952 goto eoi_parser; |
23 | 1953 break; |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1954 case DRI: |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1955 mjpeg_decode_dri(s); |
354 | 1956 break; |
1957 case SOF1: | |
1958 case SOF2: | |
1959 case SOF5: | |
1960 case SOF6: | |
1961 case SOF7: | |
1962 case SOF9: | |
1963 case SOF10: | |
1964 case SOF11: | |
1965 case SOF13: | |
1966 case SOF14: | |
1967 case SOF15: | |
1968 case JPG: | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1969 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code); |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1970 break; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1971 // default: |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1972 // printf("mjpeg: unsupported marker (%x)\n", start_code); |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1973 // break; |
23 | 1974 } |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1975 |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1976 not_the_end: |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1977 /* eof process start code */ |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1978 buf_ptr += (get_bits_count(&s->gb)+7)/8; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1979 dprintf("marker parser used %d bytes (%d bits)\n", |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1980 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb)); |
23 | 1981 } |
1982 } | |
1983 } | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1984 the_end: |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1985 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr); |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1986 // return buf_end - buf_ptr; |
23 | 1987 return buf_ptr - buf; |
1988 } | |
1989 | |
881 | 1990 static int mjpegb_decode_frame(AVCodecContext *avctx, |
1991 void *data, int *data_size, | |
1064 | 1992 uint8_t *buf, int buf_size) |
881 | 1993 { |
1994 MJpegDecodeContext *s = avctx->priv_data; | |
1064 | 1995 uint8_t *buf_end, *buf_ptr; |
1358 | 1996 AVFrame *picture = data; |
881 | 1997 GetBitContext hgb; /* for the header */ |
1998 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs; | |
2333
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
1999 uint32_t field_size, sod_offs; |
881 | 2000 |
2001 buf_ptr = buf; | |
2002 buf_end = buf + buf_size; | |
2003 | |
2004 read_header: | |
2005 /* reset on every SOI */ | |
2006 s->restart_interval = 0; | |
2333
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
2007 s->mjpb_skiptosod = 0; |
881 | 2008 |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
949
diff
changeset
|
2009 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8); |
881 | 2010 |
2011 skip_bits(&hgb, 32); /* reserved zeros */ | |
2012 | |
2173 | 2013 if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg"))) |
881 | 2014 { |
2015 dprintf("not mjpeg-b (bad fourcc)\n"); | |
2016 return 0; | |
2017 } | |
2018 | |
2173 | 2019 field_size = get_bits_long(&hgb, 32); /* field size */ |
881 | 2020 dprintf("field size: 0x%x\n", field_size); |
2021 skip_bits(&hgb, 32); /* padded field size */ | |
2173 | 2022 second_field_offs = get_bits_long(&hgb, 32); |
881 | 2023 dprintf("second field offs: 0x%x\n", second_field_offs); |
2024 if (second_field_offs) | |
2025 s->interlaced = 1; | |
2026 | |
2173 | 2027 dqt_offs = get_bits_long(&hgb, 32); |
881 | 2028 dprintf("dqt offs: 0x%x\n", dqt_offs); |
2029 if (dqt_offs) | |
2030 { | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
949
diff
changeset
|
2031 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8); |
881 | 2032 s->start_code = DQT; |
2033 mjpeg_decode_dqt(s); | |
2034 } | |
2035 | |
2173 | 2036 dht_offs = get_bits_long(&hgb, 32); |
881 | 2037 dprintf("dht offs: 0x%x\n", dht_offs); |
2038 if (dht_offs) | |
2039 { | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
949
diff
changeset
|
2040 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8); |
881 | 2041 s->start_code = DHT; |
2042 mjpeg_decode_dht(s); | |
2043 } | |
2044 | |
2173 | 2045 sof_offs = get_bits_long(&hgb, 32); |
881 | 2046 dprintf("sof offs: 0x%x\n", sof_offs); |
2047 if (sof_offs) | |
2048 { | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
949
diff
changeset
|
2049 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8); |
881 | 2050 s->start_code = SOF0; |
1307 | 2051 if (mjpeg_decode_sof(s) < 0) |
901 | 2052 return -1; |
881 | 2053 } |
2054 | |
2173 | 2055 sos_offs = get_bits_long(&hgb, 32); |
881 | 2056 dprintf("sos offs: 0x%x\n", sos_offs); |
2333
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
2057 sod_offs = get_bits_long(&hgb, 32); |
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
2058 dprintf("sod offs: 0x%x\n", sod_offs); |
881 | 2059 if (sos_offs) |
2060 { | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
949
diff
changeset
|
2061 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8); |
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
949
diff
changeset
|
2062 init_get_bits(&s->gb, buf+sos_offs, field_size*8); |
2333
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
2063 s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16)); |
881 | 2064 s->start_code = SOS; |
2065 mjpeg_decode_sos(s); | |
2066 } | |
2067 | |
2068 if (s->interlaced) { | |
2069 s->bottom_field ^= 1; | |
2070 /* if not bottom field, do not output image yet */ | |
2071 if (s->bottom_field && second_field_offs) | |
2072 { | |
2073 buf_ptr = buf + second_field_offs; | |
2074 second_field_offs = 0; | |
2075 goto read_header; | |
2076 } | |
2077 } | |
2078 | |
1358 | 2079 //XXX FIXME factorize, this looks very similar to the EOI code |
1513 | 2080 |
2081 *picture= s->picture; | |
1358 | 2082 *data_size = sizeof(AVFrame); |
2083 | |
2084 if(!s->lossless){ | |
2085 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); | |
2086 picture->qstride= 0; | |
2087 picture->qscale_table= s->qscale_table; | |
2088 memset(picture->qscale_table, picture->quality, (s->width+15)/16); | |
2089 if(avctx->debug & FF_DEBUG_QP) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
2090 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality); |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1455
diff
changeset
|
2091 picture->quality*= FF_QP2LAMBDA; |
1358 | 2092 } |
881 | 2093 |
2094 return buf_ptr - buf; | |
2095 } | |
2096 | |
1519 | 2097 #include "sp5x.h" |
2098 | |
2099 static int sp5x_decode_frame(AVCodecContext *avctx, | |
2100 void *data, int *data_size, | |
2101 uint8_t *buf, int buf_size) | |
2102 { | |
2103 #if 0 | |
2104 MJpegDecodeContext *s = avctx->priv_data; | |
2105 #endif | |
2106 const int qscale = 5; | |
2107 uint8_t *buf_ptr, *buf_end, *recoded; | |
2108 int i = 0, j = 0; | |
2109 | |
2110 if (!avctx->width || !avctx->height) | |
2111 return -1; | |
2112 | |
2113 buf_ptr = buf; | |
2114 buf_end = buf + buf_size; | |
2115 | |
2116 #if 1 | |
2117 recoded = av_mallocz(buf_size + 1024); | |
2118 if (!recoded) | |
2119 return -1; | |
2120 | |
2121 /* SOI */ | |
2122 recoded[j++] = 0xFF; | |
2123 recoded[j++] = 0xD8; | |
2124 | |
2125 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt)); | |
2126 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64); | |
2127 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64); | |
2128 j += sizeof(sp5x_data_dqt); | |
2129 | |
2130 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht)); | |
2131 j += sizeof(sp5x_data_dht); | |
2132 | |
2133 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof)); | |
2270 | 2134 recoded[j+5] = (avctx->coded_height >> 8) & 0xFF; |
2135 recoded[j+6] = avctx->coded_height & 0xFF; | |
2136 recoded[j+7] = (avctx->coded_width >> 8) & 0xFF; | |
2137 recoded[j+8] = avctx->coded_width & 0xFF; | |
1519 | 2138 j += sizeof(sp5x_data_sof); |
2139 | |
2140 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos)); | |
2141 j += sizeof(sp5x_data_sos); | |
2142 | |
1548 | 2143 for (i = 14; i < buf_size && j < buf_size+1024-2; i++) |
1519 | 2144 { |
2145 recoded[j++] = buf[i]; | |
2146 if (buf[i] == 0xff) | |
2147 recoded[j++] = 0; | |
2148 } | |
2149 | |
2150 /* EOI */ | |
2151 recoded[j++] = 0xFF; | |
2152 recoded[j++] = 0xD9; | |
2153 | |
2154 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j); | |
2155 | |
2156 av_free(recoded); | |
2157 | |
2158 #else | |
2159 /* SOF */ | |
2160 s->bits = 8; | |
2270 | 2161 s->width = avctx->coded_width; |
2162 s->height = avctx->coded_height; | |
1519 | 2163 s->nb_components = 3; |
2164 s->component_id[0] = 0; | |
2165 s->h_count[0] = 2; | |
2166 s->v_count[0] = 2; | |
2167 s->quant_index[0] = 0; | |
2168 s->component_id[1] = 1; | |
2169 s->h_count[1] = 1; | |
2170 s->v_count[1] = 1; | |
2171 s->quant_index[1] = 1; | |
2172 s->component_id[2] = 2; | |
2173 s->h_count[2] = 1; | |
2174 s->v_count[2] = 1; | |
2175 s->quant_index[2] = 1; | |
2176 s->h_max = 2; | |
2177 s->v_max = 2; | |
2178 | |
2179 s->qscale_table = av_mallocz((s->width+15)/16); | |
2442 | 2180 avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420; |
1519 | 2181 s->interlaced = 0; |
2182 | |
2183 s->picture.reference = 0; | |
2184 if (avctx->get_buffer(avctx, &s->picture) < 0) | |
2185 { | |
2186 fprintf(stderr, "get_buffer() failed\n"); | |
2187 return -1; | |
2188 } | |
2189 | |
2190 s->picture.pict_type = I_TYPE; | |
2191 s->picture.key_frame = 1; | |
2192 | |
2193 for (i = 0; i < 3; i++) | |
2194 s->linesize[i] = s->picture.linesize[i] << s->interlaced; | |
2195 | |
2196 /* DQT */ | |
2197 for (i = 0; i < 64; i++) | |
2198 { | |
2199 j = s->scantable.permutated[i]; | |
2200 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i]; | |
2201 } | |
2202 s->qscale[0] = FFMAX( | |
2203 s->quant_matrixes[0][s->scantable.permutated[1]], | |
2204 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1; | |
2205 | |
2206 for (i = 0; i < 64; i++) | |
2207 { | |
2208 j = s->scantable.permutated[i]; | |
2209 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i]; | |
2210 } | |
2211 s->qscale[1] = FFMAX( | |
2212 s->quant_matrixes[1][s->scantable.permutated[1]], | |
2213 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1; | |
2214 | |
2215 /* DHT */ | |
2216 | |
2217 /* SOS */ | |
2218 s->comp_index[0] = 0; | |
2219 s->nb_blocks[0] = s->h_count[0] * s->v_count[0]; | |
2220 s->h_scount[0] = s->h_count[0]; | |
2221 s->v_scount[0] = s->v_count[0]; | |
2222 s->dc_index[0] = 0; | |
2223 s->ac_index[0] = 0; | |
2224 | |
2225 s->comp_index[1] = 1; | |
2226 s->nb_blocks[1] = s->h_count[1] * s->v_count[1]; | |
2227 s->h_scount[1] = s->h_count[1]; | |
2228 s->v_scount[1] = s->v_count[1]; | |
2229 s->dc_index[1] = 1; | |
2230 s->ac_index[1] = 1; | |
2231 | |
2232 s->comp_index[2] = 2; | |
2233 s->nb_blocks[2] = s->h_count[2] * s->v_count[2]; | |
2234 s->h_scount[2] = s->h_count[2]; | |
2235 s->v_scount[2] = s->v_count[2]; | |
2236 s->dc_index[2] = 1; | |
2237 s->ac_index[2] = 1; | |
2238 | |
2239 for (i = 0; i < 3; i++) | |
2240 s->last_dc[i] = 1024; | |
2241 | |
2242 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8); | |
2243 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8); | |
2244 | |
1560 | 2245 init_get_bits(&s->gb, buf+14, (buf_size-14)*8); |
1519 | 2246 |
2247 return mjpeg_decode_scan(s); | |
2248 #endif | |
2249 | |
2250 return i; | |
2251 } | |
881 | 2252 |
23 | 2253 static int mjpeg_decode_end(AVCodecContext *avctx) |
2254 { | |
2255 MJpegDecodeContext *s = avctx->priv_data; | |
2256 int i, j; | |
2257 | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2258 av_free(s->buffer); |
1358 | 2259 av_free(s->qscale_table); |
1513 | 2260 |
23 | 2261 for(i=0;i<2;i++) { |
2262 for(j=0;j<4;j++) | |
2263 free_vlc(&s->vlcs[i][j]); | |
2264 } | |
2265 return 0; | |
2266 } | |
2267 | |
2268 AVCodec mjpeg_decoder = { | |
2269 "mjpeg", | |
2270 CODEC_TYPE_VIDEO, | |
2271 CODEC_ID_MJPEG, | |
2272 sizeof(MJpegDecodeContext), | |
2273 mjpeg_decode_init, | |
2274 NULL, | |
2275 mjpeg_decode_end, | |
2276 mjpeg_decode_frame, | |
1513 | 2277 CODEC_CAP_DR1, |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
2278 NULL |
23 | 2279 }; |
881 | 2280 |
2281 AVCodec mjpegb_decoder = { | |
2282 "mjpegb", | |
2283 CODEC_TYPE_VIDEO, | |
2284 CODEC_ID_MJPEGB, | |
2285 sizeof(MJpegDecodeContext), | |
2286 mjpeg_decode_init, | |
2287 NULL, | |
2288 mjpeg_decode_end, | |
2289 mjpegb_decode_frame, | |
1513 | 2290 CODEC_CAP_DR1, |
881 | 2291 NULL |
2292 }; | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2293 |
1519 | 2294 AVCodec sp5x_decoder = { |
2295 "sp5x", | |
2296 CODEC_TYPE_VIDEO, | |
2297 CODEC_ID_SP5X, | |
2298 sizeof(MJpegDecodeContext), | |
2299 mjpeg_decode_init, | |
2300 NULL, | |
2301 mjpeg_decode_end, | |
2302 sp5x_decode_frame, | |
2303 CODEC_CAP_DR1, | |
2304 NULL | |
2305 }; | |
2306 | |
1325 | 2307 #ifdef CONFIG_ENCODERS |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2308 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2309 "ljpeg", |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2310 CODEC_TYPE_VIDEO, |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2311 CODEC_ID_LJPEG, |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2312 sizeof(MpegEncContext), |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2313 MPV_encode_init, |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2314 encode_picture_lossless, |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2315 MPV_encode_end, |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2316 }; |
1325 | 2317 #endif |
2319 | 2318 |
2319 AVCodecParser mjpeg_parser = { | |
2320 { CODEC_ID_MJPEG }, | |
2321 sizeof(ParseContext), | |
2322 NULL, | |
2323 jpeg_parse, | |
2324 ff_parse_close, | |
2325 }; | |
2326 |