X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fxan.c;h=f98a06bca94a5720827a903e8e2e8b987b3b7902;hb=c5c3a926740e467243fa6730452acc7a97a32436;hp=72d4e5f14f8d34a29bf331bac9a75cb1423efc0b;hpb=9937e686fe86cc463577208d67431dabe74ad2ae;p=ffmpeg diff --git a/libavcodec/xan.c b/libavcodec/xan.c index 72d4e5f14f8..f98a06bca94 100644 --- a/libavcodec/xan.c +++ b/libavcodec/xan.c @@ -23,8 +23,9 @@ * Xan video decoder for Wing Commander III & IV computer games * by Mario Brito (mbrito@student.dei.uc.pt) * and Mike Melanson (melanson@pcisys.net) - * For more information about the Xan format, visit: - * http://www.pcisys.net/~melanson/codecs/ + * + * The xan_wc3 decoder outputs the following colorspaces natively: + * PAL8 (default), RGB555, RGB565, RGB24, BGR24, RGBA32, YUV444P */ #include @@ -57,13 +58,6 @@ typedef struct XanContext { } XanContext; -#define BE_16(x) ((((uint8_t*)(x))[0] << 8) | ((uint8_t*)(x))[1]) -#define LE_16(x) ((((uint8_t*)(x))[1] << 8) | ((uint8_t*)(x))[0]) -#define LE_32(x) ((((uint8_t*)(x))[3] << 24) | \ - (((uint8_t*)(x))[2] << 16) | \ - (((uint8_t*)(x))[1] << 8) | \ - ((uint8_t*)(x))[0]) - /* RGB -> YUV conversion stuff */ #define SCALEFACTOR 65536 #define CENTERSAMPLE 128 @@ -114,13 +108,12 @@ static int xan_decode_init(AVCodecContext *avctx) s->avctx = avctx; if ((avctx->codec->id == CODEC_ID_XAN_WC3) && - (s->avctx->extradata_size != PALETTE_CONTROL_SIZE)) { - printf (" WC3 Xan video: expected extradata_size of %d\n", - PALETTE_CONTROL_SIZE); + (s->avctx->palctrl == NULL)) { + av_log(avctx, AV_LOG_ERROR, " WC3 Xan video: palette expected.\n"); return -1; } - avctx->pix_fmt = PIX_FMT_YUV444P; + avctx->pix_fmt = PIX_FMT_PAL8; avctx->has_b_frames = 0; dsputil_init(&s->dsp, avctx); @@ -139,8 +132,8 @@ static int xan_decode_init(AVCodecContext *avctx) v_b_table[i] = V_B * i; } - s->buffer1 = av_malloc(avctx->width * avctx->height * 4); - s->buffer2 = av_malloc(avctx->width * avctx->height * 4); + s->buffer1 = av_malloc(avctx->width * avctx->height); + s->buffer2 = av_malloc(avctx->width * avctx->height); if (!s->buffer1 || !s->buffer2) return -1; @@ -160,7 +153,7 @@ static inline void bytecopy(unsigned char *dest, unsigned char *src, int count) dest[i] = src[i]; } -static int xan_decode_method_1(unsigned char *dest, unsigned char *src) +static int xan_huffman_decode(unsigned char *dest, unsigned char *src) { unsigned char byte = *src++; unsigned char ival = byte + 0x16; @@ -190,7 +183,7 @@ static int xan_decode_method_1(unsigned char *dest, unsigned char *src) return 0; } -static int xan_decode_method_2(unsigned char *dest, unsigned char *src) +static void xan_unpack(unsigned char *dest, unsigned char *src) { unsigned char opcode; int size; @@ -249,26 +242,86 @@ static int xan_decode_method_2(unsigned char *dest, unsigned char *src) size = opcode & 3; bytecopy(dest, src, size); dest += size; src += size; - - return 0; } static void inline xan_wc3_build_palette(XanContext *s, - unsigned char *palette_data) + unsigned int *palette_data) { int i; unsigned char r, g, b; + unsigned short *palette16; + unsigned int *palette32; + unsigned int pal_elem; /* transform the palette passed through the palette control structure * into the necessary internal format depending on colorspace */ switch (s->avctx->pix_fmt) { + case PIX_FMT_RGB555: + palette16 = (unsigned short *)s->palette; + for (i = 0; i < PALETTE_COUNT; i++) { + pal_elem = palette_data[i]; + r = (pal_elem >> 16) & 0xff; + g = (pal_elem >> 8) & 0xff; + b = pal_elem & 0xff; + palette16[i] = + ((r >> 3) << 10) | + ((g >> 3) << 5) | + ((b >> 3) << 0); + } + break; + + case PIX_FMT_RGB565: + palette16 = (unsigned short *)s->palette; + for (i = 0; i < PALETTE_COUNT; i++) { + pal_elem = palette_data[i]; + r = (pal_elem >> 16) & 0xff; + g = (pal_elem >> 8) & 0xff; + b = pal_elem & 0xff; + palette16[i] = + ((r >> 3) << 11) | + ((g >> 2) << 5) | + ((b >> 3) << 0); + } + break; + + case PIX_FMT_RGB24: + for (i = 0; i < PALETTE_COUNT; i++) { + pal_elem = palette_data[i]; + r = (pal_elem >> 16) & 0xff; + g = (pal_elem >> 8) & 0xff; + b = pal_elem & 0xff; + s->palette[i * 4 + 0] = r; + s->palette[i * 4 + 1] = g; + s->palette[i * 4 + 2] = b; + } + break; + + case PIX_FMT_BGR24: + for (i = 0; i < PALETTE_COUNT; i++) { + pal_elem = palette_data[i]; + r = (pal_elem >> 16) & 0xff; + g = (pal_elem >> 8) & 0xff; + b = pal_elem & 0xff; + s->palette[i * 4 + 0] = b; + s->palette[i * 4 + 1] = g; + s->palette[i * 4 + 2] = r; + } + break; + + case PIX_FMT_PAL8: + case PIX_FMT_RGBA32: + palette32 = (unsigned int *)s->palette; + memcpy (palette32, palette_data, PALETTE_COUNT * sizeof(unsigned int)); + break; + case PIX_FMT_YUV444P: for (i = 0; i < PALETTE_COUNT; i++) { - r = *palette_data++; - g = *palette_data++; - b = *palette_data++; + pal_elem = palette_data[i]; + r = (pal_elem >> 16) & 0xff; + g = (pal_elem >> 8) & 0xff; + b = pal_elem & 0xff; s->palette[i * 4 + 0] = COMPUTE_Y(r, g, b); s->palette[i * 4 + 1] = COMPUTE_U(r, g, b); s->palette[i * 4 + 2] = COMPUTE_V(r, g, b); @@ -276,11 +329,20 @@ static void inline xan_wc3_build_palette(XanContext *s, break; default: - printf (" Xan WC3: Unhandled colorspace\n"); + av_log(s->avctx, AV_LOG_ERROR, " Xan WC3: Unhandled colorspace\n"); break; } } +/* advance current_x variable; reset accounting variables if current_x + * moves beyond width */ +#define ADVANCE_CURRENT_X() \ + current_x++; \ + if (current_x >= width) { \ + index += line_inc; \ + current_x = 0; \ + } + static void inline xan_wc3_output_pixel_run(XanContext *s, unsigned char *pixel_buffer, int x, int y, int pixel_count) { @@ -289,13 +351,84 @@ static void inline xan_wc3_output_pixel_run(XanContext *s, int index; int current_x; int width = s->avctx->width; - unsigned char pixel; + unsigned char pix; + unsigned char *palette_plane; unsigned char *y_plane; unsigned char *u_plane; unsigned char *v_plane; + unsigned char *rgb_plane; + unsigned short *rgb16_plane; + unsigned short *palette16; + unsigned int *rgb32_plane; + unsigned int *palette32; switch (s->avctx->pix_fmt) { + case PIX_FMT_PAL8: + palette_plane = s->current_frame.data[0]; + stride = s->current_frame.linesize[0]; + line_inc = stride - width; + index = y * stride + x; + current_x = x; + while(pixel_count--) { + + /* don't do a memcpy() here; keyframes generally copy an entire + * frame of data and the stride needs to be accounted for */ + palette_plane[index++] = *pixel_buffer++; + + ADVANCE_CURRENT_X(); + } + break; + + case PIX_FMT_RGB555: + case PIX_FMT_RGB565: + rgb16_plane = (unsigned short *)s->current_frame.data[0]; + palette16 = (unsigned short *)s->palette; + stride = s->current_frame.linesize[0] / 2; + line_inc = stride - width; + index = y * stride + x; + current_x = x; + while(pixel_count--) { + + rgb16_plane[index++] = palette16[*pixel_buffer++]; + + ADVANCE_CURRENT_X(); + } + break; + + case PIX_FMT_RGB24: + case PIX_FMT_BGR24: + rgb_plane = s->current_frame.data[0]; + stride = s->current_frame.linesize[0]; + line_inc = stride - width * 3; + index = y * stride + x * 3; + current_x = x; + while(pixel_count--) { + pix = *pixel_buffer++; + + rgb_plane[index++] = s->palette[pix * 4 + 0]; + rgb_plane[index++] = s->palette[pix * 4 + 1]; + rgb_plane[index++] = s->palette[pix * 4 + 2]; + + ADVANCE_CURRENT_X(); + } + break; + + case PIX_FMT_RGBA32: + rgb32_plane = (unsigned int *)s->current_frame.data[0]; + palette32 = (unsigned int *)s->palette; + stride = s->current_frame.linesize[0] / 4; + line_inc = stride - width; + index = y * stride + x; + current_x = x; + while(pixel_count--) { + + rgb32_plane[index++] = palette32[*pixel_buffer++]; + + ADVANCE_CURRENT_X(); + } + break; + case PIX_FMT_YUV444P: y_plane = s->current_frame.data[0]; u_plane = s->current_frame.data[1]; @@ -305,28 +438,37 @@ static void inline xan_wc3_output_pixel_run(XanContext *s, index = y * stride + x; current_x = x; while(pixel_count--) { - pixel = *pixel_buffer++; + pix = *pixel_buffer++; - y_plane[index] = s->palette[pixel * 4 + 0]; - u_plane[index] = s->palette[pixel * 4 + 1]; - v_plane[index] = s->palette[pixel * 4 + 2]; + y_plane[index] = s->palette[pix * 4 + 0]; + u_plane[index] = s->palette[pix * 4 + 1]; + v_plane[index] = s->palette[pix * 4 + 2]; index++; - current_x++; - if (current_x >= width) { - /* reset accounting variables */ - index += line_inc; - current_x = 0; - } + ADVANCE_CURRENT_X(); } break; default: - printf (" Xan WC3: Unhandled colorspace\n"); + av_log(s->avctx, AV_LOG_ERROR, " Xan WC3: Unhandled colorspace\n"); break; } } +#define ADVANCE_CURFRAME_X() \ + curframe_x++; \ + if (curframe_x >= width) { \ + curframe_index += line_inc; \ + curframe_x = 0; \ + } + +#define ADVANCE_PREVFRAME_X() \ + prevframe_x++; \ + if (prevframe_x >= width) { \ + prevframe_index += line_inc; \ + prevframe_x = 0; \ + } + static void inline xan_wc3_copy_pixel_run(XanContext *s, int x, int y, int pixel_count, int motion_x, int motion_y) { @@ -335,11 +477,95 @@ static void inline xan_wc3_copy_pixel_run(XanContext *s, int curframe_index, prevframe_index; int curframe_x, prevframe_x; int width = s->avctx->width; + unsigned char *palette_plane, *prev_palette_plane; unsigned char *y_plane, *u_plane, *v_plane; unsigned char *prev_y_plane, *prev_u_plane, *prev_v_plane; + unsigned char *rgb_plane, *prev_rgb_plane; + unsigned short *rgb16_plane, *prev_rgb16_plane; + unsigned int *rgb32_plane, *prev_rgb32_plane; switch (s->avctx->pix_fmt) { + case PIX_FMT_PAL8: + palette_plane = s->current_frame.data[0]; + prev_palette_plane = s->last_frame.data[0]; + stride = s->current_frame.linesize[0]; + line_inc = stride - width; + curframe_index = y * stride + x; + curframe_x = x; + prevframe_index = (y + motion_y) * stride + x + motion_x; + prevframe_x = x + motion_x; + while(pixel_count--) { + + palette_plane[curframe_index++] = + prev_palette_plane[prevframe_index++]; + + ADVANCE_CURFRAME_X(); + ADVANCE_PREVFRAME_X(); + } + break; + + case PIX_FMT_RGB555: + case PIX_FMT_RGB565: + rgb16_plane = (unsigned short *)s->current_frame.data[0]; + prev_rgb16_plane = (unsigned short *)s->last_frame.data[0]; + stride = s->current_frame.linesize[0] / 2; + line_inc = stride - width; + curframe_index = y * stride + x; + curframe_x = x; + prevframe_index = (y + motion_y) * stride + x + motion_x; + prevframe_x = x + motion_x; + while(pixel_count--) { + + rgb16_plane[curframe_index++] = + prev_rgb16_plane[prevframe_index++]; + + ADVANCE_CURFRAME_X(); + ADVANCE_PREVFRAME_X(); + } + break; + + case PIX_FMT_RGB24: + case PIX_FMT_BGR24: + rgb_plane = s->current_frame.data[0]; + prev_rgb_plane = s->last_frame.data[0]; + stride = s->current_frame.linesize[0]; + line_inc = stride - width * 3; + curframe_index = y * stride + x * 3; + curframe_x = x; + prevframe_index = (y + motion_y) * stride + + (3 * (x + motion_x)); + prevframe_x = x + motion_x; + while(pixel_count--) { + + rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++]; + rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++]; + rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++]; + + ADVANCE_CURFRAME_X(); + ADVANCE_PREVFRAME_X(); + } + break; + + case PIX_FMT_RGBA32: + rgb32_plane = (unsigned int *)s->current_frame.data[0]; + prev_rgb32_plane = (unsigned int *)s->last_frame.data[0]; + stride = s->current_frame.linesize[0] / 4; + line_inc = stride - width; + curframe_index = y * stride + x; + curframe_x = x; + prevframe_index = (y + motion_y) * stride + x + motion_x; + prevframe_x = x + motion_x; + while(pixel_count--) { + + rgb32_plane[curframe_index++] = + prev_rgb32_plane[prevframe_index++]; + + ADVANCE_CURFRAME_X(); + ADVANCE_PREVFRAME_X(); + } + break; + case PIX_FMT_YUV444P: y_plane = s->current_frame.data[0]; u_plane = s->current_frame.data[1]; @@ -351,7 +577,7 @@ static void inline xan_wc3_copy_pixel_run(XanContext *s, line_inc = stride - width; curframe_index = y * stride + x; curframe_x = x; - prevframe_index = (y + motion_x) * stride + x + motion_x; + prevframe_index = (y + motion_y) * stride + x + motion_x; prevframe_x = x + motion_x; while(pixel_count--) { @@ -360,25 +586,14 @@ static void inline xan_wc3_copy_pixel_run(XanContext *s, v_plane[curframe_index] = prev_v_plane[prevframe_index]; curframe_index++; - curframe_x++; - if (curframe_x >= width) { - /* reset accounting variables */ - curframe_index += line_inc; - curframe_x = 0; - } - + ADVANCE_CURFRAME_X(); prevframe_index++; - prevframe_x++; - if (prevframe_x >= width) { - /* reset accounting variables */ - prevframe_index += line_inc; - prevframe_x = 0; - } + ADVANCE_PREVFRAME_X(); } break; default: - printf (" Xan WC3: Unhandled colorspace\n"); + av_log(s->avctx, AV_LOG_ERROR, " Xan WC3: Unhandled colorspace\n"); break; } } @@ -394,31 +609,32 @@ static void xan_wc3_decode_frame(XanContext *s) { int motion_x, motion_y; int x, y; - unsigned char *method1_buffer = s->buffer1; - unsigned char *method2_buffer = s->buffer2; + unsigned char *opcode_buffer = s->buffer1; + unsigned char *imagedata_buffer = s->buffer2; /* pointers to segments inside the compressed chunk */ - unsigned char *method1_segment; + unsigned char *huffman_segment; unsigned char *size_segment; unsigned char *vector_segment; - unsigned char *method2_segment; + unsigned char *imagedata_segment; - method1_segment = s->buf + LE_16(&s->buf[0]); - size_segment = s->buf + LE_16(&s->buf[2]); - vector_segment = s->buf + LE_16(&s->buf[4]); - method2_segment = s->buf + LE_16(&s->buf[6]); + huffman_segment = s->buf + LE_16(&s->buf[0]); + size_segment = s->buf + LE_16(&s->buf[2]); + vector_segment = s->buf + LE_16(&s->buf[4]); + imagedata_segment = s->buf + LE_16(&s->buf[6]); - xan_decode_method_1(method1_buffer, method1_segment); - if (method2_segment[0] == 2) - xan_decode_method_2(method2_buffer, method2_segment + 1); + xan_huffman_decode(opcode_buffer, huffman_segment); + + if (imagedata_segment[0] == 2) + xan_unpack(imagedata_buffer, &imagedata_segment[1]); else - method2_buffer = method2_segment + 1; + imagedata_buffer = &imagedata_segment[1]; /* use the decoded data segments to build the frame */ x = y = 0; while (total_pixels) { - opcode = *method1_buffer++; + opcode = *opcode_buffer++; size = 0; switch (opcode) { @@ -473,9 +689,9 @@ static void xan_wc3_decode_frame(XanContext *s) { /* run of (size) pixels is unchanged from last frame */ xan_wc3_copy_pixel_run(s, x, y, size, 0, 0); } else { - /* output a run of pixels from method2_buffer */ - xan_wc3_output_pixel_run(s, method2_buffer, x, y, size); - method2_buffer += size; + /* output a run of pixels from imagedata_buffer */ + xan_wc3_output_pixel_run(s, imagedata_buffer, x, y, size); + imagedata_buffer += size; } } else { /* run-based motion compensation from last frame */ @@ -508,6 +724,13 @@ static void xan_wc3_decode_frame(XanContext *s) { } } } + + /* for PAL8, make the palette available on the way out */ + if (s->avctx->pix_fmt == PIX_FMT_PAL8) { + memcpy(s->current_frame.data[1], s->palette, PALETTE_COUNT * 4); + s->current_frame.palette_has_changed = 1; + s->avctx->palctrl->palette_changed = 0; + } } static void xan_wc4_decode_frame(XanContext *s) { @@ -518,39 +741,32 @@ static int xan_decode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size) { XanContext *s = avctx->priv_data; - unsigned char *palette_control = avctx->extradata; + AVPaletteControl *palette_control = avctx->palctrl; int keyframe = 0; - if (palette_control[0]) { + if (palette_control->palette_changed) { /* load the new palette and reset the palette control */ - xan_wc3_build_palette(s, &palette_control[1]); - palette_control[0] = 0; + xan_wc3_build_palette(s, palette_control->palette); + /* If pal8 we clear flag when we copy palette */ + if (s->avctx->pix_fmt != PIX_FMT_PAL8) + palette_control->palette_changed = 0; keyframe = 1; } if (avctx->get_buffer(avctx, &s->current_frame)) { - printf (" Interplay Video: get_buffer() failed\n"); + av_log(s->avctx, AV_LOG_ERROR, " Xan Video: get_buffer() failed\n"); return -1; } + s->current_frame.reference = 3; s->buf = buf; s->size = buf_size; - if (avctx->codec->id == CODEC_ID_XAN_WC3) { -// if (keyframe) - if (1) - xan_wc3_decode_frame(s); - else { - memcpy(s->current_frame.data[0], s->last_frame.data[0], - s->current_frame.linesize[0] * avctx->height); - memcpy(s->current_frame.data[1], s->last_frame.data[1], - s->current_frame.linesize[1] * avctx->height); - memcpy(s->current_frame.data[2], s->last_frame.data[2], - s->current_frame.linesize[2] * avctx->height); - } - } else if (avctx->codec->id == CODEC_ID_XAN_WC4) + if (avctx->codec->id == CODEC_ID_XAN_WC3) + xan_wc3_decode_frame(s); + else if (avctx->codec->id == CODEC_ID_XAN_WC4) xan_wc4_decode_frame(s); - + /* release the last frame if it is allocated */ if (s->last_frame.data[0]) avctx->release_buffer(avctx, &s->last_frame);