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