Mercurial > libavcodec.hg
annotate flicvideo.c @ 3990:746a60ba3177 libavcodec
enable CMOV_IS_FAST as its faster or equal speed on every cpu (duron, athlon, PM, P3) from which ive seen benchmarks, it might be slower on P4 but noone has posted benchmarks ...
author | michael |
---|---|
date | Wed, 11 Oct 2006 12:23:40 +0000 |
parents | c8c591fe26f8 |
children | 1bf7bc44430f |
rev | line source |
---|---|
1624 | 1 /* |
2 * FLI/FLC Animation Video Decoder | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
3 * Copyright (C) 2003, 2004 the ffmpeg project |
1624 | 4 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3071
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3071
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3071
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
1624 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3071
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
1624 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3071
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
1624 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3071
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2967
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1624 | 20 * |
21 */ | |
22 | |
23 /** | |
24 * @file flic.c | |
25 * Autodesk Animator FLI/FLC Video Decoder | |
26 * by Mike Melanson (melanson@pcisys.net) | |
27 * for more information on the .fli/.flc file format and all of its many | |
28 * variations, visit: | |
29 * http://www.compuphase.com/flic.htm | |
30 * | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
31 * This decoder outputs PAL8/RGB555/RGB565 and maybe one day RGB24 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
32 * colorspace data, depending on the FLC. To use this decoder, be |
1624 | 33 * sure that your demuxer sends the FLI file header to the decoder via |
34 * the extradata chunk in AVCodecContext. The chunk should be 128 bytes | |
35 * large. The only exception is for FLI files from the game "Magic Carpet", | |
36 * in which the header is only 12 bytes. | |
37 */ | |
38 | |
39 #include <stdio.h> | |
40 #include <stdlib.h> | |
41 #include <string.h> | |
42 #include <unistd.h> | |
43 | |
44 #include "common.h" | |
45 #include "avcodec.h" | |
46 #include "bswap.h" | |
47 | |
48 #define FLI_256_COLOR 4 | |
49 #define FLI_DELTA 7 | |
50 #define FLI_COLOR 11 | |
51 #define FLI_LC 12 | |
52 #define FLI_BLACK 13 | |
53 #define FLI_BRUN 15 | |
54 #define FLI_COPY 16 | |
55 #define FLI_MINI 18 | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
56 #define FLI_DTA_BRUN 25 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
57 #define FLI_DTA_COPY 26 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
58 #define FLI_DTA_LC 27 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
59 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
60 #define FLI_TYPE_CODE (0xAF11) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
61 #define FLC_FLX_TYPE_CODE (0xAF12) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
62 #define FLC_DTA_TYPE_CODE (0xAF44) /* Marks an "Extended FLC" comes from Dave's Targa Animator (DTA) */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
63 #define FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE (0xAF13) |
1624 | 64 |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
65 #define CHECK_PIXEL_PTR(n) \ |
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
66 if (pixel_ptr + n > pixel_limit) { \ |
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
67 av_log (s->avctx, AV_LOG_INFO, "Problem: pixel_ptr >= pixel_limit (%d >= %d)\n", \ |
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
68 pixel_ptr + n, pixel_limit); \ |
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
69 return -1; \ |
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
70 } \ |
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
71 |
1624 | 72 typedef struct FlicDecodeContext { |
73 AVCodecContext *avctx; | |
74 AVFrame frame; | |
75 | |
76 unsigned int palette[256]; | |
77 int new_palette; | |
78 int fli_type; /* either 0xAF11 or 0xAF12, affects palette resolution */ | |
79 } FlicDecodeContext; | |
80 | |
81 static int flic_decode_init(AVCodecContext *avctx) | |
82 { | |
83 FlicDecodeContext *s = (FlicDecodeContext *)avctx->priv_data; | |
84 unsigned char *fli_header = (unsigned char *)avctx->extradata; | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
85 int depth; |
1624 | 86 |
87 s->avctx = avctx; | |
88 avctx->has_b_frames = 0; | |
89 | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
90 s->fli_type = LE_16(&fli_header[4]); /* Might be overridden if a Magic Carpet FLC */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
91 depth = LE_16(&fli_header[12]); |
2967 | 92 |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
93 if (depth == 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
94 depth = 8; /* Some FLC generators set depth to zero, when they mean 8Bpp. Fix up here */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
95 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
96 |
1624 | 97 if (s->avctx->extradata_size == 12) { |
98 /* special case for magic carpet FLIs */ | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
99 s->fli_type = FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
100 } else if (s->avctx->extradata_size != 128) { |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
101 av_log(avctx, AV_LOG_ERROR, "Expected extradata of 12 or 128 bytes\n"); |
1624 | 102 return -1; |
103 } | |
104 | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
105 if ((s->fli_type == FLC_FLX_TYPE_CODE) && (depth == 16)) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
106 depth = 15; /* Original Autodesk FLX's say the depth is 16Bpp when it is really 15Bpp */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
107 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
108 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
109 switch (depth) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
110 case 8 : avctx->pix_fmt = PIX_FMT_PAL8; break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
111 case 15 : avctx->pix_fmt = PIX_FMT_RGB555; break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
112 case 16 : avctx->pix_fmt = PIX_FMT_RGB565; break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
113 case 24 : avctx->pix_fmt = PIX_FMT_BGR24; /* Supposedly BGR, but havent any files to test with */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
114 av_log(avctx, AV_LOG_ERROR, "24Bpp FLC/FLX is unsupported due to no test files.\n"); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
115 return -1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
116 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
117 default : |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
118 av_log(avctx, AV_LOG_ERROR, "Unkown FLC/FLX depth of %d Bpp is unsupported.\n",depth); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
119 return -1; |
2967 | 120 } |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
121 |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
122 s->frame.data[0] = NULL; |
1624 | 123 s->new_palette = 0; |
124 | |
125 return 0; | |
126 } | |
127 | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
128 static int flic_decode_frame_8BPP(AVCodecContext *avctx, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
129 void *data, int *data_size, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
130 uint8_t *buf, int buf_size) |
1624 | 131 { |
132 FlicDecodeContext *s = (FlicDecodeContext *)avctx->priv_data; | |
133 | |
134 int stream_ptr = 0; | |
135 int stream_ptr_after_color_chunk; | |
136 int pixel_ptr; | |
137 int palette_ptr; | |
138 unsigned char palette_idx1; | |
139 unsigned char palette_idx2; | |
140 | |
141 unsigned int frame_size; | |
142 int num_chunks; | |
143 | |
144 unsigned int chunk_size; | |
145 int chunk_type; | |
146 | |
147 int i, j; | |
148 | |
149 int color_packets; | |
150 int color_changes; | |
151 int color_shift; | |
152 unsigned char r, g, b; | |
153 | |
154 int lines; | |
155 int compressed_lines; | |
156 int starting_line; | |
157 signed short line_packets; | |
158 int y_ptr; | |
159 signed char byte_run; | |
160 int pixel_skip; | |
161 int pixel_countdown; | |
162 unsigned char *pixels; | |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
163 int pixel_limit; |
2967 | 164 |
1624 | 165 s->frame.reference = 1; |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
166 s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE; |
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
167 if (avctx->reget_buffer(avctx, &s->frame) < 0) { |
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
168 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); |
1624 | 169 return -1; |
170 } | |
171 | |
172 pixels = s->frame.data[0]; | |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
173 pixel_limit = s->avctx->height * s->frame.linesize[0]; |
1624 | 174 |
175 frame_size = LE_32(&buf[stream_ptr]); | |
176 stream_ptr += 6; /* skip the magic number */ | |
177 num_chunks = LE_16(&buf[stream_ptr]); | |
178 stream_ptr += 10; /* skip padding */ | |
179 | |
180 frame_size -= 16; | |
181 | |
182 /* iterate through the chunks */ | |
183 while ((frame_size > 0) && (num_chunks > 0)) { | |
184 chunk_size = LE_32(&buf[stream_ptr]); | |
185 stream_ptr += 4; | |
186 chunk_type = LE_16(&buf[stream_ptr]); | |
187 stream_ptr += 2; | |
188 | |
189 switch (chunk_type) { | |
190 case FLI_256_COLOR: | |
191 case FLI_COLOR: | |
192 stream_ptr_after_color_chunk = stream_ptr + chunk_size - 6; | |
193 s->new_palette = 1; | |
194 | |
2967 | 195 /* check special case: If this file is from the Magic Carpet |
196 * game and uses 6-bit colors even though it reports 256-color | |
1624 | 197 * chunks in a 0xAF12-type file (fli_type is set to 0xAF13 during |
198 * initialization) */ | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
199 if ((chunk_type == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE)) |
1624 | 200 color_shift = 0; |
201 else | |
202 color_shift = 2; | |
203 /* set up the palette */ | |
204 color_packets = LE_16(&buf[stream_ptr]); | |
205 stream_ptr += 2; | |
206 palette_ptr = 0; | |
207 for (i = 0; i < color_packets; i++) { | |
208 /* first byte is how many colors to skip */ | |
209 palette_ptr += buf[stream_ptr++]; | |
210 | |
211 /* next byte indicates how many entries to change */ | |
212 color_changes = buf[stream_ptr++]; | |
213 | |
214 /* if there are 0 color changes, there are actually 256 */ | |
215 if (color_changes == 0) | |
216 color_changes = 256; | |
217 | |
218 for (j = 0; j < color_changes; j++) { | |
219 | |
220 /* wrap around, for good measure */ | |
2422 | 221 if ((unsigned)palette_ptr >= 256) |
1624 | 222 palette_ptr = 0; |
223 | |
224 r = buf[stream_ptr++] << color_shift; | |
225 g = buf[stream_ptr++] << color_shift; | |
226 b = buf[stream_ptr++] << color_shift; | |
227 s->palette[palette_ptr++] = (r << 16) | (g << 8) | b; | |
228 } | |
229 } | |
230 | |
231 /* color chunks sometimes have weird 16-bit alignment issues; | |
232 * therefore, take the hardline approach and set the stream_ptr | |
233 * to the value calculated w.r.t. the size specified by the color | |
234 * chunk header */ | |
235 stream_ptr = stream_ptr_after_color_chunk; | |
236 | |
237 break; | |
238 | |
239 case FLI_DELTA: | |
240 y_ptr = 0; | |
241 compressed_lines = LE_16(&buf[stream_ptr]); | |
242 stream_ptr += 2; | |
243 while (compressed_lines > 0) { | |
244 line_packets = LE_16(&buf[stream_ptr]); | |
245 stream_ptr += 2; | |
246 if (line_packets < 0) { | |
247 line_packets = -line_packets; | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
248 y_ptr += line_packets * s->frame.linesize[0]; |
1624 | 249 } else { |
250 compressed_lines--; | |
251 pixel_ptr = y_ptr; | |
252 pixel_countdown = s->avctx->width; | |
253 for (i = 0; i < line_packets; i++) { | |
254 /* account for the skip bytes */ | |
255 pixel_skip = buf[stream_ptr++]; | |
256 pixel_ptr += pixel_skip; | |
257 pixel_countdown -= pixel_skip; | |
258 byte_run = buf[stream_ptr++]; | |
259 if (byte_run < 0) { | |
260 byte_run = -byte_run; | |
261 palette_idx1 = buf[stream_ptr++]; | |
262 palette_idx2 = buf[stream_ptr++]; | |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
263 CHECK_PIXEL_PTR(byte_run); |
1624 | 264 for (j = 0; j < byte_run; j++, pixel_countdown -= 2) { |
265 pixels[pixel_ptr++] = palette_idx1; | |
266 pixels[pixel_ptr++] = palette_idx2; | |
267 } | |
268 } else { | |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
269 CHECK_PIXEL_PTR(byte_run * 2); |
1624 | 270 for (j = 0; j < byte_run * 2; j++, pixel_countdown--) { |
271 palette_idx1 = buf[stream_ptr++]; | |
272 pixels[pixel_ptr++] = palette_idx1; | |
273 } | |
274 } | |
275 } | |
276 | |
277 y_ptr += s->frame.linesize[0]; | |
278 } | |
279 } | |
280 break; | |
281 | |
282 case FLI_LC: | |
283 /* line compressed */ | |
284 starting_line = LE_16(&buf[stream_ptr]); | |
285 stream_ptr += 2; | |
286 y_ptr = 0; | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
287 y_ptr += starting_line * s->frame.linesize[0]; |
1624 | 288 |
289 compressed_lines = LE_16(&buf[stream_ptr]); | |
290 stream_ptr += 2; | |
291 while (compressed_lines > 0) { | |
292 pixel_ptr = y_ptr; | |
293 pixel_countdown = s->avctx->width; | |
294 line_packets = buf[stream_ptr++]; | |
295 if (line_packets > 0) { | |
296 for (i = 0; i < line_packets; i++) { | |
297 /* account for the skip bytes */ | |
298 pixel_skip = buf[stream_ptr++]; | |
299 pixel_ptr += pixel_skip; | |
300 pixel_countdown -= pixel_skip; | |
301 byte_run = buf[stream_ptr++]; | |
302 if (byte_run > 0) { | |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
303 CHECK_PIXEL_PTR(byte_run); |
1624 | 304 for (j = 0; j < byte_run; j++, pixel_countdown--) { |
305 palette_idx1 = buf[stream_ptr++]; | |
306 pixels[pixel_ptr++] = palette_idx1; | |
307 } | |
308 } else { | |
309 byte_run = -byte_run; | |
310 palette_idx1 = buf[stream_ptr++]; | |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
311 CHECK_PIXEL_PTR(byte_run); |
1624 | 312 for (j = 0; j < byte_run; j++, pixel_countdown--) { |
313 pixels[pixel_ptr++] = palette_idx1; | |
314 } | |
315 } | |
316 } | |
317 } | |
318 | |
319 y_ptr += s->frame.linesize[0]; | |
320 compressed_lines--; | |
321 } | |
322 break; | |
323 | |
324 case FLI_BLACK: | |
325 /* set the whole frame to color 0 (which is usually black) */ | |
326 memset(pixels, 0, | |
327 s->frame.linesize[0] * s->avctx->height); | |
328 break; | |
329 | |
330 case FLI_BRUN: | |
331 /* Byte run compression: This chunk type only occurs in the first | |
332 * FLI frame and it will update the entire frame. */ | |
333 y_ptr = 0; | |
334 for (lines = 0; lines < s->avctx->height; lines++) { | |
335 pixel_ptr = y_ptr; | |
336 /* disregard the line packets; instead, iterate through all | |
337 * pixels on a row */ | |
338 stream_ptr++; | |
339 pixel_countdown = s->avctx->width; | |
340 while (pixel_countdown > 0) { | |
341 byte_run = buf[stream_ptr++]; | |
342 if (byte_run > 0) { | |
343 palette_idx1 = buf[stream_ptr++]; | |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
344 CHECK_PIXEL_PTR(byte_run); |
1624 | 345 for (j = 0; j < byte_run; j++) { |
346 pixels[pixel_ptr++] = palette_idx1; | |
347 pixel_countdown--; | |
348 if (pixel_countdown < 0) | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
349 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n", |
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
350 pixel_countdown); |
1624 | 351 } |
352 } else { /* copy bytes if byte_run < 0 */ | |
353 byte_run = -byte_run; | |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
354 CHECK_PIXEL_PTR(byte_run); |
1624 | 355 for (j = 0; j < byte_run; j++) { |
356 palette_idx1 = buf[stream_ptr++]; | |
357 pixels[pixel_ptr++] = palette_idx1; | |
358 pixel_countdown--; | |
359 if (pixel_countdown < 0) | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
360 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n", |
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
361 pixel_countdown); |
1624 | 362 } |
363 } | |
364 } | |
365 | |
366 y_ptr += s->frame.linesize[0]; | |
367 } | |
368 break; | |
369 | |
370 case FLI_COPY: | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
371 /* copy the chunk (uncompressed frame) */ |
1624 | 372 if (chunk_size - 6 > s->avctx->width * s->avctx->height) { |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
373 av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \ |
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
374 "bigger than image, skipping chunk\n", chunk_size - 6); |
1624 | 375 stream_ptr += chunk_size - 6; |
376 } else { | |
377 for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height; | |
378 y_ptr += s->frame.linesize[0]) { | |
379 memcpy(&pixels[y_ptr], &buf[stream_ptr], | |
380 s->avctx->width); | |
381 stream_ptr += s->avctx->width; | |
382 } | |
383 } | |
384 break; | |
385 | |
386 case FLI_MINI: | |
387 /* some sort of a thumbnail? disregard this chunk... */ | |
388 stream_ptr += chunk_size - 6; | |
389 break; | |
390 | |
391 default: | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
392 av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type); |
1624 | 393 break; |
394 } | |
395 | |
396 frame_size -= chunk_size; | |
397 num_chunks--; | |
398 } | |
399 | |
400 /* by the end of the chunk, the stream ptr should equal the frame | |
401 * size (minus 1, possibly); if it doesn't, issue a warning */ | |
402 if ((stream_ptr != buf_size) && (stream_ptr != buf_size - 1)) | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
403 av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \ |
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
404 "and final chunk ptr = %d\n", buf_size, stream_ptr); |
1624 | 405 |
406 /* make the palette available on the way out */ | |
407 // if (s->new_palette) { | |
408 if (1) { | |
409 memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE); | |
410 s->frame.palette_has_changed = 1; | |
411 s->new_palette = 0; | |
412 } | |
413 | |
414 *data_size=sizeof(AVFrame); | |
415 *(AVFrame*)data = s->frame; | |
416 | |
417 return buf_size; | |
418 } | |
419 | |
3071
cc0357a90e8f
make some functions static (patch by Dieter < freebsd at sopwith.solgatos.com >)
aurel
parents:
3036
diff
changeset
|
420 static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
421 void *data, int *data_size, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
422 uint8_t *buf, int buf_size) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
423 { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
424 /* Note, the only difference between the 15Bpp and 16Bpp */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
425 /* Format is the pixel format, the packets are processed the same. */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
426 FlicDecodeContext *s = (FlicDecodeContext *)avctx->priv_data; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
427 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
428 int stream_ptr = 0; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
429 int pixel_ptr; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
430 unsigned char palette_idx1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
431 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
432 unsigned int frame_size; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
433 int num_chunks; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
434 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
435 unsigned int chunk_size; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
436 int chunk_type; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
437 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
438 int i, j; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
439 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
440 int lines; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
441 int compressed_lines; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
442 signed short line_packets; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
443 int y_ptr; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
444 signed char byte_run; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
445 int pixel_skip; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
446 int pixel_countdown; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
447 unsigned char *pixels; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
448 int pixel; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
449 int pixel_limit; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
450 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
451 s->frame.reference = 1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
452 s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
453 if (avctx->reget_buffer(avctx, &s->frame) < 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
454 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
455 return -1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
456 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
457 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
458 pixels = s->frame.data[0]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
459 pixel_limit = s->avctx->height * s->frame.linesize[0]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
460 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
461 frame_size = LE_32(&buf[stream_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
462 stream_ptr += 6; /* skip the magic number */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
463 num_chunks = LE_16(&buf[stream_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
464 stream_ptr += 10; /* skip padding */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
465 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
466 frame_size -= 16; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
467 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
468 /* iterate through the chunks */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
469 while ((frame_size > 0) && (num_chunks > 0)) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
470 chunk_size = LE_32(&buf[stream_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
471 stream_ptr += 4; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
472 chunk_type = LE_16(&buf[stream_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
473 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
474 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
475 switch (chunk_type) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
476 case FLI_256_COLOR: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
477 case FLI_COLOR: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
478 /* For some reason, it seems that non-paletised flics do include one of these */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
479 /* chunks in their first frame. Why i do not know, it seems rather extraneous */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
480 /* av_log(avctx, AV_LOG_ERROR, "Unexpected Palette chunk %d in non-paletised FLC\n",chunk_type);*/ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
481 stream_ptr = stream_ptr + chunk_size - 6; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
482 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
483 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
484 case FLI_DELTA: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
485 case FLI_DTA_LC: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
486 y_ptr = 0; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
487 compressed_lines = LE_16(&buf[stream_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
488 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
489 while (compressed_lines > 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
490 line_packets = LE_16(&buf[stream_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
491 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
492 if (line_packets < 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
493 line_packets = -line_packets; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
494 y_ptr += line_packets * s->frame.linesize[0]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
495 } else { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
496 compressed_lines--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
497 pixel_ptr = y_ptr; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
498 pixel_countdown = s->avctx->width; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
499 for (i = 0; i < line_packets; i++) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
500 /* account for the skip bytes */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
501 pixel_skip = buf[stream_ptr++]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
502 pixel_ptr += (pixel_skip*2); /* Pixel is 2 bytes wide */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
503 pixel_countdown -= pixel_skip; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
504 byte_run = buf[stream_ptr++]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
505 if (byte_run < 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
506 byte_run = -byte_run; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
507 pixel = LE_16(&buf[stream_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
508 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
509 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
510 for (j = 0; j < byte_run; j++, pixel_countdown -= 2) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
511 *((signed short*)(&pixels[pixel_ptr])) = pixel; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
512 pixel_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
513 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
514 } else { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
515 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
516 for (j = 0; j < byte_run; j++, pixel_countdown--) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
517 *((signed short*)(&pixels[pixel_ptr])) = LE_16(&buf[stream_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
518 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
519 pixel_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
520 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
521 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
522 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
523 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
524 y_ptr += s->frame.linesize[0]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
525 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
526 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
527 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
528 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
529 case FLI_LC: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
530 av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-paletised FLC\n"); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
531 stream_ptr = stream_ptr + chunk_size - 6; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
532 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
533 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
534 case FLI_BLACK: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
535 /* set the whole frame to 0x0000 which is balck in both 15Bpp and 16Bpp modes. */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
536 memset(pixels, 0x0000, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
537 s->frame.linesize[0] * s->avctx->height * 2); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
538 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
539 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
540 case FLI_BRUN: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
541 y_ptr = 0; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
542 for (lines = 0; lines < s->avctx->height; lines++) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
543 pixel_ptr = y_ptr; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
544 /* disregard the line packets; instead, iterate through all |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
545 * pixels on a row */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
546 stream_ptr++; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
547 pixel_countdown = (s->avctx->width * 2); |
2967 | 548 |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
549 while (pixel_countdown > 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
550 byte_run = buf[stream_ptr++]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
551 if (byte_run > 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
552 palette_idx1 = buf[stream_ptr++]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
553 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
554 for (j = 0; j < byte_run; j++) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
555 pixels[pixel_ptr++] = palette_idx1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
556 pixel_countdown--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
557 if (pixel_countdown < 0) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
558 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n", |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
559 pixel_countdown); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
560 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
561 } else { /* copy bytes if byte_run < 0 */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
562 byte_run = -byte_run; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
563 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
564 for (j = 0; j < byte_run; j++) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
565 palette_idx1 = buf[stream_ptr++]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
566 pixels[pixel_ptr++] = palette_idx1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
567 pixel_countdown--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
568 if (pixel_countdown < 0) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
569 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n", |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
570 pixel_countdown); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
571 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
572 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
573 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
574 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
575 /* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed. |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
576 * This doesnt give us any good oportunity to perform word endian conversion |
2967 | 577 * during decompression. So if its requried (ie, this isnt a LE target, we do |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
578 * a second pass over the line here, swapping the bytes. |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
579 */ |
2967 | 580 pixel = 0xFF00; |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
581 if (0xFF00 != LE_16(&pixel)) /* Check if its not an LE Target */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
582 { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
583 pixel_ptr = y_ptr; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
584 pixel_countdown = s->avctx->width; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
585 while (pixel_countdown > 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
586 *((signed short*)(&pixels[pixel_ptr])) = LE_16(&buf[pixel_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
587 pixel_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
588 } |
2967 | 589 } |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
590 y_ptr += s->frame.linesize[0]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
591 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
592 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
593 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
594 case FLI_DTA_BRUN: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
595 y_ptr = 0; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
596 for (lines = 0; lines < s->avctx->height; lines++) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
597 pixel_ptr = y_ptr; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
598 /* disregard the line packets; instead, iterate through all |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
599 * pixels on a row */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
600 stream_ptr++; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
601 pixel_countdown = s->avctx->width; /* Width is in pixels, not bytes */ |
2967 | 602 |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
603 while (pixel_countdown > 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
604 byte_run = buf[stream_ptr++]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
605 if (byte_run > 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
606 pixel = LE_16(&buf[stream_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
607 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
608 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
609 for (j = 0; j < byte_run; j++) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
610 *((signed short*)(&pixels[pixel_ptr])) = pixel; |
2967 | 611 pixel_ptr += 2; |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
612 pixel_countdown--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
613 if (pixel_countdown < 0) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
614 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n", |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
615 pixel_countdown); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
616 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
617 } else { /* copy pixels if byte_run < 0 */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
618 byte_run = -byte_run; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
619 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
620 for (j = 0; j < byte_run; j++) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
621 *((signed short*)(&pixels[pixel_ptr])) = LE_16(&buf[stream_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
622 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
623 pixel_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
624 pixel_countdown--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
625 if (pixel_countdown < 0) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
626 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n", |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
627 pixel_countdown); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
628 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
629 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
630 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
631 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
632 y_ptr += s->frame.linesize[0]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
633 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
634 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
635 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
636 case FLI_COPY: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
637 case FLI_DTA_COPY: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
638 /* copy the chunk (uncompressed frame) */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
639 if (chunk_size - 6 > (unsigned int)(s->avctx->width * s->avctx->height)*2) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
640 av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
641 "bigger than image, skipping chunk\n", chunk_size - 6); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
642 stream_ptr += chunk_size - 6; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
643 } else { |
2967 | 644 |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
645 for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
646 y_ptr += s->frame.linesize[0]) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
647 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
648 pixel_countdown = s->avctx->width; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
649 pixel_ptr = 0; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
650 while (pixel_countdown > 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
651 *((signed short*)(&pixels[y_ptr + pixel_ptr])) = LE_16(&buf[stream_ptr+pixel_ptr]); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
652 pixel_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
653 pixel_countdown--; |
2967 | 654 } |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
655 stream_ptr += s->avctx->width*2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
656 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
657 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
658 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
659 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
660 case FLI_MINI: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
661 /* some sort of a thumbnail? disregard this chunk... */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
662 stream_ptr += chunk_size - 6; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
663 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
664 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
665 default: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
666 av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
667 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
668 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
669 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
670 frame_size -= chunk_size; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
671 num_chunks--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
672 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
673 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
674 /* by the end of the chunk, the stream ptr should equal the frame |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
675 * size (minus 1, possibly); if it doesn't, issue a warning */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
676 if ((stream_ptr != buf_size) && (stream_ptr != buf_size - 1)) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
677 av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
678 "and final chunk ptr = %d\n", buf_size, stream_ptr); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
679 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
680 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
681 *data_size=sizeof(AVFrame); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
682 *(AVFrame*)data = s->frame; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
683 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
684 return buf_size; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
685 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
686 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
687 static int flic_decode_frame_24BPP(AVCodecContext *avctx, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
688 void *data, int *data_size, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
689 uint8_t *buf, int buf_size) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
690 { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
691 av_log(avctx, AV_LOG_ERROR, "24Bpp FLC Unsupported due to lack of test files.\n"); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
692 return -1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
693 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
694 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
695 static int flic_decode_frame(AVCodecContext *avctx, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
696 void *data, int *data_size, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
697 uint8_t *buf, int buf_size) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
698 { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
699 if (avctx->pix_fmt == PIX_FMT_PAL8) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
700 return flic_decode_frame_8BPP(avctx, data, data_size, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
701 buf, buf_size); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
702 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
703 else if ((avctx->pix_fmt == PIX_FMT_RGB555) || |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
704 (avctx->pix_fmt == PIX_FMT_RGB565)) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
705 return flic_decode_frame_15_16BPP(avctx, data, data_size, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
706 buf, buf_size); |
2967 | 707 } |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
708 else if (avctx->pix_fmt == PIX_FMT_BGR24) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
709 return flic_decode_frame_24BPP(avctx, data, data_size, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
710 buf, buf_size); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
711 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
712 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
713 /* Shouldnt get here, ever as the pix_fmt is processed */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
714 /* in flic_decode_init and the above if should deal with */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
715 /* the finite set of possibilites allowable by here. */ |
2967 | 716 /* but in case we do, just error out. */ |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
717 av_log(avctx, AV_LOG_ERROR, "Unknown Format of FLC. My Science cant explain how this happened\n"); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
718 return -1; |
2967 | 719 } |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
720 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
721 |
1624 | 722 static int flic_decode_end(AVCodecContext *avctx) |
723 { | |
724 FlicDecodeContext *s = avctx->priv_data; | |
725 | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
726 if (s->frame.data[0]) |
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
727 avctx->release_buffer(avctx, &s->frame); |
1624 | 728 |
729 return 0; | |
730 } | |
731 | |
732 AVCodec flic_decoder = { | |
733 "flic", | |
734 CODEC_TYPE_VIDEO, | |
735 CODEC_ID_FLIC, | |
736 sizeof(FlicDecodeContext), | |
737 flic_decode_init, | |
738 NULL, | |
739 flic_decode_end, | |
740 flic_decode_frame, | |
741 CODEC_CAP_DR1, | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
742 NULL, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
743 NULL, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
744 NULL, |
1624 | 745 NULL |
746 }; |