9937e686 |
/*
* Wing Commander/Xan Video Decoder
* Copyright (C) 2003 the ffmpeg project
* |
b78e7197 |
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or |
9937e686 |
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either |
b78e7197 |
* version 2.1 of the License, or (at your option) any later version. |
9937e686 |
* |
b78e7197 |
* FFmpeg is distributed in the hope that it will be useful, |
9937e686 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public |
b78e7197 |
* License along with FFmpeg; if not, write to the Free Software |
5509bffa |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
9937e686 |
*/
/** |
bad5537e |
* @file libavcodec/xan.c |
ca16618b |
* Xan video decoder for Wing Commander III computer game |
9937e686 |
* by Mario Brito (mbrito@student.dei.uc.pt)
* and Mike Melanson (melanson@pcisys.net) |
6f4915ac |
* |
ca16618b |
* The xan_wc3 decoder outputs PAL8 data. |
9937e686 |
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
|
6a5d31ac |
#include "libavutil/intreadwrite.h" |
9937e686 |
#include "avcodec.h"
typedef struct XanContext {
AVCodecContext *avctx;
AVFrame last_frame;
AVFrame current_frame;
|
c67102f9 |
const unsigned char *buf; |
9937e686 |
int size;
/* scratch space */
unsigned char *buffer1; |
ca16618b |
int buffer1_size; |
9937e686 |
unsigned char *buffer2; |
ca16618b |
int buffer2_size; |
9937e686 |
|
ca16618b |
int frame_size; |
9937e686 |
|
ca16618b |
} XanContext; |
9937e686 |
|
98a6fff9 |
static av_cold int xan_decode_init(AVCodecContext *avctx) |
9937e686 |
{
XanContext *s = avctx->priv_data;
s->avctx = avctx; |
ca16618b |
s->frame_size = 0; |
9937e686 |
|
115329f1 |
if ((avctx->codec->id == CODEC_ID_XAN_WC3) && |
2a2bbcb0 |
(s->avctx->palctrl == NULL)) { |
9b879566 |
av_log(avctx, AV_LOG_ERROR, " WC3 Xan video: palette expected.\n"); |
9937e686 |
return -1;
}
|
6f4915ac |
avctx->pix_fmt = PIX_FMT_PAL8; |
9937e686 |
|
0ecca7a4 |
if(avcodec_check_dimensions(avctx, avctx->width, avctx->height))
return -1; |
115329f1 |
|
ca16618b |
s->buffer1_size = avctx->width * avctx->height;
s->buffer1 = av_malloc(s->buffer1_size);
s->buffer2_size = avctx->width * avctx->height;
s->buffer2 = av_malloc(s->buffer2_size); |
9937e686 |
if (!s->buffer1 || !s->buffer2)
return -1;
return 0;
}
|
fe037229 |
/* This function is used in lieu of memcpy(). This decoder cannot use |
9937e686 |
* memcpy because the memory locations often overlap and
* memcpy doesn't like that; it's not uncommon, for example, for
* dest = src+1, to turn byte A into pattern AAAAAAAA.
* This was originally repz movsb in Intel x86 ASM. */ |
c67102f9 |
static inline void bytecopy(unsigned char *dest, const unsigned char *src, int count) |
9937e686 |
{
int i;
for (i = 0; i < count; i++)
dest[i] = src[i];
}
|
c67102f9 |
static int xan_huffman_decode(unsigned char *dest, const unsigned char *src, |
ca16618b |
int dest_len) |
9937e686 |
{
unsigned char byte = *src++;
unsigned char ival = byte + 0x16; |
c67102f9 |
const unsigned char * ptr = src + byte*2; |
9937e686 |
unsigned char val = ival;
int counter = 0; |
ca16618b |
unsigned char *dest_end = dest + dest_len; |
9937e686 |
unsigned char bits = *ptr++;
while ( val != 0x16 ) {
if ( (1 << counter) & bits )
val = src[byte + val - 0x17];
else
val = src[val - 0x17];
if ( val < 0x16 ) { |
ca16618b |
if (dest + 1 > dest_end)
return 0; |
9937e686 |
*dest++ = val;
val = ival;
}
if (counter++ == 7) {
counter = 0;
bits = *ptr++;
}
}
return 0;
}
|
c67102f9 |
static void xan_unpack(unsigned char *dest, const unsigned char *src, int dest_len) |
9937e686 |
{
unsigned char opcode;
int size;
int offset;
int byte1, byte2, byte3; |
ca16618b |
unsigned char *dest_end = dest + dest_len; |
9937e686 |
for (;;) {
opcode = *src++;
if ( (opcode & 0x80) == 0 ) {
offset = *src++;
size = opcode & 3; |
ca16618b |
if (dest + size > dest_end)
return; |
9937e686 |
bytecopy(dest, src, size); dest += size; src += size;
size = ((opcode & 0x1c) >> 2) + 3; |
ca16618b |
if (dest + size > dest_end)
return; |
9937e686 |
bytecopy (dest, dest - (((opcode & 0x60) << 3) + offset + 1), size);
dest += size;
} else if ( (opcode & 0x40) == 0 ) {
byte1 = *src++;
byte2 = *src++;
size = byte1 >> 6; |
ca16618b |
if (dest + size > dest_end)
return; |
9937e686 |
bytecopy (dest, src, size); dest += size; src += size;
size = (opcode & 0x3f) + 4; |
ca16618b |
if (dest + size > dest_end)
return; |
9937e686 |
bytecopy (dest, dest - (((byte1 & 0x3f) << 8) + byte2 + 1), size);
dest += size;
} else if ( (opcode & 0x20) == 0 ) {
byte1 = *src++;
byte2 = *src++;
byte3 = *src++;
size = opcode & 3; |
ca16618b |
if (dest + size > dest_end)
return; |
9937e686 |
bytecopy (dest, src, size); dest += size; src += size;
size = byte3 + 5 + ((opcode & 0xc) << 6); |
ca16618b |
if (dest + size > dest_end)
return; |
9937e686 |
bytecopy (dest,
dest - ((((opcode & 0x10) >> 4) << 0x10) + 1 + (byte1 << 8) + byte2),
size);
dest += size;
} else {
size = ((opcode & 0x1f) << 2) + 4;
if (size > 0x70)
break;
|
ca16618b |
if (dest + size > dest_end)
return; |
9937e686 |
bytecopy (dest, src, size); dest += size; src += size;
}
}
size = opcode & 3;
bytecopy(dest, src, size); dest += size; src += size;
}
|
5a6a6cc7 |
static inline void xan_wc3_output_pixel_run(XanContext *s, |
9f5bd895 |
const unsigned char *pixel_buffer, int x, int y, int pixel_count) |
9937e686 |
{
int stride;
int line_inc;
int index;
int current_x;
int width = s->avctx->width; |
6f4915ac |
unsigned char *palette_plane;
|
ca16618b |
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--) && (index < s->frame_size)) {
/* 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++;
current_x++;
if (current_x >= width) {
index += line_inc;
current_x = 0; |
6f4915ac |
} |
9937e686 |
}
}
|
5a6a6cc7 |
static inline void xan_wc3_copy_pixel_run(XanContext *s, |
9937e686 |
int x, int y, int pixel_count, int motion_x, int motion_y)
{
int stride;
int line_inc;
int curframe_index, prevframe_index;
int curframe_x, prevframe_x;
int width = s->avctx->width; |
6f4915ac |
unsigned char *palette_plane, *prev_palette_plane; |
ca16618b |
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--) && (curframe_index < s->frame_size)) {
|
115329f1 |
palette_plane[curframe_index++] = |
ca16618b |
prev_palette_plane[prevframe_index++];
curframe_x++;
if (curframe_x >= width) {
curframe_index += line_inc;
curframe_x = 0; |
9937e686 |
}
|
ca16618b |
prevframe_x++;
if (prevframe_x >= width) {
prevframe_index += line_inc;
prevframe_x = 0;
} |
9937e686 |
}
}
static void xan_wc3_decode_frame(XanContext *s) {
int width = s->avctx->width;
int height = s->avctx->height;
int total_pixels = width * height;
unsigned char opcode;
unsigned char flag = 0;
int size = 0;
int motion_x, motion_y;
int x, y;
|
6f4915ac |
unsigned char *opcode_buffer = s->buffer1; |
ca16618b |
int opcode_buffer_size = s->buffer1_size; |
9f5bd895 |
const unsigned char *imagedata_buffer = s->buffer2; |
9937e686 |
/* pointers to segments inside the compressed chunk */ |
c67102f9 |
const unsigned char *huffman_segment;
const unsigned char *size_segment;
const unsigned char *vector_segment;
const unsigned char *imagedata_segment; |
6f4915ac |
|
fead30d4 |
huffman_segment = s->buf + AV_RL16(&s->buf[0]);
size_segment = s->buf + AV_RL16(&s->buf[2]);
vector_segment = s->buf + AV_RL16(&s->buf[4]);
imagedata_segment = s->buf + AV_RL16(&s->buf[6]); |
9937e686 |
|
ca16618b |
xan_huffman_decode(opcode_buffer, huffman_segment, opcode_buffer_size); |
9937e686 |
|
6f4915ac |
if (imagedata_segment[0] == 2) |
9f5bd895 |
xan_unpack(s->buffer2, &imagedata_segment[1], s->buffer2_size); |
9937e686 |
else |
6f4915ac |
imagedata_buffer = &imagedata_segment[1]; |
9937e686 |
/* use the decoded data segments to build the frame */
x = y = 0;
while (total_pixels) {
|
6f4915ac |
opcode = *opcode_buffer++; |
9937e686 |
size = 0;
switch (opcode) {
case 0:
flag ^= 1;
continue;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
size = opcode;
break;
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
size += (opcode - 10);
break;
case 9:
case 19:
size = *size_segment++;
break;
case 10:
case 20: |
fead30d4 |
size = AV_RB16(&size_segment[0]); |
9937e686 |
size_segment += 2;
break;
case 11:
case 21: |
2c124cb6 |
size = AV_RB24(size_segment); |
9937e686 |
size_segment += 3;
break;
}
if (opcode < 12) {
flag ^= 1;
if (flag) {
/* run of (size) pixels is unchanged from last frame */
xan_wc3_copy_pixel_run(s, x, y, size, 0, 0);
} else { |
6f4915ac |
/* output a run of pixels from imagedata_buffer */
xan_wc3_output_pixel_run(s, imagedata_buffer, x, y, size);
imagedata_buffer += size; |
9937e686 |
}
} else {
/* run-based motion compensation from last frame */
motion_x = (*vector_segment >> 4) & 0xF;
motion_y = *vector_segment & 0xF;
vector_segment++;
/* sign extension */
if (motion_x & 0x8)
motion_x |= 0xFFFFFFF0;
if (motion_y & 0x8)
motion_y |= 0xFFFFFFF0;
/* copy a run of pixels from the previous frame */
xan_wc3_copy_pixel_run(s, x, y, size, motion_x, motion_y);
flag = 0;
}
/* coordinate accounting */
total_pixels -= size;
while (size) {
if (x + size >= width) {
y++;
size -= (width - x);
x = 0;
} else {
x += size;
size = 0;
}
}
}
}
static void xan_wc4_decode_frame(XanContext *s) {
}
static int xan_decode_frame(AVCodecContext *avctx,
void *data, int *data_size, |
c67102f9 |
const uint8_t *buf, int buf_size) |
9937e686 |
{
XanContext *s = avctx->priv_data; |
2a2bbcb0 |
AVPaletteControl *palette_control = avctx->palctrl; |
9937e686 |
if (avctx->get_buffer(avctx, &s->current_frame)) { |
9b879566 |
av_log(s->avctx, AV_LOG_ERROR, " Xan Video: get_buffer() failed\n"); |
9937e686 |
return -1;
} |
6f4915ac |
s->current_frame.reference = 3; |
9937e686 |
|
ca16618b |
if (!s->frame_size)
s->frame_size = s->current_frame.linesize[0] * s->avctx->height;
palette_control->palette_changed = 0; |
115329f1 |
memcpy(s->current_frame.data[1], palette_control->palette, |
ca16618b |
AVPALETTE_SIZE);
s->current_frame.palette_has_changed = 1;
|
9937e686 |
s->buf = buf;
s->size = buf_size;
|
6f4915ac |
if (avctx->codec->id == CODEC_ID_XAN_WC3)
xan_wc3_decode_frame(s);
else if (avctx->codec->id == CODEC_ID_XAN_WC4) |
9937e686 |
xan_wc4_decode_frame(s); |
6f4915ac |
|
9937e686 |
/* release the last frame if it is allocated */
if (s->last_frame.data[0])
avctx->release_buffer(avctx, &s->last_frame);
*data_size = sizeof(AVFrame);
*(AVFrame*)data = s->current_frame;
|
282ee4e7 |
/* shuffle frames */
FFSWAP(AVFrame, s->current_frame, s->last_frame);
|
9937e686 |
/* always report that the buffer was completely consumed */
return buf_size;
}
|
98a6fff9 |
static av_cold int xan_decode_end(AVCodecContext *avctx) |
9937e686 |
{
XanContext *s = avctx->priv_data;
|
282ee4e7 |
/* release the frames */ |
ca16618b |
if (s->last_frame.data[0])
avctx->release_buffer(avctx, &s->last_frame); |
282ee4e7 |
if (s->current_frame.data[0])
avctx->release_buffer(avctx, &s->current_frame); |
9937e686 |
av_free(s->buffer1);
av_free(s->buffer2);
return 0;
}
AVCodec xan_wc3_decoder = {
"xan_wc3",
CODEC_TYPE_VIDEO,
CODEC_ID_XAN_WC3,
sizeof(XanContext),
xan_decode_init,
NULL,
xan_decode_end,
xan_decode_frame,
CODEC_CAP_DR1, |
fe4bf374 |
.long_name = NULL_IF_CONFIG_SMALL("Wing Commander III / Xan"), |
9937e686 |
};
/*
AVCodec xan_wc4_decoder = {
"xan_wc4",
CODEC_TYPE_VIDEO,
CODEC_ID_XAN_WC4,
sizeof(XanContext),
xan_decode_init,
NULL,
xan_decode_end,
xan_decode_frame,
CODEC_CAP_DR1,
};
*/ |