History

tinfoil patch: no array is written to in bulk before counts are validated; do not free frames that are not allocated; removed all of the output modes that no one uses and only PAL8 remains

Originally committed as revision 4517 to svn://svn.ffmpeg.org/ffmpeg/trunk

Mike Melanson committed 21 years ago

Commit ca166181 parent 485bb001 file · +85 −419Browse files

Unified · Split

libavcodec/xan.c+85−419
@@ -20,12 +20,11 @@ · 19 unmodified lines
2020
2121 /**
2222 * @file xan.c
23− * Xan video decoder for Wing Commander III & IV computer games
23+ * Xan video decoder for Wing Commander III computer game
2424 * by Mario Brito (mbrito@student.dei.uc.pt)
2525 * and Mike Melanson (melanson@pcisys.net)
2626 *
27− * The xan_wc3 decoder outputs the following colorspaces natively:
28− * PAL8 (default), RGB555, RGB565, RGB24, BGR24, RGBA32, YUV444P
27+ * The xan_wc3 decoder outputs PAL8 data.
2928 */
3029
3130 #include <stdio.h>
@@ -35,77 +34,32 @@ · 3 unmodified lines
3534
3635 #include "common.h"
3736 #include "avcodec.h"
38−#include "dsputil.h"
39−
40−#define PALETTE_COUNT 256
41−#define PALETTE_CONTROL_SIZE ((256 * 3) + 1)
4237
4338 typedef struct XanContext {
4439
4540 AVCodecContext *avctx;
46− DSPContext dsp;
4741 AVFrame last_frame;
4842 AVFrame current_frame;
4943
5044 unsigned char *buf;
5145 int size;
5246
53− unsigned char palette[PALETTE_COUNT * 4];
54−
5547 /* scratch space */
5648 unsigned char *buffer1;
49+ int buffer1_size;
5750 unsigned char *buffer2;
51+ int buffer2_size;
5852
59−} XanContext;
60−
61−/* RGB -> YUV conversion stuff */
62−#define SCALEFACTOR 65536
63−#define CENTERSAMPLE 128
64−
65−#define COMPUTE_Y(r, g, b) \
66− (unsigned char) \
67− ((y_r_table[r] + y_g_table[g] + y_b_table[b]) / SCALEFACTOR)
68−#define COMPUTE_U(r, g, b) \
69− (unsigned char) \
70− ((u_r_table[r] + u_g_table[g] + u_b_table[b]) / SCALEFACTOR + CENTERSAMPLE)
71−#define COMPUTE_V(r, g, b) \
72− (unsigned char) \
73− ((v_r_table[r] + v_g_table[g] + v_b_table[b]) / SCALEFACTOR + CENTERSAMPLE)
74−
75−#define Y_R (SCALEFACTOR * 0.29900)
76−#define Y_G (SCALEFACTOR * 0.58700)
77−#define Y_B (SCALEFACTOR * 0.11400)
78−
79−#define U_R (SCALEFACTOR * -0.16874)
80−#define U_G (SCALEFACTOR * -0.33126)
81−#define U_B (SCALEFACTOR * 0.50000)
82−
83−#define V_R (SCALEFACTOR * 0.50000)
84−#define V_G (SCALEFACTOR * -0.41869)
85−#define V_B (SCALEFACTOR * -0.08131)
53+ int frame_size;
8654
87−/*
88− * Precalculate all of the YUV tables since it requires fewer than
89− * 10 kilobytes to store them.
90− */
91−static int y_r_table[256];
92−static int y_g_table[256];
93−static int y_b_table[256];
94−
95−static int u_r_table[256];
96−static int u_g_table[256];
97−static int u_b_table[256];
98−
99−static int v_r_table[256];
100−static int v_g_table[256];
101−static int v_b_table[256];
55+} XanContext;
10256
10357 static int xan_decode_init(AVCodecContext *avctx)
10458 {
10559 XanContext *s = avctx->priv_data;
106− int i;
10760
10861 s->avctx = avctx;
62+ s->frame_size = 0;
10963
11064 if ((avctx->codec->id == CODEC_ID_XAN_WC3) &&
11165 (s->avctx->palctrl == NULL)) {
@@ -115,28 +69,14 @@ static int xan_decode_init(AVCodecContext *avctx) · 3 unmodified lines
11569
11670 avctx->pix_fmt = PIX_FMT_PAL8;
11771 avctx->has_b_frames = 0;
118− dsputil_init(&s->dsp, avctx);
119−
120− /* initialize the RGB -> YUV tables */
121− for (i = 0; i < 256; i++) {
122− y_r_table[i] = Y_R * i;
123− y_g_table[i] = Y_G * i;
124− y_b_table[i] = Y_B * i;
125−
126− u_r_table[i] = U_R * i;
127− u_g_table[i] = U_G * i;
128− u_b_table[i] = U_B * i;
129−
130− v_r_table[i] = V_R * i;
131− v_g_table[i] = V_G * i;
132− v_b_table[i] = V_B * i;
133− }
13472
13573 if(avcodec_check_dimensions(avctx, avctx->width, avctx->height))
13674 return -1;
13775
138− s->buffer1 = av_malloc(avctx->width * avctx->height);
139− s->buffer2 = av_malloc(avctx->width * avctx->height);
76+ s->buffer1_size = avctx->width * avctx->height;
77+ s->buffer1 = av_malloc(s->buffer1_size);
78+ s->buffer2_size = avctx->width * avctx->height;
79+ s->buffer2 = av_malloc(s->buffer2_size);
14080 if (!s->buffer1 || !s->buffer2)
14181 return -1;
14282
@@ -156,13 +96,15 @@ static inline void bytecopy(unsigned char *dest, unsigned char *src, int count) · 13 unmodified lines
15696 dest[i] = src[i];
15797 }
15898
159−static int xan_huffman_decode(unsigned char *dest, unsigned char *src)
99+static int xan_huffman_decode(unsigned char *dest, unsigned char *src,
100+ int dest_len)
160101 {
161102 unsigned char byte = *src++;
162103 unsigned char ival = byte + 0x16;
163104 unsigned char * ptr = src + byte*2;
164105 unsigned char val = ival;
165106 int counter = 0;
107+ unsigned char *dest_end = dest + dest_len;
166108
167109 unsigned char bits = *ptr++;
168110
@@ -173,6 +115,8 @@ static int xan_huffman_decode(unsigned char *dest, unsigned char *src) · 4 unmodified lines
173115 val = src[val - 0x17];
174116
175117 if ( val < 0x16 ) {
118+ if (dest + 1 > dest_end)
119+ return 0;
176120 *dest++ = val;
177121 val = ival;
178122 }
@@ -186,12 +130,13 @@ static int xan_huffman_decode(unsigned char *dest, unsigned char *src) · 7 unmodified lines
186130 return 0;
187131 }
188132
189−static void xan_unpack(unsigned char *dest, unsigned char *src)
133+static void xan_unpack(unsigned char *dest, unsigned char *src, int dest_len)
190134 {
191135 unsigned char opcode;
192136 int size;
193137 int offset;
194138 int byte1, byte2, byte3;
139+ unsigned char *dest_end = dest + dest_len;
195140
196141 for (;;) {
197142 opcode = *src++;
@@ -201,9 +146,13 @@ static void xan_unpack(unsigned char *dest, unsigned char *src) · 3 unmodified lines
201146 offset = *src++;
202147
203148 size = opcode & 3;
149+ if (dest + size > dest_end)
150+ return;
204151 bytecopy(dest, src, size); dest += size; src += size;
205152
206153 size = ((opcode & 0x1c) >> 2) + 3;
154+ if (dest + size > dest_end)
155+ return;
207156 bytecopy (dest, dest - (((opcode & 0x60) << 3) + offset + 1), size);
208157 dest += size;
209158
@@ -213,9 +162,13 @@ static void xan_unpack(unsigned char *dest, unsigned char *src) · 3 unmodified lines
213162 byte2 = *src++;
214163
215164 size = byte1 >> 6;
165+ if (dest + size > dest_end)
166+ return;
216167 bytecopy (dest, src, size); dest += size; src += size;
217168
218169 size = (opcode & 0x3f) + 4;
170+ if (dest + size > dest_end)
171+ return;
219172 bytecopy (dest, dest - (((byte1 & 0x3f) << 8) + byte2 + 1), size);
220173 dest += size;
221174
@@ -226,9 +179,13 @@ static void xan_unpack(unsigned char *dest, unsigned char *src) · 4 unmodified lines
226179 byte3 = *src++;
227180
228181 size = opcode & 3;
182+ if (dest + size > dest_end)
183+ return;
229184 bytecopy (dest, src, size); dest += size; src += size;
230185
231186 size = byte3 + 5 + ((opcode & 0xc) << 6);
187+ if (dest + size > dest_end)
188+ return;
232189 bytecopy (dest,
233190 dest - ((((opcode & 0x10) >> 4) << 0x10) + 1 + (byte1 << 8) + byte2),
234191 size);
@@ -239,6 +196,8 @@ static void xan_unpack(unsigned char *dest, unsigned char *src) · 4 unmodified lines
239196 if (size > 0x70)
240197 break;
241198
199+ if (dest + size > dest_end)
200+ return;
242201 bytecopy (dest, src, size); dest += size; src += size;
243202 }
244203 }
@@ -247,105 +206,6 @@ static void xan_unpack(unsigned char *dest, unsigned char *src) · 2 unmodified lines
247206 bytecopy(dest, src, size); dest += size; src += size;
248207 }
249208
250−static void inline xan_wc3_build_palette(XanContext *s,
251− unsigned int *palette_data)
252−{
253− int i;
254− unsigned char r, g, b;
255− unsigned short *palette16;
256− unsigned int *palette32;
257− unsigned int pal_elem;
258−
259− /* transform the palette passed through the palette control structure
260− * into the necessary internal format depending on colorspace */
261−
262− switch (s->avctx->pix_fmt) {
263−
264− case PIX_FMT_RGB555:
265− palette16 = (unsigned short *)s->palette;
266− for (i = 0; i < PALETTE_COUNT; i++) {
267− pal_elem = palette_data[i];
268− r = (pal_elem >> 16) & 0xff;
269− g = (pal_elem >> 8) & 0xff;
270− b = pal_elem & 0xff;
271− palette16[i] =
272− ((r >> 3) << 10) |
273− ((g >> 3) << 5) |
274− ((b >> 3) << 0);
275− }
276− break;
277−
278− case PIX_FMT_RGB565:
279− palette16 = (unsigned short *)s->palette;
280− for (i = 0; i < PALETTE_COUNT; i++) {
281− pal_elem = palette_data[i];
282− r = (pal_elem >> 16) & 0xff;
283− g = (pal_elem >> 8) & 0xff;
284− b = pal_elem & 0xff;
285− palette16[i] =
286− ((r >> 3) << 11) |
287− ((g >> 2) << 5) |
288− ((b >> 3) << 0);
289− }
290− break;
291−
292− case PIX_FMT_RGB24:
293− for (i = 0; i < PALETTE_COUNT; i++) {
294− pal_elem = palette_data[i];
295− r = (pal_elem >> 16) & 0xff;
296− g = (pal_elem >> 8) & 0xff;
297− b = pal_elem & 0xff;
298− s->palette[i * 4 + 0] = r;
299− s->palette[i * 4 + 1] = g;
300− s->palette[i * 4 + 2] = b;
301− }
302− break;
303−
304− case PIX_FMT_BGR24:
305− for (i = 0; i < PALETTE_COUNT; i++) {
306− pal_elem = palette_data[i];
307− r = (pal_elem >> 16) & 0xff;
308− g = (pal_elem >> 8) & 0xff;
309− b = pal_elem & 0xff;
310− s->palette[i * 4 + 0] = b;
311− s->palette[i * 4 + 1] = g;
312− s->palette[i * 4 + 2] = r;
313− }
314− break;
315−
316− case PIX_FMT_PAL8:
317− case PIX_FMT_RGBA32:
318− palette32 = (unsigned int *)s->palette;
319− memcpy (palette32, palette_data, PALETTE_COUNT * sizeof(unsigned int));
320− break;
321−
322− case PIX_FMT_YUV444P:
323− for (i = 0; i < PALETTE_COUNT; i++) {
324− pal_elem = palette_data[i];
325− r = (pal_elem >> 16) & 0xff;
326− g = (pal_elem >> 8) & 0xff;
327− b = pal_elem & 0xff;
328− s->palette[i * 4 + 0] = COMPUTE_Y(r, g, b);
329− s->palette[i * 4 + 1] = COMPUTE_U(r, g, b);
330− s->palette[i * 4 + 2] = COMPUTE_V(r, g, b);
331− }
332− break;
333−
334− default:
335− av_log(s->avctx, AV_LOG_ERROR, " Xan WC3: Unhandled colorspace\n");
336− break;
337− }
338−}
339−
340−/* advance current_x variable; reset accounting variables if current_x
341− * moves beyond width */
342−#define ADVANCE_CURRENT_X() \
343− current_x++; \
344− if (current_x >= width) { \
345− index += line_inc; \
346− current_x = 0; \
347− }
348−
349209 static void inline xan_wc3_output_pixel_run(XanContext *s,
350210 unsigned char *pixel_buffer, int x, int y, int pixel_count)
351211 {
@@ -354,124 +214,27 @@ static void inline xan_wc3_output_pixel_run(XanContext *s, · 2 unmodified lines
354214 int index;
355215 int current_x;
356216 int width = s->avctx->width;
357− unsigned char pix;
358217 unsigned char *palette_plane;
359− unsigned char *y_plane;
360− unsigned char *u_plane;
361− unsigned char *v_plane;
362− unsigned char *rgb_plane;
363− unsigned short *rgb16_plane;
364− unsigned short *palette16;
365− unsigned int *rgb32_plane;
366− unsigned int *palette32;
367−
368− switch (s->avctx->pix_fmt) {
369−
370− case PIX_FMT_PAL8:
371− palette_plane = s->current_frame.data[0];
372− stride = s->current_frame.linesize[0];
373− line_inc = stride - width;
374− index = y * stride + x;
375− current_x = x;
376− while(pixel_count--) {
377−
378− /* don't do a memcpy() here; keyframes generally copy an entire
379− * frame of data and the stride needs to be accounted for */
380− palette_plane[index++] = *pixel_buffer++;
381−
382− ADVANCE_CURRENT_X();
383− }
384− break;
385−
386− case PIX_FMT_RGB555:
387− case PIX_FMT_RGB565:
388− rgb16_plane = (unsigned short *)s->current_frame.data[0];
389− palette16 = (unsigned short *)s->palette;
390− stride = s->current_frame.linesize[0] / 2;
391− line_inc = stride - width;
392− index = y * stride + x;
393− current_x = x;
394− while(pixel_count--) {
395218
396− rgb16_plane[index++] = palette16[*pixel_buffer++];
397−
398− ADVANCE_CURRENT_X();
399− }
400− break;
401−
402− case PIX_FMT_RGB24:
403− case PIX_FMT_BGR24:
404− rgb_plane = s->current_frame.data[0];
405− stride = s->current_frame.linesize[0];
406− line_inc = stride - width * 3;
407− index = y * stride + x * 3;
408− current_x = x;
409− while(pixel_count--) {
410− pix = *pixel_buffer++;
411−
412− rgb_plane[index++] = s->palette[pix * 4 + 0];
413− rgb_plane[index++] = s->palette[pix * 4 + 1];
414− rgb_plane[index++] = s->palette[pix * 4 + 2];
415−
416− ADVANCE_CURRENT_X();
219+ palette_plane = s->current_frame.data[0];
220+ stride = s->current_frame.linesize[0];
221+ line_inc = stride - width;
222+ index = y * stride + x;
223+ current_x = x;
224+ while((pixel_count--) && (index < s->frame_size)) {
225+
226+ /* don't do a memcpy() here; keyframes generally copy an entire
227+ * frame of data and the stride needs to be accounted for */
228+ palette_plane[index++] = *pixel_buffer++;
229+
230+ current_x++;
231+ if (current_x >= width) {
232+ index += line_inc;
233+ current_x = 0;
417234 }
418− break;
419−
420− case PIX_FMT_RGBA32:
421− rgb32_plane = (unsigned int *)s->current_frame.data[0];
422− palette32 = (unsigned int *)s->palette;
423− stride = s->current_frame.linesize[0] / 4;
424− line_inc = stride - width;
425− index = y * stride + x;
426− current_x = x;
427− while(pixel_count--) {
428−
429− rgb32_plane[index++] = palette32[*pixel_buffer++];
430−
431− ADVANCE_CURRENT_X();
432− }
433− break;
434−
435− case PIX_FMT_YUV444P:
436− y_plane = s->current_frame.data[0];
437− u_plane = s->current_frame.data[1];
438− v_plane = s->current_frame.data[2];
439− stride = s->current_frame.linesize[0];
440− line_inc = stride - width;
441− index = y * stride + x;
442− current_x = x;
443− while(pixel_count--) {
444− pix = *pixel_buffer++;
445−
446− y_plane[index] = s->palette[pix * 4 + 0];
447− u_plane[index] = s->palette[pix * 4 + 1];
448− v_plane[index] = s->palette[pix * 4 + 2];
449−
450− index++;
451− ADVANCE_CURRENT_X();
452− }
453− break;
454−
455− default:
456− av_log(s->avctx, AV_LOG_ERROR, " Xan WC3: Unhandled colorspace\n");
457− break;
458235 }
459236 }
460237
461−#define ADVANCE_CURFRAME_X() \
462− curframe_x++; \
463− if (curframe_x >= width) { \
464− curframe_index += line_inc; \
465− curframe_x = 0; \
466− }
467−
468−#define ADVANCE_PREVFRAME_X() \
469− prevframe_x++; \
470− if (prevframe_x >= width) { \
471− prevframe_index += line_inc; \
472− prevframe_x = 0; \
473− }
474−
475238 static void inline xan_wc3_copy_pixel_run(XanContext *s,
476239 int x, int y, int pixel_count, int motion_x, int motion_y)
477240 {
@@ -481,123 +244,31 @@ static void inline xan_wc3_copy_pixel_run(XanContext *s, · 3 unmodified lines
481244 int curframe_x, prevframe_x;
482245 int width = s->avctx->width;
483246 unsigned char *palette_plane, *prev_palette_plane;
484− unsigned char *y_plane, *u_plane, *v_plane;
485− unsigned char *prev_y_plane, *prev_u_plane, *prev_v_plane;
486− unsigned char *rgb_plane, *prev_rgb_plane;
487− unsigned short *rgb16_plane, *prev_rgb16_plane;
488− unsigned int *rgb32_plane, *prev_rgb32_plane;
489−
490− switch (s->avctx->pix_fmt) {
491−
492− case PIX_FMT_PAL8:
493− palette_plane = s->current_frame.data[0];
494− prev_palette_plane = s->last_frame.data[0];
495− stride = s->current_frame.linesize[0];
496− line_inc = stride - width;
497− curframe_index = y * stride + x;
498− curframe_x = x;
499− prevframe_index = (y + motion_y) * stride + x + motion_x;
500− prevframe_x = x + motion_x;
501− while(pixel_count--) {
502−
503− palette_plane[curframe_index++] =
504− prev_palette_plane[prevframe_index++];
505−
506− ADVANCE_CURFRAME_X();
507− ADVANCE_PREVFRAME_X();
508− }
509− break;
510−
511− case PIX_FMT_RGB555:
512− case PIX_FMT_RGB565:
513− rgb16_plane = (unsigned short *)s->current_frame.data[0];
514− prev_rgb16_plane = (unsigned short *)s->last_frame.data[0];
515− stride = s->current_frame.linesize[0] / 2;
516− line_inc = stride - width;
517− curframe_index = y * stride + x;
518− curframe_x = x;
519− prevframe_index = (y + motion_y) * stride + x + motion_x;
520− prevframe_x = x + motion_x;
521− while(pixel_count--) {
522−
523− rgb16_plane[curframe_index++] =
524− prev_rgb16_plane[prevframe_index++];
525−
526− ADVANCE_CURFRAME_X();
527− ADVANCE_PREVFRAME_X();
528− }
529− break;
530−
531− case PIX_FMT_RGB24:
532− case PIX_FMT_BGR24:
533− rgb_plane = s->current_frame.data[0];
534− prev_rgb_plane = s->last_frame.data[0];
535− stride = s->current_frame.linesize[0];
536− line_inc = stride - width * 3;
537− curframe_index = y * stride + x * 3;
538− curframe_x = x;
539− prevframe_index = (y + motion_y) * stride +
540− (3 * (x + motion_x));
541− prevframe_x = x + motion_x;
542− while(pixel_count--) {
543−
544− rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++];
545− rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++];
546− rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++];
547−
548− ADVANCE_CURFRAME_X();
549− ADVANCE_PREVFRAME_X();
550− }
551− break;
552−
553− case PIX_FMT_RGBA32:
554− rgb32_plane = (unsigned int *)s->current_frame.data[0];
555− prev_rgb32_plane = (unsigned int *)s->last_frame.data[0];
556− stride = s->current_frame.linesize[0] / 4;
557− line_inc = stride - width;
558− curframe_index = y * stride + x;
559− curframe_x = x;
560− prevframe_index = (y + motion_y) * stride + x + motion_x;
561− prevframe_x = x + motion_x;
562− while(pixel_count--) {
563−
564− rgb32_plane[curframe_index++] =
565− prev_rgb32_plane[prevframe_index++];
566−
567− ADVANCE_CURFRAME_X();
568− ADVANCE_PREVFRAME_X();
569− }
570− break;
571−
572− case PIX_FMT_YUV444P:
573− y_plane = s->current_frame.data[0];
574− u_plane = s->current_frame.data[1];
575− v_plane = s->current_frame.data[2];
576− prev_y_plane = s->last_frame.data[0];
577− prev_u_plane = s->last_frame.data[1];
578− prev_v_plane = s->last_frame.data[2];
579− stride = s->current_frame.linesize[0];
580− line_inc = stride - width;
581− curframe_index = y * stride + x;
582− curframe_x = x;
583− prevframe_index = (y + motion_y) * stride + x + motion_x;
584− prevframe_x = x + motion_x;
585− while(pixel_count--) {
586−
587− y_plane[curframe_index] = prev_y_plane[prevframe_index];
588− u_plane[curframe_index] = prev_u_plane[prevframe_index];
589− v_plane[curframe_index] = prev_v_plane[prevframe_index];
590−
591− curframe_index++;
592− ADVANCE_CURFRAME_X();
593− prevframe_index++;
594− ADVANCE_PREVFRAME_X();
247+
248+ palette_plane = s->current_frame.data[0];
249+ prev_palette_plane = s->last_frame.data[0];
250+ stride = s->current_frame.linesize[0];
251+ line_inc = stride - width;
252+ curframe_index = y * stride + x;
253+ curframe_x = x;
254+ prevframe_index = (y + motion_y) * stride + x + motion_x;
255+ prevframe_x = x + motion_x;
256+ while((pixel_count--) && (curframe_index < s->frame_size)) {
257+
258+ palette_plane[curframe_index++] =
259+ prev_palette_plane[prevframe_index++];
260+
261+ curframe_x++;
262+ if (curframe_x >= width) {
263+ curframe_index += line_inc;
264+ curframe_x = 0;
595265 }
596− break;
597266
598− default:
599− av_log(s->avctx, AV_LOG_ERROR, " Xan WC3: Unhandled colorspace\n");
600− break;
267+ prevframe_x++;
268+ if (prevframe_x >= width) {
269+ prevframe_index += line_inc;
270+ prevframe_x = 0;
271+ }
601272 }
602273 }
603274
@@ -613,7 +284,9 @@ static void xan_wc3_decode_frame(XanContext *s) { · 9 unmodified lines
613284 int x, y;
614285
615286 unsigned char *opcode_buffer = s->buffer1;
287+ int opcode_buffer_size = s->buffer1_size;
616288 unsigned char *imagedata_buffer = s->buffer2;
289+ int imagedata_buffer_size = s->buffer2_size;
617290
618291 /* pointers to segments inside the compressed chunk */
619292 unsigned char *huffman_segment;
@@ -626,10 +299,11 @@ static void xan_wc3_decode_frame(XanContext *s) { · 6 unmodified lines
626299 vector_segment = s->buf + LE_16(&s->buf[4]);
627300 imagedata_segment = s->buf + LE_16(&s->buf[6]);
628301
629− xan_huffman_decode(opcode_buffer, huffman_segment);
302+ xan_huffman_decode(opcode_buffer, huffman_segment, opcode_buffer_size);
630303
631304 if (imagedata_segment[0] == 2)
632− xan_unpack(imagedata_buffer, &imagedata_segment[1]);
305+ xan_unpack(imagedata_buffer, &imagedata_segment[1],
306+ imagedata_buffer_size);
633307 else
634308 imagedata_buffer = &imagedata_segment[1];
635309
@@ -727,13 +401,6 @@ static void xan_wc3_decode_frame(XanContext *s) { · 91 unmodified lines
727401 }
728402 }
729403 }
730−
731− /* for PAL8, make the palette available on the way out */
732− if (s->avctx->pix_fmt == PIX_FMT_PAL8) {
733− memcpy(s->current_frame.data[1], s->palette, PALETTE_COUNT * 4);
734− s->current_frame.palette_has_changed = 1;
735− s->avctx->palctrl->palette_changed = 0;
736− }
737404 }
738405
739406 static void xan_wc4_decode_frame(XanContext *s) {
@@ -745,16 +412,6 @@ static int xan_decode_frame(AVCodecContext *avctx, · 5 unmodified lines
745412 {
746413 XanContext *s = avctx->priv_data;
747414 AVPaletteControl *palette_control = avctx->palctrl;
748− int keyframe = 0;
749−
750− if (palette_control->palette_changed) {
751− /* load the new palette and reset the palette control */
752− xan_wc3_build_palette(s, palette_control->palette);
753− /* If pal8 we clear flag when we copy palette */
754− if (s->avctx->pix_fmt != PIX_FMT_PAL8)
755− palette_control->palette_changed = 0;
756− keyframe = 1;
757− }
758415
759416 if (avctx->get_buffer(avctx, &s->current_frame)) {
760417 av_log(s->avctx, AV_LOG_ERROR, " Xan Video: get_buffer() failed\n");
@@ -762,6 +419,14 @@ static int xan_decode_frame(AVCodecContext *avctx, · 1 unmodified line
762419 }
763420 s->current_frame.reference = 3;
764421
422+ if (!s->frame_size)
423+ s->frame_size = s->current_frame.linesize[0] * s->avctx->height;
424+
425+ palette_control->palette_changed = 0;
426+ memcpy(s->current_frame.data[1], palette_control->palette,
427+ AVPALETTE_SIZE);
428+ s->current_frame.palette_has_changed = 1;
429+
765430 s->buf = buf;
766431 s->size = buf_size;
767432
@@ -789,7 +454,8 @@ static int xan_decode_end(AVCodecContext *avctx) · 21 unmodified lines
789454 XanContext *s = avctx->priv_data;
790455
791456 /* release the last frame */
792− avctx->release_buffer(avctx, &s->last_frame);
457+ if (s->last_frame.data[0])
458+ avctx->release_buffer(avctx, &s->last_frame);
793459
794460 av_free(s->buffer1);
795461 av_free(s->buffer2);

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t