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