Mercurial > libavcodec.hg
annotate mjpeg.c @ 3308:57078a058b96 libavcodec
fix compilation of 3dnowext instinsincs, both on ia32 and AMD64.
3dnow intrinsincs are for now only compiled if 3dnowext support is available. (I should add smth that
checks for plain 3dnow later)
author | gpoirier |
---|---|
date | Tue, 16 May 2006 14:24:45 +0000 |
parents | 498543867d57 |
children | 9a6bbda8cf7e |
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 | |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 */ | |
2967 | 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 { |
2967 | 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 */ |
2979 | 57 SOF0 = 0xc0, /* baseline */ |
58 SOF1 = 0xc1, /* extended sequential, huffman */ | |
59 SOF2 = 0xc2, /* progressive, huffman */ | |
60 SOF3 = 0xc3, /* lossless, huffman */ | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
61 |
2979 | 62 SOF5 = 0xc5, /* differential sequential, huffman */ |
63 SOF6 = 0xc6, /* differential progressive, huffman */ | |
64 SOF7 = 0xc7, /* differential lossless, huffman */ | |
65 JPG = 0xc8, /* reserved for JPEG extension */ | |
66 SOF9 = 0xc9, /* extended sequential, arithmetic */ | |
67 SOF10 = 0xca, /* progressive, arithmetic */ | |
68 SOF11 = 0xcb, /* lossless, arithmetic */ | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
69 |
2979 | 70 SOF13 = 0xcd, /* differential sequential, arithmetic */ |
71 SOF14 = 0xce, /* differential progressive, arithmetic */ | |
72 SOF15 = 0xcf, /* differential lossless, arithmetic */ | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
73 |
2979 | 74 DHT = 0xc4, /* define huffman tables */ |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
75 |
2979 | 76 DAC = 0xcc, /* define arithmetic-coding conditioning */ |
349
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 |
2979 | 88 SOI = 0xd8, /* start of image */ |
89 EOI = 0xd9, /* end of image */ | |
90 SOS = 0xda, /* start of scan */ | |
91 DQT = 0xdb, /* define quantization tables */ | |
92 DNL = 0xdc, /* define number of lines */ | |
93 DRI = 0xdd, /* define restart interval */ | |
94 DHP = 0xde, /* define hierarchical progression */ | |
95 EXP = 0xdf, /* expand reference components */ | |
349
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, |
2979 | 121 SOF48 = 0xf7, ///< JPEG-LS |
122 LSE = 0xf8, ///< JPEG-LS extension parameters | |
349
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 |
2979 | 129 COM = 0xfe, /* comment */ |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
130 |
2979 | 131 TEM = 0x01, /* temporary private use for arithmetic coding */ |
349
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, | |
2967 | 198 0xf9, 0xfa |
0 | 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, | |
2967 | 225 0xf9, 0xfa |
0 | 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; | |
2967 | 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; | |
2967 | 256 |
344 | 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); | |
2967 | 277 |
0 | 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); | |
2967 | 365 |
0 | 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); |
2885
5dfb90019814
Rename put_string to ff_put_string to avoid a symbol clash on Mac OS X.
diego
parents:
2846
diff
changeset
|
383 ff_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 */ | |
2885
5dfb90019814
Rename put_string to ff_put_string to avoid a symbol clash on Mac OS X.
diego
parents:
2846
diff
changeset
|
398 ff_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 |
2967 | 404 if( s->avctx->pix_fmt == PIX_FMT_YUV420P |
2442 | 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 */ | |
2885
5dfb90019814
Rename put_string to ff_put_string to avoid a symbol clash on Mac OS X.
diego
parents:
2846
diff
changeset
|
411 ff_put_string(p, "CS=ITU601", 1); |
2442 | 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 { | |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
420 const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
421 const int ls = s->avctx->codec_id == CODEC_ID_JPEGLS; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
422 |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
423 assert(!(ls && s->mjpeg_write_tables)); |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
424 |
0 | 425 put_marker(&s->pb, SOI); |
426 | |
370
0eca28d16cbd
clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents:
369
diff
changeset
|
427 if (!s->mjpeg_data_only_frames) |
0eca28d16cbd
clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents:
369
diff
changeset
|
428 { |
2967 | 429 jpeg_put_comments(s); |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
430 |
229 | 431 if (s->mjpeg_write_tables) jpeg_table_header(s); |
0 | 432 |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
433 switch(s->avctx->codec_id){ |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
434 case CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
435 case CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
436 case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
437 default: assert(0); |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
438 } |
0 | 439 |
440 put_bits(&s->pb, 16, 17); | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
441 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32) |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
442 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
|
443 else |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
444 put_bits(&s->pb, 8, 8); /* 8 bits/component */ |
0 | 445 put_bits(&s->pb, 16, s->height); |
446 put_bits(&s->pb, 16, s->width); | |
447 put_bits(&s->pb, 8, 3); /* 3 components */ | |
2967 | 448 |
0 | 449 /* Y component */ |
450 put_bits(&s->pb, 8, 1); /* component number */ | |
229 | 451 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */ |
452 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */ | |
0 | 453 put_bits(&s->pb, 8, 0); /* select matrix */ |
2967 | 454 |
0 | 455 /* Cb component */ |
456 put_bits(&s->pb, 8, 2); /* component number */ | |
229 | 457 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */ |
458 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
|
459 #ifdef TWOMATRIXES |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
460 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
|
461 #else |
0 | 462 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
|
463 #endif |
0 | 464 |
465 /* Cr component */ | |
466 put_bits(&s->pb, 8, 3); /* component number */ | |
229 | 467 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */ |
468 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
|
469 #ifdef TWOMATRIXES |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
470 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
|
471 #else |
0 | 472 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
|
473 #endif |
370
0eca28d16cbd
clamp intra matrix to 8bit for mjpeg (workaround for qscale>=25)
al3x
parents:
369
diff
changeset
|
474 } |
0 | 475 |
476 /* scan header */ | |
477 put_marker(&s->pb, SOS); | |
478 put_bits(&s->pb, 16, 12); /* length */ | |
479 put_bits(&s->pb, 8, 3); /* 3 components */ | |
2967 | 480 |
0 | 481 /* Y component */ |
482 put_bits(&s->pb, 8, 1); /* index */ | |
483 put_bits(&s->pb, 4, 0); /* DC huffman table index */ | |
484 put_bits(&s->pb, 4, 0); /* AC huffman table index */ | |
2967 | 485 |
0 | 486 /* Cb component */ |
487 put_bits(&s->pb, 8, 2); /* index */ | |
488 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
|
489 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */ |
2967 | 490 |
0 | 491 /* Cr component */ |
492 put_bits(&s->pb, 8, 3); /* index */ | |
493 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
|
494 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */ |
0 | 495 |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
496 put_bits(&s->pb, 8, (lossless && !ls) ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */ |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
497 |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
498 switch(s->avctx->codec_id){ |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
499 case CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */ |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
500 case CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */ |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
501 case CODEC_ID_JPEGLS: put_bits(&s->pb, 8, 1); break; /* ILV = line interleaved */ |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
502 default: assert(0); |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
503 } |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
504 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
505 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */ |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
506 |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
507 //FIXME DC/AC entropy table selectors stuff in jpegls |
0 | 508 } |
509 | |
841 | 510 static void escape_FF(MpegEncContext *s, int start) |
840 | 511 { |
1786 | 512 int size= put_bits_count(&s->pb) - start*8; |
840 | 513 int i, ff_count; |
841 | 514 uint8_t *buf= s->pb.buf + start; |
1266 | 515 int align= (-(size_t)(buf))&3; |
2967 | 516 |
840 | 517 assert((size&7) == 0); |
518 size >>= 3; | |
2967 | 519 |
840 | 520 ff_count=0; |
521 for(i=0; i<size && i<align; i++){ | |
522 if(buf[i]==0xFF) ff_count++; | |
523 } | |
524 for(; i<size-15; i+=16){ | |
525 int acc, v; | |
526 | |
527 v= *(uint32_t*)(&buf[i]); | |
528 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
529 v= *(uint32_t*)(&buf[i+4]); | |
530 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
531 v= *(uint32_t*)(&buf[i+8]); | |
532 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
533 v= *(uint32_t*)(&buf[i+12]); | |
534 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; | |
535 | |
536 acc>>=4; | |
537 acc+= (acc>>16); | |
538 acc+= (acc>>8); | |
539 ff_count+= acc&0xFF; | |
540 } | |
541 for(; i<size; i++){ | |
542 if(buf[i]==0xFF) ff_count++; | |
543 } | |
544 | |
545 if(ff_count==0) return; | |
2967 | 546 |
840 | 547 /* skip put bits */ |
548 for(i=0; i<ff_count-3; i+=4) | |
549 put_bits(&s->pb, 32, 0); | |
550 put_bits(&s->pb, (ff_count-i)*8, 0); | |
2967 | 551 flush_put_bits(&s->pb); |
840 | 552 |
553 for(i=size-1; ff_count; i--){ | |
554 int v= buf[i]; | |
555 | |
556 if(v==0xFF){ | |
557 //printf("%d %d\n", i, ff_count); | |
558 buf[i+ff_count]= 0; | |
559 ff_count--; | |
560 } | |
561 | |
562 buf[i+ff_count]= v; | |
563 } | |
564 } | |
565 | |
1799 | 566 void ff_mjpeg_stuffing(PutBitContext * pbc) |
567 { | |
568 int length; | |
569 length= (-put_bits_count(pbc))&7; | |
570 if(length) put_bits(pbc, length, (1<<length)-1); | |
571 } | |
572 | |
0 | 573 void mjpeg_picture_trailer(MpegEncContext *s) |
574 { | |
1799 | 575 ff_mjpeg_stuffing(&s->pb); |
840 | 576 flush_put_bits(&s->pb); |
577 | |
841 | 578 assert((s->header_bits&7)==0); |
2967 | 579 |
841 | 580 escape_FF(s, s->header_bits>>3); |
840 | 581 |
0 | 582 put_marker(&s->pb, EOI); |
583 } | |
584 | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
585 static inline void mjpeg_encode_dc(MpegEncContext *s, int val, |
2979 | 586 uint8_t *huff_size, uint16_t *huff_code) |
0 | 587 { |
588 int mant, nbits; | |
589 | |
590 if (val == 0) { | |
840 | 591 put_bits(&s->pb, huff_size[0], huff_code[0]); |
0 | 592 } else { |
593 mant = val; | |
594 if (val < 0) { | |
595 val = -val; | |
596 mant--; | |
597 } | |
2967 | 598 |
1325 | 599 nbits= av_log2_16bit(val) + 1; |
2967 | 600 |
840 | 601 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]); |
2967 | 602 |
840 | 603 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1)); |
0 | 604 } |
605 } | |
606 | |
607 static void encode_block(MpegEncContext *s, DCTELEM *block, int n) | |
608 { | |
609 int mant, nbits, code, i, j; | |
610 int component, dc, run, last_index, val; | |
611 MJpegContext *m = s->mjpeg_ctx; | |
1064 | 612 uint8_t *huff_size_ac; |
613 uint16_t *huff_code_ac; | |
2967 | 614 |
0 | 615 /* DC coef */ |
616 component = (n <= 3 ? 0 : n - 4 + 1); | |
617 dc = block[0]; /* overflow is impossible */ | |
618 val = dc - s->last_dc[component]; | |
619 if (n < 4) { | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
620 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance); |
0 | 621 huff_size_ac = m->huff_size_ac_luminance; |
622 huff_code_ac = m->huff_code_ac_luminance; | |
623 } else { | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
624 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance); |
0 | 625 huff_size_ac = m->huff_size_ac_chrominance; |
626 huff_code_ac = m->huff_code_ac_chrominance; | |
627 } | |
628 s->last_dc[component] = dc; | |
2967 | 629 |
0 | 630 /* AC coefs */ |
2967 | 631 |
0 | 632 run = 0; |
633 last_index = s->block_last_index[n]; | |
634 for(i=1;i<=last_index;i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
635 j = s->intra_scantable.permutated[i]; |
0 | 636 val = block[j]; |
637 if (val == 0) { | |
638 run++; | |
639 } else { | |
640 while (run >= 16) { | |
840 | 641 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]); |
0 | 642 run -= 16; |
643 } | |
644 mant = val; | |
645 if (val < 0) { | |
646 val = -val; | |
647 mant--; | |
648 } | |
2967 | 649 |
1280 | 650 nbits= av_log2(val) + 1; |
0 | 651 code = (run << 4) | nbits; |
652 | |
840 | 653 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]); |
2967 | 654 |
840 | 655 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1)); |
0 | 656 run = 0; |
657 } | |
658 } | |
659 | |
660 /* output EOB only if not already 64 values */ | |
661 if (last_index < 63 || run != 0) | |
840 | 662 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]); |
0 | 663 } |
664 | |
2967 | 665 void mjpeg_encode_mb(MpegEncContext *s, |
0 | 666 DCTELEM block[6][64]) |
667 { | |
668 int i; | |
669 for(i=0;i<6;i++) { | |
670 encode_block(s, block[i], i); | |
671 } | |
672 } | |
23 | 673 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
674 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
|
675 MpegEncContext * const s = avctx->priv_data; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
676 MJpegContext * const m = s->mjpeg_ctx; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
677 AVFrame *pict = data; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
678 const int width= s->width; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
679 const int height= s->height; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
680 AVFrame * const p= (AVFrame*)&s->current_picture; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
681 const int predictor= avctx->prediction_method+1; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
682 |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1519
diff
changeset
|
683 init_put_bits(&s->pb, buf, buf_size); |
1315
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 *p = *pict; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
686 p->pict_type= FF_I_TYPE; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
687 p->key_frame= 1; |
2967 | 688 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
689 mjpeg_picture_header(s); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
690 |
1786 | 691 s->header_bits= put_bits_count(&s->pb); |
2967 | 692 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
693 if(avctx->pix_fmt == PIX_FMT_RGBA32){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
694 int x, y, i; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
695 const int linesize= p->linesize[0]; |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2453
diff
changeset
|
696 uint16_t (*buffer)[4]= (void *) s->rd_scratchpad; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
697 int left[3], top[3], topleft[3]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
698 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
699 for(i=0; i<3; i++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
700 buffer[0][i]= 1 << (9 - 1); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
701 } |
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(y = 0; y < height; y++) { |
1363 | 704 const int modified_predictor= y ? predictor : 1; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
705 uint8_t *ptr = p->data[0] + (linesize * y); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
706 |
2422 | 707 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){ |
708 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
709 return -1; | |
710 } | |
2967 | 711 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
712 for(i=0; i<3; i++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
713 top[i]= left[i]= topleft[i]= buffer[0][i]; |
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 for(x = 0; x < width; x++) { |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
716 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
|
717 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
|
718 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
|
719 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
720 for(i=0;i<3;i++) { |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
721 int pred, diff; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
722 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
723 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); |
2967 | 724 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
725 topleft[i]= top[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
726 top[i]= buffer[x+1][i]; |
2967 | 727 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
728 left[i]= buffer[x][i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
729 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
730 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100; |
2967 | 731 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
732 if(i==0) |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
733 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
|
734 else |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
735 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
|
736 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
737 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
738 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
739 }else{ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
740 int mb_x, mb_y, i; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
741 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
|
742 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0]; |
2967 | 743 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
744 for(mb_y = 0; mb_y < mb_height; mb_y++) { |
2422 | 745 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]){ |
746 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
747 return -1; | |
748 } | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
749 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
|
750 if(mb_x==0 || mb_y==0){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
751 for(i=0;i<3;i++) { |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
752 uint8_t *ptr; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
753 int x, y, h, v, linesize; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
754 h = s->mjpeg_hsample[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
755 v = s->mjpeg_vsample[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
756 linesize= p->linesize[i]; |
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 for(y=0; y<v; y++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
759 for(x=0; x<h; x++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
760 int pred; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
761 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
762 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
|
763 if(y==0 && mb_y==0){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
764 if(x==0 && mb_x==0){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
765 pred= 128; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
766 }else{ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
767 pred= ptr[-1]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
768 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
769 }else{ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
770 if(x==0 && mb_x==0){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
771 pred= ptr[-linesize]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
772 }else{ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
773 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
|
774 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
775 } |
2967 | 776 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
777 if(i==0) |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
778 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
|
779 else |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
780 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
|
781 } |
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 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
784 }else{ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
785 for(i=0;i<3;i++) { |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
786 uint8_t *ptr; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
787 int x, y, h, v, linesize; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
788 h = s->mjpeg_hsample[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
789 v = s->mjpeg_vsample[i]; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
790 linesize= p->linesize[i]; |
2967 | 791 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
792 for(y=0; y<v; y++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
793 for(x=0; x<h; x++){ |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
794 int pred; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
795 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
796 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap |
2967 | 797 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr); |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
798 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
|
799 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
800 if(i==0) |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
801 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
|
802 else |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
803 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
|
804 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
805 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
806 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
807 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
808 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
809 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
810 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
811 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
812 emms_c(); |
2967 | 813 |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
814 mjpeg_picture_trailer(s); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
815 s->picture_number++; |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
816 |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
817 flush_put_bits(&s->pb); |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
818 return pbBufPtr(&s->pb) - s->pb.buf; |
1786 | 819 // return (put_bits_count(&f->pb)+7)/8; |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
820 } |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
821 |
1325 | 822 #endif //CONFIG_ENCODERS |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
823 |
23 | 824 /******************************************/ |
825 /* decoding */ | |
826 | |
827 #define MAX_COMPONENTS 4 | |
828 | |
829 typedef struct MJpegDecodeContext { | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
830 AVCodecContext *avctx; |
23 | 831 GetBitContext gb; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
832 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
|
833 |
23 | 834 int start_code; /* current start code */ |
835 int buffer_size; | |
1064 | 836 uint8_t *buffer; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
837 |
1064 | 838 int16_t quant_matrixes[4][64]; |
23 | 839 VLC vlcs[2][4]; |
1358 | 840 int qscale[4]; ///< quantizer scale calculated from quant_matrixes |
53 | 841 |
1679
55c03fa692a9
set AVCodecContext.width/height before get_buffer()
michael
parents:
1619
diff
changeset
|
842 int org_height; /* size given at codec init */ |
53 | 843 int first_picture; /* true if decoding first picture */ |
844 int interlaced; /* true if interlaced */ | |
845 int bottom_field; /* true if bottom field */ | |
1307 | 846 int lossless; |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
847 int ls; |
1307 | 848 int rgb; |
2967 | 849 int rct; /* standard rct */ |
850 int pegasus_rct; /* pegasus reversible colorspace transform */ | |
1310 | 851 int bits; /* bits per component */ |
53 | 852 |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
853 int maxval; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
854 int near; ///< near lossless bound (si 0 for lossless) |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
855 int t1,t2,t3; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
856 int reset; ///< context halfing intervall ?rename |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
857 |
23 | 858 int width, height; |
1359 | 859 int mb_width, mb_height; |
26 | 860 int nb_components; |
861 int component_id[MAX_COMPONENTS]; | |
23 | 862 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */ |
863 int v_count[MAX_COMPONENTS]; | |
1359 | 864 int comp_index[MAX_COMPONENTS]; |
865 int dc_index[MAX_COMPONENTS]; | |
866 int ac_index[MAX_COMPONENTS]; | |
867 int nb_blocks[MAX_COMPONENTS]; | |
868 int h_scount[MAX_COMPONENTS]; | |
869 int v_scount[MAX_COMPONENTS]; | |
23 | 870 int h_max, v_max; /* maximum h and v counts */ |
871 int quant_index[4]; /* quant table index for each component */ | |
872 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */ | |
1513 | 873 AVFrame picture; /* picture structure */ |
874 int linesize[MAX_COMPONENTS]; ///< linesize << interlaced | |
2367
c353719836af
fix some type mismatches patch by (Jeff Muizelaar <muizelaar rogers com>)
michael
parents:
2360
diff
changeset
|
875 int8_t *qscale_table; |
3089 | 876 DECLARE_ALIGNED_8(DCTELEM, block[64]); |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
877 ScanTable scantable; |
1064 | 878 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/); |
354 | 879 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
880 int restart_interval; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
881 int restart_count; |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
882 |
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
883 int buggy_avid; |
2442 | 884 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
|
885 int interlace_polarity; |
2333
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
886 |
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
887 int mjpb_skiptosod; |
3078
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
888 |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
889 int cur_scan; /* current scan, used by JPEG-LS */ |
23 | 890 } MJpegDecodeContext; |
891 | |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
892 #include "jpeg_ls.c" //FIXME make jpeg-ls more independant |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
893 |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
894 static int mjpeg_decode_dht(MJpegDecodeContext *s); |
375 | 895 |
2967 | 896 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, |
3227 | 897 int nb_codes, int use_static, int is_ac) |
29 | 898 { |
3227 | 899 uint8_t huff_size[256+16]; |
900 uint16_t huff_code[256+16]; | |
901 | |
902 assert(nb_codes <= 256); | |
29 | 903 |
904 memset(huff_size, 0, sizeof(huff_size)); | |
905 build_huffman_codes(huff_size, huff_code, bits_table, val_table); | |
2967 | 906 |
3227 | 907 if(is_ac){ |
908 memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes); | |
909 memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes); | |
910 memset(huff_size, 0, sizeof(uint8_t)*16); | |
911 memset(huff_code, 0, sizeof(uint16_t)*16); | |
912 nb_codes += 16; | |
913 } | |
914 | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2367
diff
changeset
|
915 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static); |
29 | 916 } |
917 | |
23 | 918 static int mjpeg_decode_init(AVCodecContext *avctx) |
919 { | |
920 MJpegDecodeContext *s = avctx->priv_data; | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
921 MpegEncContext s2; |
2802
4db6127e20b8
reset restart_count when restart_interval is set and fill the
reimar
parents:
2799
diff
changeset
|
922 memset(s, 0, sizeof(MJpegDecodeContext)); |
23 | 923 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
924 s->avctx = avctx; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
925 |
1092 | 926 /* 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
|
927 memset(&s2, 0, sizeof(MpegEncContext)); |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
928 s2.avctx= avctx; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
929 // s2->out_format = FMT_MJPEG; |
1892 | 930 dsputil_init(&s2.dsp, avctx); |
931 DCT_common_init(&s2); | |
932 | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
933 s->scantable= s2.intra_scantable; |
1092 | 934 s->idct_put= s2.dsp.idct_put; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
935 |
23 | 936 s->mpeg_enc_ctx_allocated = 0; |
2799
924c7e66ced8
dont pre allocate uselessly large buffer and dont ignore FF_INPUT_BUFFER_PADDING_SIZE
michael
parents:
2798
diff
changeset
|
937 s->buffer_size = 0; |
924c7e66ced8
dont pre allocate uselessly large buffer and dont ignore FF_INPUT_BUFFER_PADDING_SIZE
michael
parents:
2798
diff
changeset
|
938 s->buffer = NULL; |
23 | 939 s->start_code = -1; |
53 | 940 s->first_picture = 1; |
2270 | 941 s->org_height = avctx->coded_height; |
2967 | 942 |
3227 | 943 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0); |
944 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0); | |
945 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1); | |
946 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1); | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
947 |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
948 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
|
949 { |
2979 | 950 av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n"); |
951 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8); | |
952 mjpeg_decode_dht(s); | |
953 /* should check for error - but dunno */ | |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
954 } |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
955 |
23 | 956 return 0; |
957 } | |
958 | |
2319 | 959 |
960 /** | |
961 * finds the end of the current frame in the bitstream. | |
962 * @return the position of the first byte of the next frame, or -1 | |
963 */ | |
964 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){ | |
965 int vop_found, i; | |
966 uint16_t state; | |
2967 | 967 |
2319 | 968 vop_found= pc->frame_start_found; |
969 state= pc->state; | |
2967 | 970 |
2319 | 971 i=0; |
972 if(!vop_found){ | |
973 for(i=0; i<buf_size; i++){ | |
974 state= (state<<8) | buf[i]; | |
975 if(state == 0xFFD8){ | |
976 i++; | |
977 vop_found=1; | |
978 break; | |
979 } | |
980 } | |
981 } | |
982 | |
983 if(vop_found){ | |
984 /* EOF considered as end of frame */ | |
985 if (buf_size == 0) | |
986 return 0; | |
987 for(; i<buf_size; i++){ | |
988 state= (state<<8) | buf[i]; | |
989 if(state == 0xFFD8){ | |
990 pc->frame_start_found=0; | |
2967 | 991 pc->state=0; |
2319 | 992 return i-1; |
993 } | |
994 } | |
995 } | |
996 pc->frame_start_found= vop_found; | |
997 pc->state= state; | |
998 return END_NOT_FOUND; | |
999 } | |
1000 | |
1001 static int jpeg_parse(AVCodecParserContext *s, | |
1002 AVCodecContext *avctx, | |
2967 | 1003 uint8_t **poutbuf, int *poutbuf_size, |
2319 | 1004 const uint8_t *buf, int buf_size) |
1005 { | |
1006 ParseContext *pc = s->priv_data; | |
1007 int next; | |
2967 | 1008 |
2319 | 1009 next= find_frame_end(pc, buf, buf_size); |
1010 | |
1011 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { | |
1012 *poutbuf = NULL; | |
1013 *poutbuf_size = 0; | |
1014 return buf_size; | |
1015 } | |
1016 | |
1017 *poutbuf = (uint8_t *)buf; | |
1018 *poutbuf_size = buf_size; | |
1019 return next; | |
1020 } | |
1021 | |
23 | 1022 /* quantize tables */ |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1023 static int mjpeg_decode_dqt(MJpegDecodeContext *s) |
23 | 1024 { |
37 | 1025 int len, index, i, j; |
2967 | 1026 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1027 len = get_bits(&s->gb, 16) - 2; |
23 | 1028 |
1029 while (len >= 65) { | |
1030 /* only 8 bit precision handled */ | |
1031 if (get_bits(&s->gb, 4) != 0) | |
2979 | 1032 { |
1033 dprintf("dqt: 16bit precision\n"); | |
23 | 1034 return -1; |
2979 | 1035 } |
23 | 1036 index = get_bits(&s->gb, 4); |
1037 if (index >= 4) | |
1038 return -1; | |
1039 dprintf("index=%d\n", index); | |
1040 /* read quant table */ | |
37 | 1041 for(i=0;i<64;i++) { |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
1042 j = s->scantable.permutated[i]; |
2979 | 1043 s->quant_matrixes[index][j] = get_bits(&s->gb, 8); |
37 | 1044 } |
1358 | 1045 |
1046 //XXX FIXME finetune, and perhaps add dc too | |
1047 s->qscale[index]= FFMAX( | |
1048 s->quant_matrixes[index][s->scantable.permutated[1]], | |
1049 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1; | |
2979 | 1050 dprintf("qscale[%d]: %d\n", index, s->qscale[index]); |
23 | 1051 len -= 65; |
1052 } | |
2967 | 1053 |
23 | 1054 return 0; |
1055 } | |
1056 | |
1057 /* decode huffman tables and build VLC decoders */ | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1058 static int mjpeg_decode_dht(MJpegDecodeContext *s) |
23 | 1059 { |
1060 int len, index, i, class, n, v, code_max; | |
1064 | 1061 uint8_t bits_table[17]; |
1062 uint8_t val_table[256]; | |
2967 | 1063 |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1064 len = get_bits(&s->gb, 16) - 2; |
23 | 1065 |
1066 while (len > 0) { | |
1067 if (len < 17) | |
1068 return -1; | |
1069 class = get_bits(&s->gb, 4); | |
1070 if (class >= 2) | |
1071 return -1; | |
1072 index = get_bits(&s->gb, 4); | |
1073 if (index >= 4) | |
1074 return -1; | |
1075 n = 0; | |
1076 for(i=1;i<=16;i++) { | |
1077 bits_table[i] = get_bits(&s->gb, 8); | |
1078 n += bits_table[i]; | |
1079 } | |
1080 len -= 17; | |
1081 if (len < n || n > 256) | |
1082 return -1; | |
1083 | |
1084 code_max = 0; | |
1085 for(i=0;i<n;i++) { | |
1086 v = get_bits(&s->gb, 8); | |
1087 if (v > code_max) | |
1088 code_max = v; | |
1089 val_table[i] = v; | |
1090 } | |
1091 len -= n; | |
1092 | |
1093 /* build VLC and flush previous vlc if present */ | |
1094 free_vlc(&s->vlcs[class][index]); | |
1095 dprintf("class=%d index=%d nb_codes=%d\n", | |
1096 class, index, code_max + 1); | |
3227 | 1097 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){ |
1351 | 1098 return -1; |
1099 } | |
23 | 1100 } |
1101 return 0; | |
1102 } | |
1103 | |
1307 | 1104 static int mjpeg_decode_sof(MJpegDecodeContext *s) |
23 | 1105 { |
26 | 1106 int len, nb_components, i, width, height; |
23 | 1107 |
1108 /* XXX: verify len field validity */ | |
1109 len = get_bits(&s->gb, 16); | |
1310 | 1110 s->bits= get_bits(&s->gb, 8); |
2967 | 1111 |
1112 if(s->pegasus_rct) s->bits=9; | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
1113 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly |
1310 | 1114 |
1115 if (s->bits != 8 && !s->lossless){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1116 av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n"); |
23 | 1117 return -1; |
1307 | 1118 } |
3078
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1119 if (s->bits > 8 && s->ls){ |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1120 av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component accepted for JPEG-LS\n"); |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1121 return -1; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1122 } |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1123 |
23 | 1124 height = get_bits(&s->gb, 16); |
1125 width = get_bits(&s->gb, 16); | |
2967 | 1126 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1127 dprintf("sof0: picture: %dx%d\n", width, height); |
2422 | 1128 if(avcodec_check_dimensions(s->avctx, width, height)) |
1129 return -1; | |
23 | 1130 |
1131 nb_components = get_bits(&s->gb, 8); | |
1132 if (nb_components <= 0 || | |
1133 nb_components > MAX_COMPONENTS) | |
1134 return -1; | |
26 | 1135 s->nb_components = nb_components; |
23 | 1136 s->h_max = 1; |
1137 s->v_max = 1; | |
1138 for(i=0;i<nb_components;i++) { | |
1139 /* component id */ | |
26 | 1140 s->component_id[i] = get_bits(&s->gb, 8) - 1; |
23 | 1141 s->h_count[i] = get_bits(&s->gb, 4); |
1142 s->v_count[i] = get_bits(&s->gb, 4); | |
1143 /* compute hmax and vmax (only used in interleaved case) */ | |
1144 if (s->h_count[i] > s->h_max) | |
1145 s->h_max = s->h_count[i]; | |
1146 if (s->v_count[i] > s->v_max) | |
1147 s->v_max = s->v_count[i]; | |
1148 s->quant_index[i] = get_bits(&s->gb, 8); | |
1149 if (s->quant_index[i] >= 4) | |
1150 return -1; | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1151 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i], |
2979 | 1152 s->v_count[i], s->component_id[i], s->quant_index[i]); |
23 | 1153 } |
2967 | 1154 |
3078
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1155 if(s->ls && (s->h_max > 1 || s->v_max > 1)) { |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1156 av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n"); |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1157 return -1; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1158 } |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1159 |
1310 | 1160 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1; |
23 | 1161 |
1162 /* if different size, realloc/alloc picture */ | |
1163 /* XXX: also check h_count and v_count */ | |
1164 if (width != s->width || height != s->height) { | |
1358 | 1165 av_freep(&s->qscale_table); |
2967 | 1166 |
23 | 1167 s->width = width; |
1168 s->height = height; | |
1679
55c03fa692a9
set AVCodecContext.width/height before get_buffer()
michael
parents:
1619
diff
changeset
|
1169 |
53 | 1170 /* test interlaced mode */ |
1171 if (s->first_picture && | |
1172 s->org_height != 0 && | |
1173 s->height < ((s->org_height * 3) / 4)) { | |
1174 s->interlaced = 1; | |
2979 | 1175 // s->bottom_field = (s->interlace_polarity) ? 1 : 0; |
1679
55c03fa692a9
set AVCodecContext.width/height before get_buffer()
michael
parents:
1619
diff
changeset
|
1176 s->bottom_field = 0; |
3062
8d05d4036b6a
Mjpeg interlaced decoding fix, height was wrong while decoding (/2).
banan
parents:
3036
diff
changeset
|
1177 height *= 2; |
53 | 1178 } |
1179 | |
3062
8d05d4036b6a
Mjpeg interlaced decoding fix, height was wrong while decoding (/2).
banan
parents:
3036
diff
changeset
|
1180 avcodec_set_dimensions(s->avctx, width, height); |
8d05d4036b6a
Mjpeg interlaced decoding fix, height was wrong while decoding (/2).
banan
parents:
3036
diff
changeset
|
1181 |
1358 | 1182 s->qscale_table= av_mallocz((s->width+15)/16); |
1183 | |
53 | 1184 s->first_picture = 0; |
23 | 1185 } |
2967 | 1186 |
1513 | 1187 if(s->interlaced && s->bottom_field) |
1188 return 0; | |
2967 | 1189 |
1513 | 1190 /* XXX: not complete test ! */ |
1191 switch((s->h_count[0] << 4) | s->v_count[0]) { | |
1192 case 0x11: | |
1193 if(s->rgb){ | |
1194 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
|
1195 }else if(s->nb_components==3) |
2442 | 1196 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
|
1197 else |
0c686b4cd576
grayscale mjpeg decoding support based upon a patch by (Leon Bottou (leonb))
michael
parents:
1679
diff
changeset
|
1198 s->avctx->pix_fmt = PIX_FMT_GRAY8; |
1513 | 1199 break; |
1200 case 0x21: | |
2442 | 1201 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P; |
1513 | 1202 break; |
1203 default: | |
1204 case 0x22: | |
2442 | 1205 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P; |
1513 | 1206 break; |
1207 } | |
3078
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1208 if(s->ls){ |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1209 if(s->nb_components > 1) |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1210 s->avctx->pix_fmt = PIX_FMT_RGB24; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1211 else |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1212 s->avctx->pix_fmt = PIX_FMT_GRAY8; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1213 } |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1214 |
1513 | 1215 if(s->picture.data[0]) |
1216 s->avctx->release_buffer(s->avctx, &s->picture); | |
1217 | |
1218 s->picture.reference= 0; | |
1219 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
|
1220 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
1513 | 1221 return -1; |
1222 } | |
1223 s->picture.pict_type= I_TYPE; | |
1224 s->picture.key_frame= 1; | |
2967 | 1225 |
1513 | 1226 for(i=0; i<3; i++){ |
1227 s->linesize[i]= s->picture.linesize[i] << s->interlaced; | |
1228 } | |
1229 | |
1230 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height); | |
2967 | 1231 |
354 | 1232 if (len != (8+(3*nb_components))) |
1233 { | |
2979 | 1234 dprintf("decode_sof0: error, len(%d) mismatch\n", len); |
354 | 1235 } |
2967 | 1236 |
23 | 1237 return 0; |
1238 } | |
1239 | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
1240 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index) |
23 | 1241 { |
1280 | 1242 int code; |
780 | 1243 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2); |
23 | 1244 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
|
1245 { |
2979 | 1246 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index, |
427 | 1247 &s->vlcs[0][dc_index]); |
23 | 1248 return 0xffff; |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1249 } |
1280 | 1250 |
1251 if(code) | |
1252 return get_xbits(&s->gb, code); | |
1253 else | |
1254 return 0; | |
23 | 1255 } |
1256 | |
1257 /* decode block and dequantize */ | |
2967 | 1258 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, |
3225 | 1259 int component, int dc_index, int ac_index, int16_t *quant_matrix) |
23 | 1260 { |
1280 | 1261 int code, i, j, level, val; |
23 | 1262 |
1263 /* DC coef */ | |
440
000aeeac27a2
* started to cleanup name clashes for onetime compilation
kabi
parents:
427
diff
changeset
|
1264 val = mjpeg_decode_dc(s, dc_index); |
23 | 1265 if (val == 0xffff) { |
1266 dprintf("error dc\n"); | |
1267 return -1; | |
1268 } | |
1269 val = val * quant_matrix[0] + s->last_dc[component]; | |
1270 s->last_dc[component] = val; | |
1271 block[0] = val; | |
1272 /* AC coefs */ | |
3227 | 1273 i = 0; |
3232 | 1274 {OPEN_READER(re, &s->gb) |
23 | 1275 for(;;) { |
3225 | 1276 UPDATE_CACHE(re, &s->gb); |
1277 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2) | |
1275 | 1278 |
23 | 1279 /* EOB */ |
3227 | 1280 if (code == 0x10) |
23 | 1281 break; |
3242 | 1282 i += ((unsigned)code) >> 4; |
1283 if(code != 0x100){ | |
3225 | 1284 code &= 0xf; |
3241
61d9f1418c02
do UPDATE_CACHE only when needed (which should be VERY rare)
michael
parents:
3240
diff
changeset
|
1285 if(code > MIN_CACHE_BITS - 16){ |
61d9f1418c02
do UPDATE_CACHE only when needed (which should be VERY rare)
michael
parents:
3240
diff
changeset
|
1286 UPDATE_CACHE(re, &s->gb) |
61d9f1418c02
do UPDATE_CACHE only when needed (which should be VERY rare)
michael
parents:
3240
diff
changeset
|
1287 } |
3239 | 1288 { |
3242 | 1289 int cache=GET_CACHE(re,&s->gb); |
3239 | 1290 int sign=(~cache)>>31; |
3240 | 1291 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign; |
3225 | 1292 } |
1293 | |
3226 | 1294 LAST_SKIP_BITS(re, &s->gb, code) |
3225 | 1295 |
3228
ad50f9ef5c6b
avoid if(i>=63) check at the end of decode_block()
michael
parents:
3227
diff
changeset
|
1296 if (i >= 63) { |
ad50f9ef5c6b
avoid if(i>=63) check at the end of decode_block()
michael
parents:
3227
diff
changeset
|
1297 if(i == 63){ |
ad50f9ef5c6b
avoid if(i>=63) check at the end of decode_block()
michael
parents:
3227
diff
changeset
|
1298 j = s->scantable.permutated[63]; |
ad50f9ef5c6b
avoid if(i>=63) check at the end of decode_block()
michael
parents:
3227
diff
changeset
|
1299 block[j] = level * quant_matrix[j]; |
ad50f9ef5c6b
avoid if(i>=63) check at the end of decode_block()
michael
parents:
3227
diff
changeset
|
1300 break; |
ad50f9ef5c6b
avoid if(i>=63) check at the end of decode_block()
michael
parents:
3227
diff
changeset
|
1301 } |
23 | 1302 dprintf("error count: %d\n", i); |
1303 return -1; | |
1304 } | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
676
diff
changeset
|
1305 j = s->scantable.permutated[i]; |
23 | 1306 block[j] = level * quant_matrix[j]; |
1307 } | |
1308 } | |
3232 | 1309 CLOSE_READER(re, &s->gb)} |
3225 | 1310 |
23 | 1311 return 0; |
1312 } | |
1313 | |
1359 | 1314 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){ |
1315 int i, mb_x, mb_y; | |
2422 | 1316 uint16_t buffer[32768][4]; |
1359 | 1317 int left[3], top[3], topleft[3]; |
1318 const int linesize= s->linesize[0]; | |
1319 const int mask= (1<<s->bits)-1; | |
2967 | 1320 |
2422 | 1321 if((unsigned)s->mb_width > 32768) //dynamic alloc |
1322 return -1; | |
2967 | 1323 |
1359 | 1324 for(i=0; i<3; i++){ |
1325 buffer[0][i]= 1 << (s->bits + point_transform - 1); | |
1326 } | |
1327 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
1363 | 1328 const int modified_predictor= mb_y ? predictor : 1; |
1513 | 1329 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y); |
1359 | 1330 |
1331 if (s->interlaced && s->bottom_field) | |
1332 ptr += linesize >> 1; | |
1333 | |
1334 for(i=0; i<3; i++){ | |
1335 top[i]= left[i]= topleft[i]= buffer[0][i]; | |
1336 } | |
1337 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1338 if (s->restart_interval && !s->restart_count) | |
1339 s->restart_count = s->restart_interval; | |
1340 | |
1341 for(i=0;i<3;i++) { | |
1342 int pred; | |
1343 | |
1344 topleft[i]= top[i]; | |
1345 top[i]= buffer[mb_x][i]; | |
1346 | |
1347 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); | |
2967 | 1348 |
1349 left[i]= | |
1359 | 1350 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform)); |
1351 } | |
1352 | |
1353 if (s->restart_interval && !--s->restart_count) { | |
1354 align_get_bits(&s->gb); | |
1355 skip_bits(&s->gb, 16); /* skip RSTn */ | |
1356 } | |
1357 } | |
1358 | |
1359 if(s->rct){ | |
1360 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1361 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2); | |
1362 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; | |
1363 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; | |
1364 } | |
1365 }else if(s->pegasus_rct){ | |
1366 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1367 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2); | |
1368 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; | |
1369 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; | |
1370 } | |
1371 }else{ | |
1372 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1373 ptr[4*mb_x+0] = buffer[mb_x][0]; | |
1374 ptr[4*mb_x+1] = buffer[mb_x][1]; | |
1375 ptr[4*mb_x+2] = buffer[mb_x][2]; | |
1376 } | |
1377 } | |
1378 } | |
1379 return 0; | |
1380 } | |
1381 | |
1382 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){ | |
1383 int i, mb_x, mb_y; | |
1384 const int nb_components=3; | |
1385 | |
1386 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
1387 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1388 if (s->restart_interval && !s->restart_count) | |
1389 s->restart_count = s->restart_interval; | |
1390 | |
1391 if(mb_x==0 || mb_y==0 || s->interlaced){ | |
1392 for(i=0;i<nb_components;i++) { | |
1393 uint8_t *ptr; | |
1394 int n, h, v, x, y, c, j, linesize; | |
1395 n = s->nb_blocks[i]; | |
1396 c = s->comp_index[i]; | |
1397 h = s->h_scount[i]; | |
1398 v = s->v_scount[i]; | |
1399 x = 0; | |
1400 y = 0; | |
1401 linesize= s->linesize[c]; | |
2967 | 1402 |
1359 | 1403 for(j=0; j<n; j++) { |
1404 int pred; | |
1405 | |
1513 | 1406 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap |
1359 | 1407 if(y==0 && mb_y==0){ |
1408 if(x==0 && mb_x==0){ | |
1409 pred= 128 << point_transform; | |
1410 }else{ | |
1411 pred= ptr[-1]; | |
1412 } | |
1413 }else{ | |
1414 if(x==0 && mb_x==0){ | |
1415 pred= ptr[-linesize]; | |
1416 }else{ | |
1417 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); | |
1418 } | |
1419 } | |
2967 | 1420 |
1359 | 1421 if (s->interlaced && s->bottom_field) |
1422 ptr += linesize >> 1; | |
1423 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); | |
1424 | |
1425 if (++x == h) { | |
1426 x = 0; | |
1427 y++; | |
1428 } | |
1429 } | |
1430 } | |
1431 }else{ | |
1432 for(i=0;i<nb_components;i++) { | |
1433 uint8_t *ptr; | |
1434 int n, h, v, x, y, c, j, linesize; | |
1435 n = s->nb_blocks[i]; | |
1436 c = s->comp_index[i]; | |
1437 h = s->h_scount[i]; | |
1438 v = s->v_scount[i]; | |
1439 x = 0; | |
1440 y = 0; | |
1441 linesize= s->linesize[c]; | |
2967 | 1442 |
1359 | 1443 for(j=0; j<n; j++) { |
1444 int pred; | |
1445 | |
1513 | 1446 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap |
1359 | 1447 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); |
1448 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform); | |
1449 if (++x == h) { | |
1450 x = 0; | |
1451 y++; | |
1452 } | |
1453 } | |
1454 } | |
1455 } | |
1456 if (s->restart_interval && !--s->restart_count) { | |
1457 align_get_bits(&s->gb); | |
1458 skip_bits(&s->gb, 16); /* skip RSTn */ | |
1459 } | |
1460 } | |
1461 } | |
1462 return 0; | |
1463 } | |
1464 | |
1465 static int mjpeg_decode_scan(MJpegDecodeContext *s){ | |
1466 int i, mb_x, mb_y; | |
1467 const int nb_components=3; | |
1468 | |
1469 for(mb_y = 0; mb_y < s->mb_height; mb_y++) { | |
1470 for(mb_x = 0; mb_x < s->mb_width; mb_x++) { | |
1471 if (s->restart_interval && !s->restart_count) | |
1472 s->restart_count = s->restart_interval; | |
1473 | |
1474 for(i=0;i<nb_components;i++) { | |
1475 uint8_t *ptr; | |
1476 int n, h, v, x, y, c, j; | |
1477 n = s->nb_blocks[i]; | |
1478 c = s->comp_index[i]; | |
1479 h = s->h_scount[i]; | |
1480 v = s->v_scount[i]; | |
1481 x = 0; | |
1482 y = 0; | |
1483 for(j=0;j<n;j++) { | |
1484 memset(s->block, 0, sizeof(s->block)); | |
2967 | 1485 if (decode_block(s, s->block, i, |
1486 s->dc_index[i], s->ac_index[i], | |
3225 | 1487 s->quant_matrixes[ s->quant_index[c] ]) < 0) { |
1359 | 1488 dprintf("error y=%d x=%d\n", mb_y, mb_x); |
1489 return -1; | |
1490 } | |
2979 | 1491 // dprintf("mb: %d %d processed\n", mb_y, mb_x); |
2967 | 1492 ptr = s->picture.data[c] + |
1493 (((s->linesize[c] * (v * mb_y + y) * 8) + | |
2258 | 1494 (h * mb_x + x) * 8) >> s->avctx->lowres); |
1359 | 1495 if (s->interlaced && s->bottom_field) |
1496 ptr += s->linesize[c] >> 1; | |
1994 | 1497 //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 | 1498 s->idct_put(ptr, s->linesize[c], s->block); |
1499 if (++x == h) { | |
1500 x = 0; | |
1501 y++; | |
1502 } | |
1503 } | |
1504 } | |
1505 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */ | |
1506 if (s->restart_interval && (s->restart_interval < 1350) && | |
1507 !--s->restart_count) { | |
1508 align_get_bits(&s->gb); | |
1509 skip_bits(&s->gb, 16); /* skip RSTn */ | |
1510 for (i=0; i<nb_components; i++) /* reset dc */ | |
1511 s->last_dc[i] = 1024; | |
1512 } | |
1513 } | |
1514 } | |
1515 return 0; | |
1516 } | |
1517 | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1518 static int mjpeg_decode_sos(MJpegDecodeContext *s) |
23 | 1519 { |
1455 | 1520 int len, nb_components, i, h, v, predictor, point_transform; |
1359 | 1521 int vmax, hmax, index, id; |
1307 | 1522 const int block_size= s->lossless ? 1 : 8; |
2976 | 1523 int ilv; |
1307 | 1524 |
23 | 1525 /* XXX: verify len field validity */ |
1526 len = get_bits(&s->gb, 16); | |
1527 nb_components = get_bits(&s->gb, 8); | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1528 if (len != 6+2*nb_components) |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1529 { |
2979 | 1530 dprintf("decode_sos: invalid len (%d)\n", len); |
1531 return -1; | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1532 } |
23 | 1533 /* XXX: only interleaved scan accepted */ |
3078
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1534 if ((nb_components != s->nb_components) && !s->ls) |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1535 { |
2979 | 1536 dprintf("decode_sos: components(%d) mismatch\n", nb_components); |
23 | 1537 return -1; |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1538 } |
23 | 1539 vmax = 0; |
1540 hmax = 0; | |
1541 for(i=0;i<nb_components;i++) { | |
26 | 1542 id = get_bits(&s->gb, 8) - 1; |
2979 | 1543 dprintf("component: %d\n", id); |
26 | 1544 /* find component index */ |
1545 for(index=0;index<s->nb_components;index++) | |
1546 if (id == s->component_id[index]) | |
1547 break; | |
1548 if (index == s->nb_components) | |
2979 | 1549 { |
1550 dprintf("decode_sos: index(%d) out of components\n", index); | |
23 | 1551 return -1; |
2979 | 1552 } |
26 | 1553 |
1359 | 1554 s->comp_index[i] = index; |
1310 | 1555 |
1359 | 1556 s->nb_blocks[i] = s->h_count[index] * s->v_count[index]; |
1557 s->h_scount[i] = s->h_count[index]; | |
1558 s->v_scount[i] = s->v_count[index]; | |
28
b611fafddf9e
added 422P and 444P support - fixed block parsing error
glantau
parents:
26
diff
changeset
|
1559 |
1359 | 1560 s->dc_index[i] = get_bits(&s->gb, 4); |
1561 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
|
1562 |
2979 | 1563 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 || |
1564 s->dc_index[i] >= 4 || s->ac_index[i] >= 4) | |
1565 goto out_of_range; | |
1359 | 1566 #if 0 //buggy |
2979 | 1567 switch(s->start_code) |
1568 { | |
1569 case SOF0: | |
1570 if (dc_index[i] > 1 || ac_index[i] > 1) | |
1571 goto out_of_range; | |
1572 break; | |
1573 case SOF1: | |
1574 case SOF2: | |
1575 if (dc_index[i] > 3 || ac_index[i] > 3) | |
1576 goto out_of_range; | |
1577 break; | |
1578 case SOF3: | |
1579 if (dc_index[i] > 3 || ac_index[i] != 0) | |
1580 goto out_of_range; | |
1581 break; | |
1582 } | |
1359 | 1583 #endif |
23 | 1584 } |
1310 | 1585 |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
1586 predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */ |
2976 | 1587 ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */ |
1307 | 1588 skip_bits(&s->gb, 4); /* Ah */ |
1589 point_transform= get_bits(&s->gb, 4); /* Al */ | |
23 | 1590 |
2967 | 1591 for(i=0;i<nb_components;i++) |
23 | 1592 s->last_dc[i] = 1024; |
1593 | |
1594 if (nb_components > 1) { | |
1595 /* interleaved stream */ | |
1359 | 1596 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size); |
1597 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size); | |
3078
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1598 } else if(!s->ls) { /* skip this for JPEG-LS */ |
1359 | 1599 h = s->h_max / s->h_scount[s->comp_index[0]]; |
1600 v = s->v_max / s->v_scount[s->comp_index[0]]; | |
1601 s->mb_width = (s->width + h * block_size - 1) / (h * block_size); | |
1602 s->mb_height = (s->height + v * block_size - 1) / (v * block_size); | |
1603 s->nb_blocks[0] = 1; | |
1604 s->h_scount[0] = 1; | |
1605 s->v_scount[0] = 1; | |
23 | 1606 } |
1307 | 1607 |
1310 | 1608 if(s->avctx->debug & FF_DEBUG_PICT_INFO) |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
1609 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
1610 predictor, point_transform, ilv, s->bits, |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
1611 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : "")); |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
1612 |
2967 | 1613 |
2333
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
1614 /* 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
|
1615 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
|
1616 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
|
1617 |
1307 | 1618 if(s->lossless){ |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
1619 if(s->ls){ |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
1620 // for(){ |
3078
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1621 // reset_ls_coding_parameters(s, 0); |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1622 |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1623 ls_decode_picture(s, predictor, point_transform, ilv); |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
1624 }else{ |
1359 | 1625 if(s->rgb){ |
1626 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0) | |
1627 return -1; | |
1628 }else{ | |
1629 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0) | |
1630 return -1; | |
1307 | 1631 } |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
1632 } |
1307 | 1633 }else{ |
1359 | 1634 if(mjpeg_decode_scan(s) < 0) |
1635 return -1; | |
23 | 1636 } |
44
92d51f683931
added forgotten emms() - fix various segmentation faults when using mjpeg
glantau
parents:
37
diff
changeset
|
1637 emms_c(); |
1359 | 1638 return 0; |
349
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1639 out_of_range: |
34f6c77ff01a
Support for external huffman table and various fixes by Alex Beregszaszi <alex@naxine.org>
arpi_esp
parents:
344
diff
changeset
|
1640 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
|
1641 return -1; |
23 | 1642 } |
1643 | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1644 static int mjpeg_decode_dri(MJpegDecodeContext *s) |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1645 { |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1646 if (get_bits(&s->gb, 16) != 4) |
2979 | 1647 return -1; |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1648 s->restart_interval = get_bits(&s->gb, 16); |
2802
4db6127e20b8
reset restart_count when restart_interval is set and fill the
reimar
parents:
2799
diff
changeset
|
1649 s->restart_count = 0; |
507
b5b91e89b88c
* turned into debug message - it's annoying when watching mjpeg files
kabi
parents:
477
diff
changeset
|
1650 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
|
1651 |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1652 return 0; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1653 } |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1654 |
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
|
1655 static int mjpeg_decode_app(MJpegDecodeContext *s) |
354 | 1656 { |
1657 int len, id; | |
1658 | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1659 len = get_bits(&s->gb, 16); |
354 | 1660 if (len < 5) |
2979 | 1661 return -1; |
2789 | 1662 if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits) |
1663 return -1; | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1664 |
811 | 1665 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16); |
1666 id = be2me_32(id); | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1667 len -= 6; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1668 |
1310 | 1669 if(s->avctx->debug & FF_DEBUG_STARTCODE){ |
2967 | 1670 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); |
1310 | 1671 } |
2967 | 1672 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1673 /* 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
|
1674 /* 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
|
1675 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
|
1676 if (id == ff_get_fourcc("AVI1")) |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1677 { |
2979 | 1678 /* structure: |
1679 4bytes AVI1 | |
1680 1bytes polarity | |
1681 1bytes always zero | |
1682 4bytes field_size | |
1683 4bytes field_size_less_padding | |
1684 */ | |
1685 s->buggy_avid = 1; | |
1686 // if (s->first_picture) | |
1687 // printf("mjpeg: workarounding buggy AVID\n"); | |
1688 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
|
1689 #if 0 |
2979 | 1690 skip_bits(&s->gb, 8); |
1691 skip_bits(&s->gb, 32); | |
1692 skip_bits(&s->gb, 32); | |
1693 len -= 10; | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1694 #endif |
2979 | 1695 // if (s->interlace_polarity) |
1696 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity); | |
1697 goto out; | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1698 } |
2967 | 1699 |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1700 // len -= 2; |
2967 | 1701 |
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
|
1702 if (id == ff_get_fourcc("JFIF")) |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1703 { |
2979 | 1704 int t_w, t_h, v1, v2; |
1705 skip_bits(&s->gb, 8); /* the trailing zero-byte */ | |
1706 v1= get_bits(&s->gb, 8); | |
1911 | 1707 v2= get_bits(&s->gb, 8); |
1548 | 1708 skip_bits(&s->gb, 8); |
903 | 1709 |
1548 | 1710 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16); |
1711 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16); | |
935 | 1712 |
1911 | 1713 if (s->avctx->debug & FF_DEBUG_PICT_INFO) |
1714 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n", | |
1715 v1, v2, | |
1716 s->avctx->sample_aspect_ratio.num, | |
1717 s->avctx->sample_aspect_ratio.den | |
1718 ); | |
1719 | |
2979 | 1720 t_w = get_bits(&s->gb, 8); |
1721 t_h = get_bits(&s->gb, 8); | |
1722 if (t_w && t_h) | |
1723 { | |
1724 /* skip thumbnail */ | |
1725 if (len-10-(t_w*t_h*3) > 0) | |
1726 len -= t_w*t_h*3; | |
1727 } | |
1728 len -= 10; | |
1729 goto out; | |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1730 } |
2967 | 1731 |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1732 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
|
1733 { |
1906
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1734 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
|
1735 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n"); |
2979 | 1736 skip_bits(&s->gb, 16); /* version */ |
1737 skip_bits(&s->gb, 16); /* flags0 */ | |
1738 skip_bits(&s->gb, 16); /* flags1 */ | |
1739 skip_bits(&s->gb, 8); /* transform */ | |
1740 len -= 7; | |
1741 goto out; | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1742 } |
1310 | 1743 |
1744 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
|
1745 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
|
1746 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n"); |
2979 | 1747 skip_bits(&s->gb, 16); /* version ? */ |
1748 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
1749 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
1750 skip_bits(&s->gb, 16); /* unknwon always 0? */ | |
1310 | 1751 switch( get_bits(&s->gb, 8)){ |
1752 case 1: | |
1753 s->rgb= 1; | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
1754 s->pegasus_rct=0; |
1310 | 1755 break; |
1756 case 2: | |
1757 s->rgb= 1; | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
1758 s->pegasus_rct=1; |
1310 | 1759 break; |
1760 default: | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
1761 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n"); |
1310 | 1762 } |
1763 len -= 9; | |
1764 goto out; | |
1765 } | |
2967 | 1766 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1767 /* 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
|
1768 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
|
1769 { |
2979 | 1770 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16); |
1771 id = be2me_32(id); | |
1772 len -= 4; | |
1773 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */ | |
1774 { | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1775 #if 0 |
2979 | 1776 skip_bits(&s->gb, 32); /* field size */ |
1777 skip_bits(&s->gb, 32); /* pad field size */ | |
1778 skip_bits(&s->gb, 32); /* next off */ | |
1779 skip_bits(&s->gb, 32); /* quant off */ | |
1780 skip_bits(&s->gb, 32); /* huff off */ | |
1781 skip_bits(&s->gb, 32); /* image off */ | |
1782 skip_bits(&s->gb, 32); /* scan off */ | |
1783 skip_bits(&s->gb, 32); /* data off */ | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1784 #endif |
1906
caee9c21b0b1
always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
michael
parents:
1892
diff
changeset
|
1785 if (s->avctx->debug & FF_DEBUG_PICT_INFO) |
2979 | 1786 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n"); |
1787 } | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1788 } |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1789 |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1790 out: |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1791 /* 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
|
1792 if (len < 0) |
2979 | 1793 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
|
1794 while(--len > 0) |
2979 | 1795 skip_bits(&s->gb, 8); |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1796 |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1797 return 0; |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1798 } |
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1799 |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1800 static int mjpeg_decode_com(MJpegDecodeContext *s) |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1801 { |
1322 | 1802 int len = get_bits(&s->gb, 16); |
2798 | 1803 if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) { |
2979 | 1804 uint8_t *cbuf = av_malloc(len - 1); |
1805 if (cbuf) { | |
1806 int i; | |
1807 for (i = 0; i < len - 2; i++) | |
1808 cbuf[i] = get_bits(&s->gb, 8); | |
1809 if (i > 0 && cbuf[i-1] == '\n') | |
1810 cbuf[i-1] = 0; | |
1811 else | |
1812 cbuf[i] = 0; | |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
1813 |
1911 | 1814 if(s->avctx->debug & FF_DEBUG_PICT_INFO) |
1815 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
|
1816 |
2979 | 1817 /* buggy avid, it puts EOI only at every 10th frame */ |
1818 if (!strcmp(cbuf, "AVID")) | |
1819 { | |
1820 s->buggy_avid = 1; | |
1821 // if (s->first_picture) | |
1822 // printf("mjpeg: workarounding buggy AVID\n"); | |
1823 } | |
2442 | 1824 else if(!strcmp(cbuf, "CS=ITU601")){ |
1825 s->cs_itu601= 1; | |
1826 } | |
1061 | 1827 |
2979 | 1828 av_free(cbuf); |
1829 } | |
354 | 1830 } |
1831 | |
1832 return 0; | |
1833 } | |
1834 | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1835 #if 0 |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1836 static int valid_marker_list[] = |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1837 { |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1838 /* 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
|
1839 /* 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
|
1840 /* 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
|
1841 /* 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
|
1842 /* 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
|
1843 /* 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
|
1844 /* 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
|
1845 /* 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
|
1846 /* 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
|
1847 /* 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
|
1848 /* 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
|
1849 /* 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
|
1850 /* 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
|
1851 /* 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
|
1852 /* 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
|
1853 /* 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
|
1854 /* 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
|
1855 } |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1856 #endif |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1857 |
23 | 1858 /* return the 8 bit start code value and update the search |
1859 state. Return -1 if no start code found */ | |
1064 | 1860 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end) |
23 | 1861 { |
1064 | 1862 uint8_t *buf_ptr; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1863 unsigned int v, v2; |
23 | 1864 int val; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1865 #ifdef DEBUG |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1866 int skipped=0; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1867 #endif |
23 | 1868 |
1869 buf_ptr = *pbuf_ptr; | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1870 while (buf_ptr < buf_end) { |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1871 v = *buf_ptr++; |
2979 | 1872 v2 = *buf_ptr; |
1619 | 1873 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) { |
2979 | 1874 val = *buf_ptr++; |
1875 goto found; | |
23 | 1876 } |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1877 #ifdef DEBUG |
2979 | 1878 skipped++; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1879 #endif |
23 | 1880 } |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1881 val = -1; |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1882 found: |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1883 #ifdef DEBUG |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1884 dprintf("find_marker skipped %d bytes\n", skipped); |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1885 #endif |
23 | 1886 *pbuf_ptr = buf_ptr; |
1887 return val; | |
1888 } | |
1889 | |
2967 | 1890 static int mjpeg_decode_frame(AVCodecContext *avctx, |
23 | 1891 void *data, int *data_size, |
1064 | 1892 uint8_t *buf, int buf_size) |
23 | 1893 { |
1894 MJpegDecodeContext *s = avctx->priv_data; | |
1064 | 1895 uint8_t *buf_end, *buf_ptr; |
1519 | 1896 int start_code; |
1358 | 1897 AVFrame *picture = data; |
23 | 1898 |
1899 buf_ptr = buf; | |
1900 buf_end = buf + buf_size; | |
1901 while (buf_ptr < buf_end) { | |
1902 /* find start next marker */ | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1903 start_code = find_marker(&buf_ptr, buf_end); |
2979 | 1904 { |
1905 /* EOF */ | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1906 if (start_code < 0) { |
2979 | 1907 goto the_end; |
354 | 1908 } else { |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1909 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr); |
2967 | 1910 |
2979 | 1911 if ((buf_end - buf_ptr) > s->buffer_size) |
1912 { | |
1913 av_free(s->buffer); | |
1914 s->buffer_size = buf_end-buf_ptr; | |
2799
924c7e66ced8
dont pre allocate uselessly large buffer and dont ignore FF_INPUT_BUFFER_PADDING_SIZE
michael
parents:
2798
diff
changeset
|
1915 s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE); |
2979 | 1916 dprintf("buffer too small, expanding to %d bytes\n", |
1917 s->buffer_size); | |
1918 } | |
2967 | 1919 |
3078
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1920 /* unescape buffer of SOS, use special treatment for JPEG-LS */ |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1921 if (start_code == SOS && !s->ls) |
2979 | 1922 { |
1923 uint8_t *src = buf_ptr; | |
1924 uint8_t *dst = s->buffer; | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1925 |
2979 | 1926 while (src<buf_end) |
1927 { | |
1928 uint8_t x = *(src++); | |
832
ff66fdb1d092
fixed some bugs in app parser - some jfif and adobe jpgs fixed
al3x
parents:
811
diff
changeset
|
1929 |
2979 | 1930 *(dst++) = x; |
1931 if (x == 0xff) | |
1932 { | |
2360
0fcb4d572719
workaround apps which dont provided correctly padded streams
michael
parents:
2333
diff
changeset
|
1933 while(src<buf_end && x == 0xff) |
0fcb4d572719
workaround apps which dont provided correctly padded streams
michael
parents:
2333
diff
changeset
|
1934 x = *(src++); |
840 | 1935 |
2979 | 1936 if (x >= 0xd0 && x <= 0xd7) |
1937 *(dst++) = x; | |
1938 else if (x) | |
1939 break; | |
1940 } | |
1941 } | |
1942 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8); | |
2967 | 1943 |
2979 | 1944 dprintf("escaping removed %d bytes\n", |
1945 (buf_end - buf_ptr) - (dst - s->buffer)); | |
1946 } | |
3078
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1947 else if(start_code == SOS && s->ls){ |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1948 uint8_t *src = buf_ptr; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1949 uint8_t *dst = s->buffer; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1950 int bit_count = 0; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1951 int t = 0, b = 0; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1952 PutBitContext pb; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1953 |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1954 s->cur_scan++; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1955 |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1956 /* find marker */ |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1957 while (src + t < buf_end){ |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1958 uint8_t x = src[t++]; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1959 if (x == 0xff){ |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1960 while((src + t < buf_end) && x == 0xff) |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1961 x = src[t++]; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1962 if (x & 0x80) { |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1963 t -= 2; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1964 break; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1965 } |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1966 } |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1967 } |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1968 bit_count = t * 8; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1969 |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1970 init_put_bits(&pb, dst, t); |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1971 |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1972 /* unescape bitstream */ |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1973 while(b < t){ |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1974 uint8_t x = src[b++]; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1975 put_bits(&pb, 8, x); |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1976 if(x == 0xFF){ |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1977 x = src[b++]; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1978 put_bits(&pb, 7, x); |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1979 bit_count--; |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1980 } |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1981 } |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1982 flush_put_bits(&pb); |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1983 |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1984 init_get_bits(&s->gb, dst, bit_count); |
1e63c12c2c71
JPEG-LS codec by (Kostya | kostya.forjunk gmail com)
michael
parents:
3062
diff
changeset
|
1985 } |
2979 | 1986 else |
1987 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8); | |
2967 | 1988 |
2979 | 1989 s->start_code = start_code; |
1310 | 1990 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
|
1991 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code); |
1310 | 1992 } |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
1993 |
2979 | 1994 /* process markers */ |
1995 if (start_code >= 0xd0 && start_code <= 0xd7) { | |
1996 dprintf("restart marker: %d\n", start_code&0x0f); | |
1997 /* APP fields */ | |
1998 } else if (start_code >= APP0 && start_code <= APP15) { | |
1999 mjpeg_decode_app(s); | |
2000 /* Comment */ | |
2001 } else if (start_code == COM){ | |
2002 mjpeg_decode_com(s); | |
2003 } | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2004 |
23 | 2005 switch(start_code) { |
2006 case SOI: | |
2979 | 2007 s->restart_interval = 0; |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2008 |
2979 | 2009 s->restart_count = 0; |
23 | 2010 /* nothing to do on SOI */ |
2011 break; | |
2012 case DQT: | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2013 mjpeg_decode_dqt(s); |
23 | 2014 break; |
2015 case DHT: | |
1351 | 2016 if(mjpeg_decode_dht(s) < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
2017 av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n"); |
1351 | 2018 return -1; |
2019 } | |
23 | 2020 break; |
2021 case SOF0: | |
1307 | 2022 s->lossless=0; |
2967 | 2023 if (mjpeg_decode_sof(s) < 0) |
2979 | 2024 return -1; |
1307 | 2025 break; |
2026 case SOF3: | |
2027 s->lossless=1; | |
2967 | 2028 if (mjpeg_decode_sof(s) < 0) |
2979 | 2029 return -1; |
23 | 2030 break; |
2970
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2031 case SOF48: |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2032 s->lossless=1; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2033 s->ls=1; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2034 if (mjpeg_decode_sof(s) < 0) |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2035 return -1; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2036 break; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2037 case LSE: |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2038 if (decode_lse(s) < 0) |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2039 return -1; |
583b6ac45c07
unfinished jpeg-ls codec (feel free to finish it ...)
michael
parents:
2967
diff
changeset
|
2040 break; |
2979 | 2041 case EOI: |
2042 if ((s->buggy_avid && !s->interlaced) || s->restart_interval) | |
1358 | 2043 break; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2044 eoi_parser: |
2979 | 2045 { |
53 | 2046 if (s->interlaced) { |
2047 s->bottom_field ^= 1; | |
2048 /* if not bottom field, do not output image yet */ | |
2049 if (s->bottom_field) | |
540
4cee7ce37e10
don't exit decoder after decoding first field -> fixes angels.avi interlacing
arpi_esp
parents:
527
diff
changeset
|
2050 goto not_the_end; |
53 | 2051 } |
1513 | 2052 *picture = s->picture; |
1358 | 2053 *data_size = sizeof(AVFrame); |
2054 | |
2055 if(!s->lossless){ | |
2967 | 2056 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); |
1358 | 2057 picture->qstride= 0; |
2058 picture->qscale_table= s->qscale_table; | |
2059 memset(picture->qscale_table, picture->quality, (s->width+15)/16); | |
2060 if(avctx->debug & FF_DEBUG_QP) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
2061 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
|
2062 picture->quality*= FF_QP2LAMBDA; |
1358 | 2063 } |
2967 | 2064 |
23 | 2065 goto the_end; |
2066 } | |
2979 | 2067 break; |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2068 case SOS: |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2069 mjpeg_decode_sos(s); |
2979 | 2070 /* buggy avid puts EOI every 10-20th frame */ |
2071 /* if restart period is over process EOI */ | |
2072 if ((s->buggy_avid && !s->interlaced) || s->restart_interval) | |
2073 goto eoi_parser; | |
2074 break; | |
2075 case DRI: | |
2076 mjpeg_decode_dri(s); | |
23 | 2077 break; |
2979 | 2078 case SOF1: |
2079 case SOF2: | |
2080 case SOF5: | |
2081 case SOF6: | |
2082 case SOF7: | |
2083 case SOF9: | |
2084 case SOF10: | |
2085 case SOF11: | |
2086 case SOF13: | |
2087 case SOF14: | |
2088 case SOF15: | |
2089 case JPG: | |
2090 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code); | |
2091 break; | |
2092 // default: | |
2093 // printf("mjpeg: unsupported marker (%x)\n", start_code); | |
2094 // break; | |
23 | 2095 } |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2096 |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2097 not_the_end: |
2979 | 2098 /* eof process start code */ |
2099 buf_ptr += (get_bits_count(&s->gb)+7)/8; | |
2100 dprintf("marker parser used %d bytes (%d bits)\n", | |
2101 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb)); | |
23 | 2102 } |
2103 } | |
2104 } | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2105 the_end: |
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2106 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
|
2107 // return buf_end - buf_ptr; |
23 | 2108 return buf_ptr - buf; |
2109 } | |
2110 | |
2967 | 2111 static int mjpegb_decode_frame(AVCodecContext *avctx, |
881 | 2112 void *data, int *data_size, |
1064 | 2113 uint8_t *buf, int buf_size) |
881 | 2114 { |
2115 MJpegDecodeContext *s = avctx->priv_data; | |
1064 | 2116 uint8_t *buf_end, *buf_ptr; |
1358 | 2117 AVFrame *picture = data; |
881 | 2118 GetBitContext hgb; /* for the header */ |
2119 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
|
2120 uint32_t field_size, sod_offs; |
881 | 2121 |
2122 buf_ptr = buf; | |
2123 buf_end = buf + buf_size; | |
2967 | 2124 |
881 | 2125 read_header: |
2126 /* reset on every SOI */ | |
2127 s->restart_interval = 0; | |
2802
4db6127e20b8
reset restart_count when restart_interval is set and fill the
reimar
parents:
2799
diff
changeset
|
2128 s->restart_count = 0; |
2333
816185a9594a
Fix mjpeg-b (padding bytes can exist between end of sos and image data)
rtognimp
parents:
2319
diff
changeset
|
2129 s->mjpb_skiptosod = 0; |
881 | 2130 |
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
|
2131 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8); |
881 | 2132 |
2133 skip_bits(&hgb, 32); /* reserved zeros */ | |
2967 | 2134 |
2173 | 2135 if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg"))) |
881 | 2136 { |
2979 | 2137 dprintf("not mjpeg-b (bad fourcc)\n"); |
2138 return 0; | |
881 | 2139 } |
2140 | |
2173 | 2141 field_size = get_bits_long(&hgb, 32); /* field size */ |
881 | 2142 dprintf("field size: 0x%x\n", field_size); |
2143 skip_bits(&hgb, 32); /* padded field size */ | |
2173 | 2144 second_field_offs = get_bits_long(&hgb, 32); |
881 | 2145 dprintf("second field offs: 0x%x\n", second_field_offs); |
2146 if (second_field_offs) | |
2979 | 2147 s->interlaced = 1; |
881 | 2148 |
2173 | 2149 dqt_offs = get_bits_long(&hgb, 32); |
881 | 2150 dprintf("dqt offs: 0x%x\n", dqt_offs); |
2151 if (dqt_offs) | |
2152 { | |
2979 | 2153 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8); |
2154 s->start_code = DQT; | |
2155 mjpeg_decode_dqt(s); | |
881 | 2156 } |
2967 | 2157 |
2173 | 2158 dht_offs = get_bits_long(&hgb, 32); |
881 | 2159 dprintf("dht offs: 0x%x\n", dht_offs); |
2160 if (dht_offs) | |
2161 { | |
2979 | 2162 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8); |
2163 s->start_code = DHT; | |
2164 mjpeg_decode_dht(s); | |
881 | 2165 } |
2166 | |
2173 | 2167 sof_offs = get_bits_long(&hgb, 32); |
881 | 2168 dprintf("sof offs: 0x%x\n", sof_offs); |
2169 if (sof_offs) | |
2170 { | |
2979 | 2171 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8); |
2172 s->start_code = SOF0; | |
2173 if (mjpeg_decode_sof(s) < 0) | |
2174 return -1; | |
881 | 2175 } |
2176 | |
2173 | 2177 sos_offs = get_bits_long(&hgb, 32); |
881 | 2178 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
|
2179 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
|
2180 dprintf("sod offs: 0x%x\n", sod_offs); |
881 | 2181 if (sos_offs) |
2182 { | |
2979 | 2183 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8); |
2184 init_get_bits(&s->gb, buf+sos_offs, field_size*8); | |
2185 s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16)); | |
2186 s->start_code = SOS; | |
2187 mjpeg_decode_sos(s); | |
881 | 2188 } |
2189 | |
2190 if (s->interlaced) { | |
2191 s->bottom_field ^= 1; | |
2192 /* if not bottom field, do not output image yet */ | |
2193 if (s->bottom_field && second_field_offs) | |
2979 | 2194 { |
2195 buf_ptr = buf + second_field_offs; | |
2196 second_field_offs = 0; | |
2197 goto read_header; | |
2198 } | |
881 | 2199 } |
2200 | |
1358 | 2201 //XXX FIXME factorize, this looks very similar to the EOI code |
1513 | 2202 |
2203 *picture= s->picture; | |
1358 | 2204 *data_size = sizeof(AVFrame); |
2967 | 2205 |
1358 | 2206 if(!s->lossless){ |
2967 | 2207 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); |
1358 | 2208 picture->qstride= 0; |
2209 picture->qscale_table= s->qscale_table; | |
2210 memset(picture->qscale_table, picture->quality, (s->width+15)/16); | |
2211 if(avctx->debug & FF_DEBUG_QP) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1560
diff
changeset
|
2212 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
|
2213 picture->quality*= FF_QP2LAMBDA; |
1358 | 2214 } |
881 | 2215 |
2216 return buf_ptr - buf; | |
2217 } | |
2218 | |
1519 | 2219 #include "sp5x.h" |
2220 | |
2967 | 2221 static int sp5x_decode_frame(AVCodecContext *avctx, |
1519 | 2222 void *data, int *data_size, |
2223 uint8_t *buf, int buf_size) | |
2224 { | |
2225 #if 0 | |
2226 MJpegDecodeContext *s = avctx->priv_data; | |
2227 #endif | |
2228 const int qscale = 5; | |
2229 uint8_t *buf_ptr, *buf_end, *recoded; | |
2230 int i = 0, j = 0; | |
2231 | |
2232 if (!avctx->width || !avctx->height) | |
2979 | 2233 return -1; |
1519 | 2234 |
2235 buf_ptr = buf; | |
2236 buf_end = buf + buf_size; | |
2237 | |
2238 #if 1 | |
2239 recoded = av_mallocz(buf_size + 1024); | |
2240 if (!recoded) | |
2979 | 2241 return -1; |
1519 | 2242 |
2243 /* SOI */ | |
2244 recoded[j++] = 0xFF; | |
2245 recoded[j++] = 0xD8; | |
2246 | |
2247 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt)); | |
2248 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64); | |
2249 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64); | |
2250 j += sizeof(sp5x_data_dqt); | |
2251 | |
2252 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht)); | |
2253 j += sizeof(sp5x_data_dht); | |
2254 | |
2255 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof)); | |
2270 | 2256 recoded[j+5] = (avctx->coded_height >> 8) & 0xFF; |
2257 recoded[j+6] = avctx->coded_height & 0xFF; | |
2258 recoded[j+7] = (avctx->coded_width >> 8) & 0xFF; | |
2259 recoded[j+8] = avctx->coded_width & 0xFF; | |
1519 | 2260 j += sizeof(sp5x_data_sof); |
2261 | |
2262 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos)); | |
2263 j += sizeof(sp5x_data_sos); | |
2264 | |
1548 | 2265 for (i = 14; i < buf_size && j < buf_size+1024-2; i++) |
1519 | 2266 { |
2979 | 2267 recoded[j++] = buf[i]; |
2268 if (buf[i] == 0xff) | |
2269 recoded[j++] = 0; | |
1519 | 2270 } |
2271 | |
2272 /* EOI */ | |
2273 recoded[j++] = 0xFF; | |
2274 recoded[j++] = 0xD9; | |
2275 | |
2276 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j); | |
2277 | |
2278 av_free(recoded); | |
2279 | |
2280 #else | |
2281 /* SOF */ | |
2282 s->bits = 8; | |
2270 | 2283 s->width = avctx->coded_width; |
2284 s->height = avctx->coded_height; | |
1519 | 2285 s->nb_components = 3; |
2286 s->component_id[0] = 0; | |
2287 s->h_count[0] = 2; | |
2288 s->v_count[0] = 2; | |
2289 s->quant_index[0] = 0; | |
2290 s->component_id[1] = 1; | |
2291 s->h_count[1] = 1; | |
2292 s->v_count[1] = 1; | |
2293 s->quant_index[1] = 1; | |
2294 s->component_id[2] = 2; | |
2295 s->h_count[2] = 1; | |
2296 s->v_count[2] = 1; | |
2297 s->quant_index[2] = 1; | |
2298 s->h_max = 2; | |
2299 s->v_max = 2; | |
2967 | 2300 |
1519 | 2301 s->qscale_table = av_mallocz((s->width+15)/16); |
2442 | 2302 avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420; |
1519 | 2303 s->interlaced = 0; |
2967 | 2304 |
1519 | 2305 s->picture.reference = 0; |
2306 if (avctx->get_buffer(avctx, &s->picture) < 0) | |
2307 { | |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2802
diff
changeset
|
2308 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
2979 | 2309 return -1; |
1519 | 2310 } |
2311 | |
2312 s->picture.pict_type = I_TYPE; | |
2313 s->picture.key_frame = 1; | |
2314 | |
2315 for (i = 0; i < 3; i++) | |
2979 | 2316 s->linesize[i] = s->picture.linesize[i] << s->interlaced; |
1519 | 2317 |
2318 /* DQT */ | |
2319 for (i = 0; i < 64; i++) | |
2320 { | |
2979 | 2321 j = s->scantable.permutated[i]; |
2322 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i]; | |
1519 | 2323 } |
2324 s->qscale[0] = FFMAX( | |
2979 | 2325 s->quant_matrixes[0][s->scantable.permutated[1]], |
2326 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1; | |
1519 | 2327 |
2328 for (i = 0; i < 64; i++) | |
2329 { | |
2979 | 2330 j = s->scantable.permutated[i]; |
2331 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i]; | |
1519 | 2332 } |
2333 s->qscale[1] = FFMAX( | |
2979 | 2334 s->quant_matrixes[1][s->scantable.permutated[1]], |
2335 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1; | |
1519 | 2336 |
2337 /* DHT */ | |
2338 | |
2339 /* SOS */ | |
2340 s->comp_index[0] = 0; | |
2341 s->nb_blocks[0] = s->h_count[0] * s->v_count[0]; | |
2342 s->h_scount[0] = s->h_count[0]; | |
2343 s->v_scount[0] = s->v_count[0]; | |
2344 s->dc_index[0] = 0; | |
2345 s->ac_index[0] = 0; | |
2346 | |
2347 s->comp_index[1] = 1; | |
2348 s->nb_blocks[1] = s->h_count[1] * s->v_count[1]; | |
2349 s->h_scount[1] = s->h_count[1]; | |
2350 s->v_scount[1] = s->v_count[1]; | |
2351 s->dc_index[1] = 1; | |
2352 s->ac_index[1] = 1; | |
2353 | |
2354 s->comp_index[2] = 2; | |
2355 s->nb_blocks[2] = s->h_count[2] * s->v_count[2]; | |
2356 s->h_scount[2] = s->h_count[2]; | |
2357 s->v_scount[2] = s->v_count[2]; | |
2358 s->dc_index[2] = 1; | |
2359 s->ac_index[2] = 1; | |
2967 | 2360 |
1519 | 2361 for (i = 0; i < 3; i++) |
2979 | 2362 s->last_dc[i] = 1024; |
1519 | 2363 |
2364 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8); | |
2365 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8); | |
2366 | |
1560 | 2367 init_get_bits(&s->gb, buf+14, (buf_size-14)*8); |
2967 | 2368 |
1519 | 2369 return mjpeg_decode_scan(s); |
2370 #endif | |
2371 | |
2372 return i; | |
2373 } | |
881 | 2374 |
23 | 2375 static int mjpeg_decode_end(AVCodecContext *avctx) |
2376 { | |
2377 MJpegDecodeContext *s = avctx->priv_data; | |
2378 int i, j; | |
2379 | |
775
e96776e1d2ae
reworked decode_frame marker searching, fixes many non-working samples
al3x
parents:
706
diff
changeset
|
2380 av_free(s->buffer); |
1358 | 2381 av_free(s->qscale_table); |
2967 | 2382 |
23 | 2383 for(i=0;i<2;i++) { |
2384 for(j=0;j<4;j++) | |
2385 free_vlc(&s->vlcs[i][j]); | |
2386 } | |
2387 return 0; | |
2388 } | |
2389 | |
2390 AVCodec mjpeg_decoder = { | |
2391 "mjpeg", | |
2392 CODEC_TYPE_VIDEO, | |
2393 CODEC_ID_MJPEG, | |
2394 sizeof(MJpegDecodeContext), | |
2395 mjpeg_decode_init, | |
2396 NULL, | |
2397 mjpeg_decode_end, | |
2398 mjpeg_decode_frame, | |
1513 | 2399 CODEC_CAP_DR1, |
369
c60869851bb4
added support for various app headers, and writin FFmpeg comment
al3x
parents:
357
diff
changeset
|
2400 NULL |
23 | 2401 }; |
881 | 2402 |
2403 AVCodec mjpegb_decoder = { | |
2404 "mjpegb", | |
2405 CODEC_TYPE_VIDEO, | |
2406 CODEC_ID_MJPEGB, | |
2407 sizeof(MJpegDecodeContext), | |
2408 mjpeg_decode_init, | |
2409 NULL, | |
2410 mjpeg_decode_end, | |
2411 mjpegb_decode_frame, | |
1513 | 2412 CODEC_CAP_DR1, |
881 | 2413 NULL |
2414 }; | |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2415 |
1519 | 2416 AVCodec sp5x_decoder = { |
2417 "sp5x", | |
2418 CODEC_TYPE_VIDEO, | |
2419 CODEC_ID_SP5X, | |
2420 sizeof(MJpegDecodeContext), | |
2421 mjpeg_decode_init, | |
2422 NULL, | |
2423 mjpeg_decode_end, | |
2424 sp5x_decode_frame, | |
2425 CODEC_CAP_DR1, | |
2426 NULL | |
2427 }; | |
2428 | |
1325 | 2429 #ifdef CONFIG_ENCODERS |
1315
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2430 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
|
2431 "ljpeg", |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2432 CODEC_TYPE_VIDEO, |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2433 CODEC_ID_LJPEG, |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2434 sizeof(MpegEncContext), |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2435 MPV_encode_init, |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2436 encode_picture_lossless, |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2437 MPV_encode_end, |
6696d3bf4ff2
lossless mjpeg encoding (planar yuv & RGB) and somerelated bugfixes
michaelni
parents:
1312
diff
changeset
|
2438 }; |
1325 | 2439 #endif |
2319 | 2440 |
2441 AVCodecParser mjpeg_parser = { | |
2442 { CODEC_ID_MJPEG }, | |
2443 sizeof(ParseContext), | |
2444 NULL, | |
2445 jpeg_parse, | |
2446 ff_parse_close, | |
2447 }; | |
2448 |