Mercurial > libavcodec.hg
annotate flicvideo.c @ 6920:d02af7474bff libavcodec
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
fixes CID84 RUN2
CID85 RUN2
CID86 RUN2
CID87 RUN2
CID88 RUN2
CID89 RUN2
CID90 RUN2
CID91 RUN2
CID92 RUN2
CID93 RUN2
CID94 RUN2
CID95 RUN2
CID96 RUN2
CID97 RUN2
CID98 RUN2
CID99 RUN2
CID100 RUN2
CID101 RUN2
CID102 RUN2
CID103 RUN2
CID104 RUN2
CID105 RUN2
CID106 RUN2
author | michael |
---|---|
date | Wed, 28 May 2008 11:59:41 +0000 |
parents | f7cbb7733146 |
children | e943e1409077 |
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 * @file flic.c | |
24 * Autodesk Animator FLI/FLC Video Decoder | |
25 * by Mike Melanson (melanson@pcisys.net) | |
26 * for more information on the .fli/.flc file format and all of its many | |
27 * variations, visit: | |
28 * http://www.compuphase.com/flic.htm | |
29 * | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
30 * 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
|
31 * colorspace data, depending on the FLC. To use this decoder, be |
1624 | 32 * sure that your demuxer sends the FLI file header to the decoder via |
33 * the extradata chunk in AVCodecContext. The chunk should be 128 bytes | |
34 * large. The only exception is for FLI files from the game "Magic Carpet", | |
35 * in which the header is only 12 bytes. | |
36 */ | |
37 | |
38 #include <stdio.h> | |
39 #include <stdlib.h> | |
40 #include <string.h> | |
41 #include <unistd.h> | |
42 | |
6763 | 43 #include "libavutil/bswap.h" |
1624 | 44 #include "avcodec.h" |
45 | |
46 #define FLI_256_COLOR 4 | |
47 #define FLI_DELTA 7 | |
48 #define FLI_COLOR 11 | |
49 #define FLI_LC 12 | |
50 #define FLI_BLACK 13 | |
51 #define FLI_BRUN 15 | |
52 #define FLI_COPY 16 | |
53 #define FLI_MINI 18 | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
54 #define FLI_DTA_BRUN 25 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
55 #define FLI_DTA_COPY 26 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
56 #define FLI_DTA_LC 27 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
57 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
58 #define FLI_TYPE_CODE (0xAF11) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
59 #define FLC_FLX_TYPE_CODE (0xAF12) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
60 #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
|
61 #define FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE (0xAF13) |
1624 | 62 |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
63 #define CHECK_PIXEL_PTR(n) \ |
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
64 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
|
65 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
|
66 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 return -1; \ |
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
68 } \ |
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
69 |
1624 | 70 typedef struct FlicDecodeContext { |
71 AVCodecContext *avctx; | |
72 AVFrame frame; | |
73 | |
74 unsigned int palette[256]; | |
75 int new_palette; | |
76 int fli_type; /* either 0xAF11 or 0xAF12, affects palette resolution */ | |
77 } FlicDecodeContext; | |
78 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6488
diff
changeset
|
79 static av_cold int flic_decode_init(AVCodecContext *avctx) |
1624 | 80 { |
4827 | 81 FlicDecodeContext *s = avctx->priv_data; |
1624 | 82 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
|
83 int depth; |
1624 | 84 |
85 s->avctx = avctx; | |
86 | |
4364 | 87 s->fli_type = AV_RL16(&fli_header[4]); /* Might be overridden if a Magic Carpet FLC */ |
2967 | 88 |
5632 | 89 depth = 0; |
1624 | 90 if (s->avctx->extradata_size == 12) { |
91 /* 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
|
92 s->fli_type = FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE; |
5632 | 93 depth = 8; |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
94 } else if (s->avctx->extradata_size != 128) { |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
95 av_log(avctx, AV_LOG_ERROR, "Expected extradata of 12 or 128 bytes\n"); |
1624 | 96 return -1; |
5632 | 97 } else { |
98 depth = AV_RL16(&fli_header[12]); | |
99 } | |
100 | |
101 if (depth == 0) { | |
102 depth = 8; /* Some FLC generators set depth to zero, when they mean 8Bpp. Fix up here */ | |
1624 | 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 : |
4627 | 118 av_log(avctx, AV_LOG_ERROR, "Unknown FLC/FLX depth of %d Bpp is unsupported.\n",depth); |
2907
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, |
6237 | 130 const uint8_t *buf, int buf_size) |
1624 | 131 { |
4827 | 132 FlicDecodeContext *s = avctx->priv_data; |
1624 | 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; | |
4199 | 159 int byte_run; |
1624 | 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 |
4364 | 175 frame_size = AV_RL32(&buf[stream_ptr]); |
1624 | 176 stream_ptr += 6; /* skip the magic number */ |
4364 | 177 num_chunks = AV_RL16(&buf[stream_ptr]); |
1624 | 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)) { | |
4364 | 184 chunk_size = AV_RL32(&buf[stream_ptr]); |
1624 | 185 stream_ptr += 4; |
4364 | 186 chunk_type = AV_RL16(&buf[stream_ptr]); |
1624 | 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 | |
2967 | 194 /* check special case: If this file is from the Magic Carpet |
195 * game and uses 6-bit colors even though it reports 256-color | |
1624 | 196 * chunks in a 0xAF12-type file (fli_type is set to 0xAF13 during |
197 * initialization) */ | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
198 if ((chunk_type == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE)) |
1624 | 199 color_shift = 0; |
200 else | |
201 color_shift = 2; | |
202 /* set up the palette */ | |
4364 | 203 color_packets = AV_RL16(&buf[stream_ptr]); |
1624 | 204 stream_ptr += 2; |
205 palette_ptr = 0; | |
206 for (i = 0; i < color_packets; i++) { | |
207 /* first byte is how many colors to skip */ | |
208 palette_ptr += buf[stream_ptr++]; | |
209 | |
210 /* next byte indicates how many entries to change */ | |
211 color_changes = buf[stream_ptr++]; | |
212 | |
213 /* if there are 0 color changes, there are actually 256 */ | |
214 if (color_changes == 0) | |
215 color_changes = 256; | |
216 | |
217 for (j = 0; j < color_changes; j++) { | |
4045 | 218 unsigned int entry; |
1624 | 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; | |
4045 | 227 entry = (r << 16) | (g << 8) | b; |
228 if (s->palette[palette_ptr] != entry) | |
229 s->new_palette = 1; | |
230 s->palette[palette_ptr++] = entry; | |
1624 | 231 } |
232 } | |
233 | |
234 /* color chunks sometimes have weird 16-bit alignment issues; | |
235 * therefore, take the hardline approach and set the stream_ptr | |
236 * to the value calculated w.r.t. the size specified by the color | |
237 * chunk header */ | |
238 stream_ptr = stream_ptr_after_color_chunk; | |
239 | |
240 break; | |
241 | |
242 case FLI_DELTA: | |
243 y_ptr = 0; | |
4364 | 244 compressed_lines = AV_RL16(&buf[stream_ptr]); |
1624 | 245 stream_ptr += 2; |
246 while (compressed_lines > 0) { | |
4364 | 247 line_packets = AV_RL16(&buf[stream_ptr]); |
1624 | 248 stream_ptr += 2; |
4234
e560d163e7a8
Implement DELTA_FLI opcodes correctly. Patch by Steven Johnson
alex
parents:
4233
diff
changeset
|
249 if ((line_packets & 0xC000) == 0xC000) { |
e560d163e7a8
Implement DELTA_FLI opcodes correctly. Patch by Steven Johnson
alex
parents:
4233
diff
changeset
|
250 // line skip opcode |
1624 | 251 line_packets = -line_packets; |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
252 y_ptr += line_packets * s->frame.linesize[0]; |
4234
e560d163e7a8
Implement DELTA_FLI opcodes correctly. Patch by Steven Johnson
alex
parents:
4233
diff
changeset
|
253 } else if ((line_packets & 0xC000) == 0x4000) { |
e560d163e7a8
Implement DELTA_FLI opcodes correctly. Patch by Steven Johnson
alex
parents:
4233
diff
changeset
|
254 av_log(avctx, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", line_packets); |
e560d163e7a8
Implement DELTA_FLI opcodes correctly. Patch by Steven Johnson
alex
parents:
4233
diff
changeset
|
255 } else if ((line_packets & 0xC000) == 0x8000) { |
e560d163e7a8
Implement DELTA_FLI opcodes correctly. Patch by Steven Johnson
alex
parents:
4233
diff
changeset
|
256 // "last byte" opcode |
e560d163e7a8
Implement DELTA_FLI opcodes correctly. Patch by Steven Johnson
alex
parents:
4233
diff
changeset
|
257 pixels[y_ptr + s->frame.linesize[0] - 1] = line_packets & 0xff; |
1624 | 258 } else { |
259 compressed_lines--; | |
260 pixel_ptr = y_ptr; | |
261 pixel_countdown = s->avctx->width; | |
262 for (i = 0; i < line_packets; i++) { | |
263 /* account for the skip bytes */ | |
264 pixel_skip = buf[stream_ptr++]; | |
265 pixel_ptr += pixel_skip; | |
266 pixel_countdown -= pixel_skip; | |
4199 | 267 byte_run = (signed char)(buf[stream_ptr++]); |
1624 | 268 if (byte_run < 0) { |
269 byte_run = -byte_run; | |
270 palette_idx1 = buf[stream_ptr++]; | |
271 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
|
272 CHECK_PIXEL_PTR(byte_run); |
1624 | 273 for (j = 0; j < byte_run; j++, pixel_countdown -= 2) { |
274 pixels[pixel_ptr++] = palette_idx1; | |
275 pixels[pixel_ptr++] = palette_idx2; | |
276 } | |
277 } else { | |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
278 CHECK_PIXEL_PTR(byte_run * 2); |
1624 | 279 for (j = 0; j < byte_run * 2; j++, pixel_countdown--) { |
280 palette_idx1 = buf[stream_ptr++]; | |
281 pixels[pixel_ptr++] = palette_idx1; | |
282 } | |
283 } | |
284 } | |
285 | |
286 y_ptr += s->frame.linesize[0]; | |
287 } | |
288 } | |
289 break; | |
290 | |
291 case FLI_LC: | |
292 /* line compressed */ | |
4364 | 293 starting_line = AV_RL16(&buf[stream_ptr]); |
1624 | 294 stream_ptr += 2; |
295 y_ptr = 0; | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
296 y_ptr += starting_line * s->frame.linesize[0]; |
1624 | 297 |
4364 | 298 compressed_lines = AV_RL16(&buf[stream_ptr]); |
1624 | 299 stream_ptr += 2; |
300 while (compressed_lines > 0) { | |
301 pixel_ptr = y_ptr; | |
302 pixel_countdown = s->avctx->width; | |
303 line_packets = buf[stream_ptr++]; | |
304 if (line_packets > 0) { | |
305 for (i = 0; i < line_packets; i++) { | |
306 /* account for the skip bytes */ | |
307 pixel_skip = buf[stream_ptr++]; | |
308 pixel_ptr += pixel_skip; | |
309 pixel_countdown -= pixel_skip; | |
4199 | 310 byte_run = (signed char)(buf[stream_ptr++]); |
1624 | 311 if (byte_run > 0) { |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
312 CHECK_PIXEL_PTR(byte_run); |
1624 | 313 for (j = 0; j < byte_run; j++, pixel_countdown--) { |
314 palette_idx1 = buf[stream_ptr++]; | |
315 pixels[pixel_ptr++] = palette_idx1; | |
316 } | |
4233
5e05fadc93d1
support byte_run=0 case in DELTA_FLI (this case means only skip pixels)
alex
parents:
4232
diff
changeset
|
317 } else if (byte_run < 0) { |
1624 | 318 byte_run = -byte_run; |
319 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
|
320 CHECK_PIXEL_PTR(byte_run); |
1624 | 321 for (j = 0; j < byte_run; j++, pixel_countdown--) { |
322 pixels[pixel_ptr++] = palette_idx1; | |
323 } | |
324 } | |
325 } | |
326 } | |
327 | |
328 y_ptr += s->frame.linesize[0]; | |
329 compressed_lines--; | |
330 } | |
331 break; | |
332 | |
333 case FLI_BLACK: | |
334 /* set the whole frame to color 0 (which is usually black) */ | |
335 memset(pixels, 0, | |
336 s->frame.linesize[0] * s->avctx->height); | |
337 break; | |
338 | |
339 case FLI_BRUN: | |
340 /* Byte run compression: This chunk type only occurs in the first | |
341 * FLI frame and it will update the entire frame. */ | |
342 y_ptr = 0; | |
343 for (lines = 0; lines < s->avctx->height; lines++) { | |
344 pixel_ptr = y_ptr; | |
345 /* disregard the line packets; instead, iterate through all | |
346 * pixels on a row */ | |
347 stream_ptr++; | |
348 pixel_countdown = s->avctx->width; | |
349 while (pixel_countdown > 0) { | |
4199 | 350 byte_run = (signed char)(buf[stream_ptr++]); |
1624 | 351 if (byte_run > 0) { |
352 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
|
353 CHECK_PIXEL_PTR(byte_run); |
1624 | 354 for (j = 0; j < byte_run; j++) { |
355 pixels[pixel_ptr++] = palette_idx1; | |
356 pixel_countdown--; | |
357 if (pixel_countdown < 0) | |
4539 | 358 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n", |
359 pixel_countdown, lines); | |
1624 | 360 } |
361 } else { /* copy bytes if byte_run < 0 */ | |
362 byte_run = -byte_run; | |
2825
faa53103dde0
tinfoil patch: make sure that pixel pointer does not go out of bounds
melanson
parents:
2422
diff
changeset
|
363 CHECK_PIXEL_PTR(byte_run); |
1624 | 364 for (j = 0; j < byte_run; j++) { |
365 palette_idx1 = buf[stream_ptr++]; | |
366 pixels[pixel_ptr++] = palette_idx1; | |
367 pixel_countdown--; | |
368 if (pixel_countdown < 0) | |
4539 | 369 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n", |
370 pixel_countdown, lines); | |
1624 | 371 } |
372 } | |
373 } | |
374 | |
375 y_ptr += s->frame.linesize[0]; | |
376 } | |
377 break; | |
378 | |
379 case FLI_COPY: | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
380 /* copy the chunk (uncompressed frame) */ |
1624 | 381 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
|
382 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
|
383 "bigger than image, skipping chunk\n", chunk_size - 6); |
1624 | 384 stream_ptr += chunk_size - 6; |
385 } else { | |
386 for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height; | |
387 y_ptr += s->frame.linesize[0]) { | |
388 memcpy(&pixels[y_ptr], &buf[stream_ptr], | |
389 s->avctx->width); | |
390 stream_ptr += s->avctx->width; | |
391 } | |
392 } | |
393 break; | |
394 | |
395 case FLI_MINI: | |
396 /* some sort of a thumbnail? disregard this chunk... */ | |
397 stream_ptr += chunk_size - 6; | |
398 break; | |
399 | |
400 default: | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
401 av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type); |
1624 | 402 break; |
403 } | |
404 | |
405 frame_size -= chunk_size; | |
406 num_chunks--; | |
407 } | |
408 | |
409 /* by the end of the chunk, the stream ptr should equal the frame | |
410 * size (minus 1, possibly); if it doesn't, issue a warning */ | |
411 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
|
412 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
|
413 "and final chunk ptr = %d\n", buf_size, stream_ptr); |
1624 | 414 |
415 /* make the palette available on the way out */ | |
4045 | 416 memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE); |
417 if (s->new_palette) { | |
1624 | 418 s->frame.palette_has_changed = 1; |
419 s->new_palette = 0; | |
420 } | |
421 | |
422 *data_size=sizeof(AVFrame); | |
423 *(AVFrame*)data = s->frame; | |
424 | |
425 return buf_size; | |
426 } | |
427 | |
3071
cc0357a90e8f
make some functions static (patch by Dieter < freebsd at sopwith.solgatos.com >)
aurel
parents:
3036
diff
changeset
|
428 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
|
429 void *data, int *data_size, |
6237 | 430 const uint8_t *buf, int buf_size) |
2907
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 /* 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
|
433 /* Format is the pixel format, the packets are processed the same. */ |
4827 | 434 FlicDecodeContext *s = avctx->priv_data; |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
435 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
436 int stream_ptr = 0; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
437 int pixel_ptr; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
438 unsigned char palette_idx1; |
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 unsigned int frame_size; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
441 int num_chunks; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
442 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
443 unsigned int chunk_size; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
444 int chunk_type; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
445 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
446 int i, j; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
447 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
448 int lines; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
449 int compressed_lines; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
450 signed short line_packets; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
451 int y_ptr; |
4199 | 452 int byte_run; |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
453 int pixel_skip; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
454 int pixel_countdown; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
455 unsigned char *pixels; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
456 int pixel; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
457 int pixel_limit; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
458 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
459 s->frame.reference = 1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
460 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
|
461 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
|
462 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
|
463 return -1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
464 } |
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 pixels = s->frame.data[0]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
467 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
|
468 |
4364 | 469 frame_size = AV_RL32(&buf[stream_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
470 stream_ptr += 6; /* skip the magic number */ |
4364 | 471 num_chunks = AV_RL16(&buf[stream_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
472 stream_ptr += 10; /* skip padding */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
473 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
474 frame_size -= 16; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
475 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
476 /* iterate through the chunks */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
477 while ((frame_size > 0) && (num_chunks > 0)) { |
4364 | 478 chunk_size = AV_RL32(&buf[stream_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
479 stream_ptr += 4; |
4364 | 480 chunk_type = AV_RL16(&buf[stream_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
481 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
482 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
483 switch (chunk_type) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
484 case FLI_256_COLOR: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
485 case FLI_COLOR: |
6488 | 486 /* For some reason, it seems that non-palettized flics do |
487 * include one of these chunks in their first frame. | |
488 * Why I do not know, it seems rather extraneous. */ | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
489 /* 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
|
490 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
|
491 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
492 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
493 case FLI_DELTA: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
494 case FLI_DTA_LC: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
495 y_ptr = 0; |
4364 | 496 compressed_lines = AV_RL16(&buf[stream_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
497 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
498 while (compressed_lines > 0) { |
4364 | 499 line_packets = AV_RL16(&buf[stream_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
500 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
501 if (line_packets < 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
502 line_packets = -line_packets; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
503 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
|
504 } else { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
505 compressed_lines--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
506 pixel_ptr = y_ptr; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
507 pixel_countdown = s->avctx->width; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
508 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
|
509 /* account for the skip bytes */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
510 pixel_skip = buf[stream_ptr++]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
511 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
|
512 pixel_countdown -= pixel_skip; |
4199 | 513 byte_run = (signed char)(buf[stream_ptr++]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
514 if (byte_run < 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
515 byte_run = -byte_run; |
4364 | 516 pixel = AV_RL16(&buf[stream_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
517 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
518 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
519 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
|
520 *((signed short*)(&pixels[pixel_ptr])) = pixel; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
521 pixel_ptr += 2; |
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 } else { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
524 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
525 for (j = 0; j < byte_run; j++, pixel_countdown--) { |
4364 | 526 *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
527 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
528 pixel_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
529 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
530 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
531 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
532 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
533 y_ptr += s->frame.linesize[0]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
534 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
535 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
536 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
537 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
538 case FLI_LC: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
539 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
|
540 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
|
541 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
542 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
543 case FLI_BLACK: |
4235 | 544 /* set the whole frame to 0x0000 which is black in both 15Bpp and 16Bpp modes. */ |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
545 memset(pixels, 0x0000, |
4232 | 546 s->frame.linesize[0] * s->avctx->height); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
547 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
548 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
549 case FLI_BRUN: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
550 y_ptr = 0; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
551 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
|
552 pixel_ptr = y_ptr; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
553 /* 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
|
554 * pixels on a row */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
555 stream_ptr++; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
556 pixel_countdown = (s->avctx->width * 2); |
2967 | 557 |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
558 while (pixel_countdown > 0) { |
4199 | 559 byte_run = (signed char)(buf[stream_ptr++]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
560 if (byte_run > 0) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
561 palette_idx1 = buf[stream_ptr++]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
562 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
563 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
|
564 pixels[pixel_ptr++] = palette_idx1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
565 pixel_countdown--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
566 if (pixel_countdown < 0) |
4539 | 567 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) (linea%d)\n", |
568 pixel_countdown, lines); | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
569 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
570 } 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
|
571 byte_run = -byte_run; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
572 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
573 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
|
574 palette_idx1 = buf[stream_ptr++]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
575 pixels[pixel_ptr++] = palette_idx1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
576 pixel_countdown--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
577 if (pixel_countdown < 0) |
4539 | 578 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n", |
579 pixel_countdown, lines); | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
580 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
581 } |
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 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
584 /* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed. |
5127 | 585 * This does not give us any good oportunity to perform word endian conversion |
586 * during decompression. So if it is required (i.e., this is not a LE target, we do | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
587 * 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
|
588 */ |
5154
b683b5f78fab
replace endian detection hack with #ifdef WORDS_BIGENDIAN
mru
parents:
5129
diff
changeset
|
589 #ifdef WORDS_BIGENDIAN |
5155 | 590 pixel_ptr = y_ptr; |
591 pixel_countdown = s->avctx->width; | |
592 while (pixel_countdown > 0) { | |
4364 | 593 *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[pixel_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
594 pixel_ptr += 2; |
5155 | 595 } |
5154
b683b5f78fab
replace endian detection hack with #ifdef WORDS_BIGENDIAN
mru
parents:
5129
diff
changeset
|
596 #endif |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
597 y_ptr += s->frame.linesize[0]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
598 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
599 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
600 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
601 case FLI_DTA_BRUN: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
602 y_ptr = 0; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
603 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
|
604 pixel_ptr = y_ptr; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
605 /* 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
|
606 * pixels on a row */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
607 stream_ptr++; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
608 pixel_countdown = s->avctx->width; /* Width is in pixels, not bytes */ |
2967 | 609 |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
610 while (pixel_countdown > 0) { |
4199 | 611 byte_run = (signed char)(buf[stream_ptr++]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
612 if (byte_run > 0) { |
4364 | 613 pixel = AV_RL16(&buf[stream_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
614 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
615 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
616 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
|
617 *((signed short*)(&pixels[pixel_ptr])) = pixel; |
2967 | 618 pixel_ptr += 2; |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
619 pixel_countdown--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
620 if (pixel_countdown < 0) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
621 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
|
622 pixel_countdown); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
623 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
624 } 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
|
625 byte_run = -byte_run; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
626 CHECK_PIXEL_PTR(byte_run); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
627 for (j = 0; j < byte_run; j++) { |
4364 | 628 *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
629 stream_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
630 pixel_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
631 pixel_countdown--; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
632 if (pixel_countdown < 0) |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
633 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
|
634 pixel_countdown); |
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 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
637 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
638 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
639 y_ptr += s->frame.linesize[0]; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
640 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
641 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
642 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
643 case FLI_COPY: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
644 case FLI_DTA_COPY: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
645 /* copy the chunk (uncompressed frame) */ |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
646 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
|
647 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
|
648 "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
|
649 stream_ptr += chunk_size - 6; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
650 } else { |
2967 | 651 |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
652 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
|
653 y_ptr += s->frame.linesize[0]) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
654 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
655 pixel_countdown = s->avctx->width; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
656 pixel_ptr = 0; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
657 while (pixel_countdown > 0) { |
4364 | 658 *((signed short*)(&pixels[y_ptr + pixel_ptr])) = AV_RL16(&buf[stream_ptr+pixel_ptr]); |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
659 pixel_ptr += 2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
660 pixel_countdown--; |
2967 | 661 } |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
662 stream_ptr += s->avctx->width*2; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
663 } |
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 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
666 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
667 case FLI_MINI: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
668 /* 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
|
669 stream_ptr += chunk_size - 6; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
670 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
671 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
672 default: |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
673 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
|
674 break; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
675 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
676 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
677 frame_size -= chunk_size; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
678 num_chunks--; |
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 /* 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
|
682 * 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
|
683 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
|
684 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
|
685 "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
|
686 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
687 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
688 *data_size=sizeof(AVFrame); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
689 *(AVFrame*)data = s->frame; |
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 return buf_size; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
692 } |
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 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
|
695 void *data, int *data_size, |
6237 | 696 const uint8_t *buf, int buf_size) |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
697 { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
698 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
|
699 return -1; |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
700 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
701 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
702 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
|
703 void *data, int *data_size, |
6237 | 704 const uint8_t *buf, int buf_size) |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
705 { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
706 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
|
707 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
|
708 buf, buf_size); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
709 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
710 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
|
711 (avctx->pix_fmt == PIX_FMT_RGB565)) { |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
712 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
|
713 buf, buf_size); |
2967 | 714 } |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
715 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
|
716 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
|
717 buf, buf_size); |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
718 } |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
719 |
5127 | 720 /* Should not get here, ever as the pix_fmt is processed */ |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
721 /* 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
|
722 /* the finite set of possibilites allowable by here. */ |
5127 | 723 /* But in case we do, just error out. */ |
724 av_log(avctx, AV_LOG_ERROR, "Unknown FLC format, my science cannot explain how this happened.\n"); | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
725 return -1; |
2967 | 726 } |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
727 |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
728 |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6488
diff
changeset
|
729 static av_cold int flic_decode_end(AVCodecContext *avctx) |
1624 | 730 { |
731 FlicDecodeContext *s = avctx->priv_data; | |
732 | |
1759
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
733 if (s->frame.data[0]) |
e73a3b86565f
Use reget buffer instead of copying from prev frame
rtognimp
parents:
1624
diff
changeset
|
734 avctx->release_buffer(avctx, &s->frame); |
1624 | 735 |
736 return 0; | |
737 } | |
738 | |
739 AVCodec flic_decoder = { | |
740 "flic", | |
741 CODEC_TYPE_VIDEO, | |
742 CODEC_ID_FLIC, | |
743 sizeof(FlicDecodeContext), | |
744 flic_decode_init, | |
745 NULL, | |
746 flic_decode_end, | |
747 flic_decode_frame, | |
748 CODEC_CAP_DR1, | |
2907
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
749 NULL, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
750 NULL, |
f7114e03d8dd
support for FLX and DTA extensions in the FLIC format, courtesy of
melanson
parents:
2825
diff
changeset
|
751 NULL, |
6717 | 752 NULL, |
753 .long_name = "Autodesk Animator Flic video", | |
1624 | 754 }; |