Mercurial > libavcodec.hg
annotate svq1dec.c @ 12197:fbf4d5b1b664 libavcodec
Remove FF_MM_SSE2/3 flags for CPUs where this is generally not faster than
regular MMX code. Examples of this are the Core1 CPU. Instead, set a new flag,
FF_MM_SSE2/3SLOW, which can be checked for particular SSE2/3 functions that
have been checked specifically on such CPUs and are actually faster than
their MMX counterparts.
In addition, use this flag to enable particular VP8 and LPC SSE2 functions
that are faster than their MMX counterparts.
Based on a patch by Loren Merritt <lorenm AT u washington edu>.
author | rbultje |
---|---|
date | Mon, 19 Jul 2010 22:38:23 +0000 |
parents | 670516285e58 |
children |
rev | line source |
---|---|
5233 | 1 /* |
2 * SVQ1 decoder | |
3 * ported to MPlayer by Arpi <arpi@thot.banki.hu> | |
4 * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru> | |
5 * | |
6 * Copyright (C) 2002 the xine project | |
7 * Copyright (C) 2002 the ffmpeg project | |
8 * | |
9 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net> | |
10 * | |
11 * This file is part of FFmpeg. | |
12 * | |
13 * FFmpeg is free software; you can redistribute it and/or | |
14 * modify it under the terms of the GNU Lesser General Public | |
15 * License as published by the Free Software Foundation; either | |
16 * version 2.1 of the License, or (at your option) any later version. | |
17 * | |
18 * FFmpeg is distributed in the hope that it will be useful, | |
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
21 * Lesser General Public License for more details. | |
22 * | |
23 * You should have received a copy of the GNU Lesser General Public | |
24 * License along with FFmpeg; if not, write to the Free Software | |
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
26 */ | |
27 | |
28 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11560
diff
changeset
|
29 * @file |
5233 | 30 * Sorenson Vector Quantizer #1 (SVQ1) video codec. |
31 * For more information of the SVQ1 algorithm, visit: | |
32 * http://www.pcisys.net/~melanson/codecs/ | |
33 */ | |
34 | |
35 | |
36 //#define DEBUG_SVQ1 | |
37 #include "avcodec.h" | |
38 #include "dsputil.h" | |
39 #include "mpegvideo.h" | |
8627
d6bab465b82c
moves mid_pred() into mathops.h (with arch specific code split by directory)
aurel
parents:
8318
diff
changeset
|
40 #include "mathops.h" |
5233 | 41 |
42 #include "svq1.h" | |
43 | |
44 #undef NDEBUG | |
45 #include <assert.h> | |
46 | |
47 extern const uint8_t mvtab[33][2]; | |
48 | |
49 static VLC svq1_block_type; | |
50 static VLC svq1_motion_component; | |
51 static VLC svq1_intra_multistage[6]; | |
52 static VLC svq1_inter_multistage[6]; | |
53 static VLC svq1_intra_mean; | |
54 static VLC svq1_inter_mean; | |
55 | |
56 /* motion vector (prediction) */ | |
57 typedef struct svq1_pmv_s { | |
58 int x; | |
59 int y; | |
8318
bc36a075bf35
The POSIX namespace shall be held sacrosanct. To that end,
melanson
parents:
8026
diff
changeset
|
60 } svq1_pmv; |
5233 | 61 |
62 static const uint16_t checksum_table[256] = { | |
63 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, | |
64 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, | |
65 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, | |
66 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, | |
67 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, | |
68 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, | |
69 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, | |
70 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, | |
71 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, | |
72 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, | |
73 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, | |
74 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, | |
75 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, | |
76 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, | |
77 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, | |
78 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, | |
79 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, | |
80 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, | |
81 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, | |
82 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, | |
83 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, | |
84 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, | |
85 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, | |
86 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, | |
87 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, | |
88 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, | |
89 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, | |
90 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, | |
91 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, | |
92 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, | |
93 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, | |
94 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 | |
95 }; | |
96 | |
97 static const uint8_t string_table[256] = { | |
98 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54, | |
99 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D, | |
100 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06, | |
101 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F, | |
102 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0, | |
103 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9, | |
104 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2, | |
105 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B, | |
106 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9, | |
107 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0, | |
108 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B, | |
109 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2, | |
110 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D, | |
111 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44, | |
112 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F, | |
113 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16, | |
114 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB, | |
115 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92, | |
116 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9, | |
117 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0, | |
118 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F, | |
119 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36, | |
120 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D, | |
121 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64, | |
122 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26, | |
123 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F, | |
124 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74, | |
125 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D, | |
126 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82, | |
127 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB, | |
128 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0, | |
129 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9 | |
130 }; | |
131 | |
132 #define SVQ1_PROCESS_VECTOR()\ | |
133 for (; level > 0; i++) {\ | |
134 /* process next depth */\ | |
135 if (i == m) {\ | |
136 m = n;\ | |
137 if (--level == 0)\ | |
138 break;\ | |
139 }\ | |
140 /* divide block if next bit set */\ | |
5513 | 141 if (get_bits1 (bitbuf) == 0)\ |
5233 | 142 break;\ |
143 /* add child nodes */\ | |
144 list[n++] = list[i];\ | |
145 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\ | |
146 } | |
147 | |
148 #define SVQ1_ADD_CODEBOOK()\ | |
149 /* add codebook entries to vector */\ | |
150 for (j=0; j < stages; j++) {\ | |
151 n3 = codebook[entries[j]] ^ 0x80808080;\ | |
152 n1 += ((n3 & 0xFF00FF00) >> 8);\ | |
153 n2 += (n3 & 0x00FF00FF);\ | |
154 }\ | |
155 \ | |
156 /* clip to [0..255] */\ | |
157 if (n1 & 0xFF00FF00) {\ | |
158 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ | |
159 n1 += 0x7F007F00;\ | |
160 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ | |
161 n1 &= (n3 & 0x00FF00FF);\ | |
162 }\ | |
163 \ | |
164 if (n2 & 0xFF00FF00) {\ | |
165 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ | |
166 n2 += 0x7F007F00;\ | |
167 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ | |
168 n2 &= (n3 & 0x00FF00FF);\ | |
169 } | |
170 | |
171 #define SVQ1_DO_CODEBOOK_INTRA()\ | |
172 for (y=0; y < height; y++) {\ | |
173 for (x=0; x < (width / 4); x++, codebook++) {\ | |
174 n1 = n4;\ | |
175 n2 = n4;\ | |
176 SVQ1_ADD_CODEBOOK()\ | |
177 /* store result */\ | |
178 dst[x] = (n1 << 8) | n2;\ | |
179 }\ | |
180 dst += (pitch / 4);\ | |
181 } | |
182 | |
183 #define SVQ1_DO_CODEBOOK_NONINTRA()\ | |
184 for (y=0; y < height; y++) {\ | |
185 for (x=0; x < (width / 4); x++, codebook++) {\ | |
186 n3 = dst[x];\ | |
187 /* add mean value to vector */\ | |
188 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\ | |
189 n2 = (n3 & 0x00FF00FF) + n4;\ | |
190 SVQ1_ADD_CODEBOOK()\ | |
191 /* store result */\ | |
192 dst[x] = (n1 << 8) | n2;\ | |
193 }\ | |
194 dst += (pitch / 4);\ | |
195 } | |
196 | |
197 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\ | |
198 codebook = (const uint32_t *) cbook[level];\ | |
199 bit_cache = get_bits (bitbuf, 4*stages);\ | |
200 /* calculate codebook entries for this vector */\ | |
201 for (j=0; j < stages; j++) {\ | |
202 entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\ | |
203 }\ | |
204 mean -= (stages * 128);\ | |
205 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF); | |
206 | |
207 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) { | |
208 uint32_t bit_cache; | |
209 uint8_t *list[63]; | |
210 uint32_t *dst; | |
211 const uint32_t *codebook; | |
212 int entries[6]; | |
213 int i, j, m, n; | |
214 int mean, stages; | |
215 unsigned x, y, width, height, level; | |
216 uint32_t n1, n2, n3, n4; | |
217 | |
218 /* initialize list for breadth first processing of vectors */ | |
219 list[0] = pixels; | |
220 | |
221 /* recursively process vector */ | |
222 for (i=0, m=1, n=1, level=5; i < n; i++) { | |
223 SVQ1_PROCESS_VECTOR(); | |
224 | |
225 /* destination address and vector size */ | |
226 dst = (uint32_t *) list[i]; | |
227 width = 1 << ((4 + level) /2); | |
228 height = 1 << ((3 + level) /2); | |
229 | |
230 /* get number of stages (-1 skips vector, 0 for mean only) */ | |
231 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1; | |
232 | |
233 if (stages == -1) { | |
234 for (y=0; y < height; y++) { | |
235 memset (&dst[y*(pitch / 4)], 0, width); | |
236 } | |
237 continue; /* skip vector */ | |
238 } | |
239 | |
240 if ((stages > 0) && (level >= 4)) { | |
241 #ifdef DEBUG_SVQ1 | |
242 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level); | |
243 #endif | |
244 return -1; /* invalid vector */ | |
245 } | |
246 | |
247 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3); | |
248 | |
249 if (stages == 0) { | |
250 for (y=0; y < height; y++) { | |
251 memset (&dst[y*(pitch / 4)], mean, width); | |
252 } | |
253 } else { | |
254 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks); | |
255 SVQ1_DO_CODEBOOK_INTRA() | |
256 } | |
257 } | |
258 | |
259 return 0; | |
260 } | |
261 | |
262 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) { | |
263 uint32_t bit_cache; | |
264 uint8_t *list[63]; | |
265 uint32_t *dst; | |
266 const uint32_t *codebook; | |
267 int entries[6]; | |
268 int i, j, m, n; | |
269 int mean, stages; | |
270 int x, y, width, height, level; | |
271 uint32_t n1, n2, n3, n4; | |
272 | |
273 /* initialize list for breadth first processing of vectors */ | |
274 list[0] = pixels; | |
275 | |
276 /* recursively process vector */ | |
277 for (i=0, m=1, n=1, level=5; i < n; i++) { | |
278 SVQ1_PROCESS_VECTOR(); | |
279 | |
280 /* destination address and vector size */ | |
281 dst = (uint32_t *) list[i]; | |
282 width = 1 << ((4 + level) /2); | |
283 height = 1 << ((3 + level) /2); | |
284 | |
285 /* get number of stages (-1 skips vector, 0 for mean only) */ | |
286 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1; | |
287 | |
288 if (stages == -1) continue; /* skip vector */ | |
289 | |
290 if ((stages > 0) && (level >= 4)) { | |
291 #ifdef DEBUG_SVQ1 | |
292 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level); | |
293 #endif | |
294 return -1; /* invalid vector */ | |
295 } | |
296 | |
297 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256; | |
298 | |
299 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks); | |
300 SVQ1_DO_CODEBOOK_NONINTRA() | |
301 } | |
302 return 0; | |
303 } | |
304 | |
8318
bc36a075bf35
The POSIX namespace shall be held sacrosanct. To that end,
melanson
parents:
8026
diff
changeset
|
305 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv) { |
5233 | 306 int diff; |
307 int i; | |
308 | |
309 for (i=0; i < 2; i++) { | |
310 | |
311 /* get motion code */ | |
312 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2); | |
313 if(diff<0) | |
314 return -1; | |
315 else if(diff){ | |
316 if(get_bits1(bitbuf)) diff= -diff; | |
317 } | |
318 | |
319 /* add median of motion vector predictors and clip result */ | |
320 if (i == 1) | |
321 mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26; | |
322 else | |
323 mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26; | |
324 } | |
325 | |
326 return 0; | |
327 } | |
328 | |
329 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) { | |
330 uint8_t *src; | |
331 uint8_t *dst; | |
332 int i; | |
333 | |
334 src = &previous[x + y*pitch]; | |
335 dst = current; | |
336 | |
337 for (i=0; i < 16; i++) { | |
338 memcpy (dst, src, 16); | |
339 src += pitch; | |
340 dst += pitch; | |
341 } | |
342 } | |
343 | |
344 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf, | |
345 uint8_t *current, uint8_t *previous, int pitch, | |
8318
bc36a075bf35
The POSIX namespace shall be held sacrosanct. To that end,
melanson
parents:
8026
diff
changeset
|
346 svq1_pmv *motion, int x, int y) { |
5233 | 347 uint8_t *src; |
348 uint8_t *dst; | |
8318
bc36a075bf35
The POSIX namespace shall be held sacrosanct. To that end,
melanson
parents:
8026
diff
changeset
|
349 svq1_pmv mv; |
bc36a075bf35
The POSIX namespace shall be held sacrosanct. To that end,
melanson
parents:
8026
diff
changeset
|
350 svq1_pmv *pmv[3]; |
5233 | 351 int result; |
352 | |
353 /* predict and decode motion vector */ | |
354 pmv[0] = &motion[0]; | |
355 if (y == 0) { | |
356 pmv[1] = | |
357 pmv[2] = pmv[0]; | |
358 } | |
359 else { | |
360 pmv[1] = &motion[(x / 8) + 2]; | |
361 pmv[2] = &motion[(x / 8) + 4]; | |
362 } | |
363 | |
364 result = svq1_decode_motion_vector (bitbuf, &mv, pmv); | |
365 | |
366 if (result != 0) | |
367 return result; | |
368 | |
369 motion[0].x = | |
370 motion[(x / 8) + 2].x = | |
371 motion[(x / 8) + 3].x = mv.x; | |
372 motion[0].y = | |
373 motion[(x / 8) + 2].y = | |
374 motion[(x / 8) + 3].y = mv.y; | |
375 | |
376 if(y + (mv.y >> 1)<0) | |
377 mv.y= 0; | |
378 if(x + (mv.x >> 1)<0) | |
379 mv.x= 0; | |
380 | |
381 #if 0 | |
382 int w= (s->width+15)&~15; | |
383 int h= (s->height+15)&~15; | |
384 if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h) | |
385 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1)); | |
386 #endif | |
387 | |
388 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch]; | |
389 dst = current; | |
390 | |
391 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16); | |
392 | |
393 return 0; | |
394 } | |
395 | |
396 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf, | |
397 uint8_t *current, uint8_t *previous, int pitch, | |
8318
bc36a075bf35
The POSIX namespace shall be held sacrosanct. To that end,
melanson
parents:
8026
diff
changeset
|
398 svq1_pmv *motion,int x, int y) { |
5233 | 399 uint8_t *src; |
400 uint8_t *dst; | |
8318
bc36a075bf35
The POSIX namespace shall be held sacrosanct. To that end,
melanson
parents:
8026
diff
changeset
|
401 svq1_pmv mv; |
bc36a075bf35
The POSIX namespace shall be held sacrosanct. To that end,
melanson
parents:
8026
diff
changeset
|
402 svq1_pmv *pmv[4]; |
5233 | 403 int i, result; |
404 | |
405 /* predict and decode motion vector (0) */ | |
406 pmv[0] = &motion[0]; | |
407 if (y == 0) { | |
408 pmv[1] = | |
409 pmv[2] = pmv[0]; | |
410 } | |
411 else { | |
412 pmv[1] = &motion[(x / 8) + 2]; | |
413 pmv[2] = &motion[(x / 8) + 4]; | |
414 } | |
415 | |
416 result = svq1_decode_motion_vector (bitbuf, &mv, pmv); | |
417 | |
418 if (result != 0) | |
419 return result; | |
420 | |
421 /* predict and decode motion vector (1) */ | |
422 pmv[0] = &mv; | |
423 if (y == 0) { | |
424 pmv[1] = | |
425 pmv[2] = pmv[0]; | |
426 } | |
427 else { | |
428 pmv[1] = &motion[(x / 8) + 3]; | |
429 } | |
430 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv); | |
431 | |
432 if (result != 0) | |
433 return result; | |
434 | |
435 /* predict and decode motion vector (2) */ | |
436 pmv[1] = &motion[0]; | |
437 pmv[2] = &motion[(x / 8) + 1]; | |
438 | |
439 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv); | |
440 | |
441 if (result != 0) | |
442 return result; | |
443 | |
444 /* predict and decode motion vector (3) */ | |
445 pmv[2] = &motion[(x / 8) + 2]; | |
446 pmv[3] = &motion[(x / 8) + 3]; | |
447 | |
448 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv); | |
449 | |
450 if (result != 0) | |
451 return result; | |
452 | |
453 /* form predictions */ | |
454 for (i=0; i < 4; i++) { | |
455 int mvx= pmv[i]->x + (i&1)*16; | |
456 int mvy= pmv[i]->y + (i>>1)*16; | |
457 | |
458 ///XXX /FIXME clipping or padding? | |
459 if(y + (mvy >> 1)<0) | |
460 mvy= 0; | |
461 if(x + (mvx >> 1)<0) | |
462 mvx= 0; | |
463 | |
464 #if 0 | |
465 int w= (s->width+15)&~15; | |
466 int h= (s->height+15)&~15; | |
467 if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h) | |
468 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1)); | |
469 #endif | |
470 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch]; | |
471 dst = current; | |
472 | |
473 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8); | |
474 | |
475 /* select next block */ | |
476 if (i & 1) { | |
477 current += 8*(pitch - 1); | |
478 } else { | |
479 current += 8; | |
480 } | |
481 } | |
482 | |
483 return 0; | |
484 } | |
485 | |
486 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf, | |
487 uint8_t *current, uint8_t *previous, int pitch, | |
8318
bc36a075bf35
The POSIX namespace shall be held sacrosanct. To that end,
melanson
parents:
8026
diff
changeset
|
488 svq1_pmv *motion, int x, int y) { |
5233 | 489 uint32_t block_type; |
490 int result = 0; | |
491 | |
492 /* get block type */ | |
493 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2); | |
494 | |
495 /* reset motion vectors */ | |
496 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) { | |
497 motion[0].x = | |
498 motion[0].y = | |
499 motion[(x / 8) + 2].x = | |
500 motion[(x / 8) + 2].y = | |
501 motion[(x / 8) + 3].x = | |
502 motion[(x / 8) + 3].y = 0; | |
503 } | |
504 | |
505 switch (block_type) { | |
506 case SVQ1_BLOCK_SKIP: | |
507 svq1_skip_block (current, previous, pitch, x, y); | |
508 break; | |
509 | |
510 case SVQ1_BLOCK_INTER: | |
511 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y); | |
512 | |
513 if (result != 0) | |
514 { | |
515 #ifdef DEBUG_SVQ1 | |
516 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result); | |
517 #endif | |
518 break; | |
519 } | |
520 result = svq1_decode_block_non_intra (bitbuf, current, pitch); | |
521 break; | |
522 | |
523 case SVQ1_BLOCK_INTER_4V: | |
524 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y); | |
525 | |
526 if (result != 0) | |
527 { | |
528 #ifdef DEBUG_SVQ1 | |
529 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result); | |
530 #endif | |
531 break; | |
532 } | |
533 result = svq1_decode_block_non_intra (bitbuf, current, pitch); | |
534 break; | |
535 | |
536 case SVQ1_BLOCK_INTRA: | |
537 result = svq1_decode_block_intra (bitbuf, current, pitch); | |
538 break; | |
539 } | |
540 | |
541 return result; | |
542 } | |
543 | |
8026
f693666fbf9f
Export svq1_packet_checksum() that is needed for svq3 watermarks,
michael
parents:
7040
diff
changeset
|
544 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) { |
5233 | 545 int i; |
546 | |
547 for (i=0; i < length; i++) { | |
548 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8); | |
549 } | |
550 | |
551 return value; | |
552 } | |
553 | |
554 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) { | |
555 uint8_t seed; | |
556 int i; | |
557 | |
558 out[0] = get_bits (bitbuf, 8); | |
559 | |
560 seed = string_table[out[0]]; | |
561 | |
562 for (i=1; i <= out[0]; i++) { | |
563 out[i] = get_bits (bitbuf, 8) ^ seed; | |
564 seed = string_table[out[i] ^ seed]; | |
565 } | |
566 } | |
567 | |
568 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) { | |
569 int frame_size_code; | |
570 int temporal_reference; | |
571 | |
572 temporal_reference = get_bits (bitbuf, 8); | |
573 | |
574 /* frame type */ | |
575 s->pict_type= get_bits (bitbuf, 2)+1; | |
576 if(s->pict_type==4) | |
577 return -1; | |
578 | |
6481 | 579 if (s->pict_type == FF_I_TYPE) { |
5233 | 580 |
581 /* unknown fields */ | |
582 if (s->f_code == 0x50 || s->f_code == 0x60) { | |
583 int csum = get_bits (bitbuf, 16); | |
584 | |
8026
f693666fbf9f
Export svq1_packet_checksum() that is needed for svq3 watermarks,
michael
parents:
7040
diff
changeset
|
585 csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum); |
5233 | 586 |
587 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n", | |
588 // (csum == 0) ? "correct" : "incorrect", csum); | |
589 } | |
590 | |
591 if ((s->f_code ^ 0x10) >= 0x50) { | |
592 uint8_t msg[256]; | |
593 | |
594 svq1_parse_string (bitbuf, msg); | |
595 | |
596 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg); | |
597 } | |
598 | |
599 skip_bits (bitbuf, 2); | |
600 skip_bits (bitbuf, 2); | |
601 skip_bits1 (bitbuf); | |
602 | |
603 /* load frame size */ | |
604 frame_size_code = get_bits (bitbuf, 3); | |
605 | |
606 if (frame_size_code == 7) { | |
607 /* load width, height (12 bits each) */ | |
608 s->width = get_bits (bitbuf, 12); | |
609 s->height = get_bits (bitbuf, 12); | |
610 | |
611 if (!s->width || !s->height) | |
612 return -1; | |
613 } else { | |
614 /* get width, height from table */ | |
615 s->width = ff_svq1_frame_size_table[frame_size_code].width; | |
616 s->height = ff_svq1_frame_size_table[frame_size_code].height; | |
617 } | |
618 } | |
619 | |
620 /* unknown fields */ | |
5513 | 621 if (get_bits1 (bitbuf) == 1) { |
5233 | 622 skip_bits1 (bitbuf); /* use packet checksum if (1) */ |
623 skip_bits1 (bitbuf); /* component checksums after image data if (1) */ | |
624 | |
625 if (get_bits (bitbuf, 2) != 0) | |
626 return -1; | |
627 } | |
628 | |
5513 | 629 if (get_bits1 (bitbuf) == 1) { |
5233 | 630 skip_bits1 (bitbuf); |
631 skip_bits (bitbuf, 4); | |
632 skip_bits1 (bitbuf); | |
633 skip_bits (bitbuf, 2); | |
634 | |
5513 | 635 while (get_bits1 (bitbuf) == 1) { |
5233 | 636 skip_bits (bitbuf, 8); |
637 } | |
638 } | |
639 | |
640 return 0; | |
641 } | |
642 | |
643 static int svq1_decode_frame(AVCodecContext *avctx, | |
644 void *data, int *data_size, | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
645 AVPacket *avpkt) |
5233 | 646 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
647 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
648 int buf_size = avpkt->size; |
5233 | 649 MpegEncContext *s=avctx->priv_data; |
650 uint8_t *current, *previous; | |
651 int result, i, x, y, width, height; | |
652 AVFrame *pict = data; | |
11960 | 653 svq1_pmv *pmv; |
5233 | 654 |
655 /* initialize bit buffer */ | |
656 init_get_bits(&s->gb,buf,buf_size*8); | |
657 | |
658 /* decode frame header */ | |
659 s->f_code = get_bits (&s->gb, 22); | |
660 | |
661 if ((s->f_code & ~0x70) || !(s->f_code & 0x60)) | |
662 return -1; | |
663 | |
664 /* swap some header bytes (why?) */ | |
665 if (s->f_code != 0x20) { | |
666 uint32_t *src = (uint32_t *) (buf + 4); | |
667 | |
668 for (i=0; i < 4; i++) { | |
669 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i]; | |
670 } | |
671 } | |
672 | |
673 result = svq1_decode_frame_header (&s->gb, s); | |
674 | |
675 if (result != 0) | |
676 { | |
677 #ifdef DEBUG_SVQ1 | |
678 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result); | |
679 #endif | |
680 return result; | |
681 } | |
682 | |
683 //FIXME this avoids some confusion for "B frames" without 2 references | |
684 //this should be removed after libavcodec can handle more flexible picture types & ordering | |
6481 | 685 if(s->pict_type==FF_B_TYPE && s->last_picture_ptr==NULL) return buf_size; |
5233 | 686 |
6481 | 687 if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return buf_size; |
688 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE) | |
689 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE) | |
5233 | 690 || avctx->skip_frame >= AVDISCARD_ALL) |
691 return buf_size; | |
692 | |
693 if(MPV_frame_start(s, avctx) < 0) | |
694 return -1; | |
695 | |
11960 | 696 pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv)); |
697 if (!pmv) | |
698 return -1; | |
699 | |
5233 | 700 /* decode y, u and v components */ |
701 for (i=0; i < 3; i++) { | |
702 int linesize; | |
703 if (i == 0) { | |
9686
bc32976d6d9d
Move ALIGN macro to libavutil/common.h and use it in various places
conrad
parents:
9401
diff
changeset
|
704 width = FFALIGN(s->width, 16); |
bc32976d6d9d
Move ALIGN macro to libavutil/common.h and use it in various places
conrad
parents:
9401
diff
changeset
|
705 height = FFALIGN(s->height, 16); |
5233 | 706 linesize= s->linesize; |
707 } else { | |
708 if(s->flags&CODEC_FLAG_GRAY) break; | |
9686
bc32976d6d9d
Move ALIGN macro to libavutil/common.h and use it in various places
conrad
parents:
9401
diff
changeset
|
709 width = FFALIGN(s->width/4, 16); |
bc32976d6d9d
Move ALIGN macro to libavutil/common.h and use it in various places
conrad
parents:
9401
diff
changeset
|
710 height = FFALIGN(s->height/4, 16); |
5233 | 711 linesize= s->uvlinesize; |
712 } | |
713 | |
714 current = s->current_picture.data[i]; | |
715 | |
6481 | 716 if(s->pict_type==FF_B_TYPE){ |
5233 | 717 previous = s->next_picture.data[i]; |
718 }else{ | |
719 previous = s->last_picture.data[i]; | |
720 } | |
721 | |
6481 | 722 if (s->pict_type == FF_I_TYPE) { |
5233 | 723 /* keyframe */ |
724 for (y=0; y < height; y+=16) { | |
725 for (x=0; x < width; x+=16) { | |
726 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize); | |
727 if (result != 0) | |
728 { | |
729 //#ifdef DEBUG_SVQ1 | |
730 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result); | |
731 //#endif | |
11960 | 732 goto err; |
5233 | 733 } |
734 } | |
735 current += 16*linesize; | |
736 } | |
737 } else { | |
738 /* delta frame */ | |
8318
bc36a075bf35
The POSIX namespace shall be held sacrosanct. To that end,
melanson
parents:
8026
diff
changeset
|
739 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv)); |
5233 | 740 |
741 for (y=0; y < height; y+=16) { | |
742 for (x=0; x < width; x+=16) { | |
743 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous, | |
744 linesize, pmv, x, y); | |
745 if (result != 0) | |
746 { | |
747 #ifdef DEBUG_SVQ1 | |
748 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result); | |
749 #endif | |
11960 | 750 goto err; |
5233 | 751 } |
752 } | |
753 | |
754 pmv[0].x = | |
755 pmv[0].y = 0; | |
756 | |
757 current += 16*linesize; | |
758 } | |
759 } | |
760 } | |
761 | |
762 *pict = *(AVFrame*)&s->current_picture; | |
763 | |
764 | |
765 MPV_frame_end(s); | |
766 | |
767 *data_size=sizeof(AVFrame); | |
11960 | 768 result = buf_size; |
769 err: | |
770 av_free(pmv); | |
771 return result; | |
5233 | 772 } |
773 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
774 static av_cold int svq1_decode_init(AVCodecContext *avctx) |
5233 | 775 { |
776 MpegEncContext *s = avctx->priv_data; | |
777 int i; | |
10262
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
778 int offset = 0; |
5233 | 779 |
780 MPV_decode_defaults(s); | |
781 | |
782 s->avctx = avctx; | |
783 s->width = (avctx->width+3)&~3; | |
784 s->height = (avctx->height+3)&~3; | |
785 s->codec_id= avctx->codec->id; | |
786 avctx->pix_fmt = PIX_FMT_YUV410P; | |
787 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames | |
788 s->flags= avctx->flags; | |
789 if (MPV_common_init(s) < 0) return -1; | |
790 | |
10259
21add4db7e53
Use INIT_VLC_STATIC where easily possible in svq1dec
reimar
parents:
10146
diff
changeset
|
791 INIT_VLC_STATIC(&svq1_block_type, 2, 4, |
5233 | 792 &ff_svq1_block_type_vlc[0][1], 2, 1, |
10259
21add4db7e53
Use INIT_VLC_STATIC where easily possible in svq1dec
reimar
parents:
10146
diff
changeset
|
793 &ff_svq1_block_type_vlc[0][0], 2, 1, 6); |
5233 | 794 |
10259
21add4db7e53
Use INIT_VLC_STATIC where easily possible in svq1dec
reimar
parents:
10146
diff
changeset
|
795 INIT_VLC_STATIC(&svq1_motion_component, 7, 33, |
5233 | 796 &mvtab[0][1], 2, 1, |
10259
21add4db7e53
Use INIT_VLC_STATIC where easily possible in svq1dec
reimar
parents:
10146
diff
changeset
|
797 &mvtab[0][0], 2, 1, 176); |
5233 | 798 |
799 for (i = 0; i < 6; i++) { | |
10262
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
800 static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}}; |
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
801 static VLC_TYPE table[168][2]; |
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
802 svq1_intra_multistage[i].table = &table[offset]; |
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
803 svq1_intra_multistage[i].table_allocated = sizes[0][i]; |
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
804 offset += sizes[0][i]; |
5233 | 805 init_vlc(&svq1_intra_multistage[i], 3, 8, |
806 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1, | |
10262
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
807 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC); |
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
808 svq1_inter_multistage[i].table = &table[offset]; |
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
809 svq1_inter_multistage[i].table_allocated = sizes[1][i]; |
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
810 offset += sizes[1][i]; |
5233 | 811 init_vlc(&svq1_inter_multistage[i], 3, 8, |
812 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1, | |
10262
0eed6587903b
Replace last use of INIT_VLC_USE_STATIC by INIT_VLC_USE_NEW_STATIC in svq1dec
reimar
parents:
10259
diff
changeset
|
813 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC); |
5233 | 814 } |
815 | |
10259
21add4db7e53
Use INIT_VLC_STATIC where easily possible in svq1dec
reimar
parents:
10146
diff
changeset
|
816 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256, |
5233 | 817 &ff_svq1_intra_mean_vlc[0][1], 4, 2, |
10259
21add4db7e53
Use INIT_VLC_STATIC where easily possible in svq1dec
reimar
parents:
10146
diff
changeset
|
818 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632); |
5233 | 819 |
10259
21add4db7e53
Use INIT_VLC_STATIC where easily possible in svq1dec
reimar
parents:
10146
diff
changeset
|
820 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512, |
5233 | 821 &ff_svq1_inter_mean_vlc[0][1], 4, 2, |
10259
21add4db7e53
Use INIT_VLC_STATIC where easily possible in svq1dec
reimar
parents:
10146
diff
changeset
|
822 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434); |
5233 | 823 |
824 return 0; | |
825 } | |
826 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
827 static av_cold int svq1_decode_end(AVCodecContext *avctx) |
5233 | 828 { |
829 MpegEncContext *s = avctx->priv_data; | |
830 | |
831 MPV_common_end(s); | |
832 return 0; | |
833 } | |
834 | |
835 | |
836 AVCodec svq1_decoder = { | |
837 "svq1", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
10441
diff
changeset
|
838 AVMEDIA_TYPE_VIDEO, |
5233 | 839 CODEC_ID_SVQ1, |
840 sizeof(MpegEncContext), | |
841 svq1_decode_init, | |
842 NULL, | |
843 svq1_decode_end, | |
844 svq1_decode_frame, | |
845 CODEC_CAP_DR1, | |
846 .flush= ff_mpeg_flush, | |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
9686
diff
changeset
|
847 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE}, |
10441
0a6fc654cfb6
Add additional long names for the Sorenson Vector Quantizer 1 decoder
stefano
parents:
10262
diff
changeset
|
848 .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"), |
5233 | 849 }; |