falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2496 Commits
32 Branches
375MB
Tree: 6f4915ac83
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6f4915ac83'
${ noResults }
FFmpeg/libavcodec/xan.c

888 lines
25KB
Raw Blame History 

  1. /*

  2.  * Wing Commander/Xan Video Decoder

  3.  * Copyright (C) 2003 the ffmpeg project

  4.  *

  5.  * This library is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU Lesser General Public

  7.  * License as published by the Free Software Foundation; either

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  13.  * Lesser General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU Lesser General Public

  16.  * License along with this library; if not, write to the Free Software

  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  18.  *

  19.  */

  20. 

  21. /**

  22.  * @file xan.c

  23.  * Xan video decoder for Wing Commander III & IV computer games

  24.  * by Mario Brito (mbrito@student.dei.uc.pt)

  25.  * and Mike Melanson (melanson@pcisys.net)

  26.  *

  27.  * The xan_wc3 decoder outputs the following colorspaces natively:

  28.  *   PAL8 (default), RGB555, RGB565, RGB24, BGR24, RGBA32, YUV444P

  29.  */

  30. 

  31. #include <stdio.h>

  32. #include <stdlib.h>

  33. #include <string.h>

  34. #include <unistd.h>

  35. 

  36. #include "common.h"

  37. #include "avcodec.h"

  38. #include "dsputil.h"

  39. 

  40. #define PALETTE_COUNT 256

  41. #define PALETTE_CONTROL_SIZE ((256 * 3) + 1)

  42. 

  43. typedef struct XanContext {

  44. 

  45.     AVCodecContext *avctx;

  46.     DSPContext dsp;

  47.     AVFrame last_frame;

  48.     AVFrame current_frame;

  49. 

  50.     unsigned char *buf;

  51.     int size;

  52. 

  53.     unsigned char palette[PALETTE_COUNT * 4];

  54. 

  55.     /* scratch space */

  56.     unsigned char *buffer1;

  57.     unsigned char *buffer2;

  58. 

  59. } XanContext;

  60. 

  61. #define BE_16(x)  ((((uint8_t*)(x))[0] << 8) | ((uint8_t*)(x))[1])

  62. #define LE_16(x)  ((((uint8_t*)(x))[1] << 8) | ((uint8_t*)(x))[0])

  63. #define LE_32(x)  ((((uint8_t*)(x))[3] << 24) | \

  64.                    (((uint8_t*)(x))[2] << 16) | \

  65.                    (((uint8_t*)(x))[1] << 8) | \

  66.                     ((uint8_t*)(x))[0])

  67. 

  68. /* RGB -> YUV conversion stuff */

  69. #define SCALEFACTOR 65536

  70. #define CENTERSAMPLE 128

  71. 

  72. #define COMPUTE_Y(r, g, b) \

  73.   (unsigned char) \

  74.   ((y_r_table[r] + y_g_table[g] + y_b_table[b]) / SCALEFACTOR)

  75. #define COMPUTE_U(r, g, b) \

  76.   (unsigned char) \

  77.   ((u_r_table[r] + u_g_table[g] + u_b_table[b]) / SCALEFACTOR + CENTERSAMPLE)

  78. #define COMPUTE_V(r, g, b) \

  79.   (unsigned char) \

  80.   ((v_r_table[r] + v_g_table[g] + v_b_table[b]) / SCALEFACTOR + CENTERSAMPLE)

  81. 

  82. #define Y_R (SCALEFACTOR *  0.29900)

  83. #define Y_G (SCALEFACTOR *  0.58700)

  84. #define Y_B (SCALEFACTOR *  0.11400)

  85. 

  86. #define U_R (SCALEFACTOR * -0.16874)

  87. #define U_G (SCALEFACTOR * -0.33126)

  88. #define U_B (SCALEFACTOR *  0.50000)

  89. 

  90. #define V_R (SCALEFACTOR *  0.50000)

  91. #define V_G (SCALEFACTOR * -0.41869)

  92. #define V_B (SCALEFACTOR * -0.08131)

  93. 

  94. /*

  95.  * Precalculate all of the YUV tables since it requires fewer than

  96.  * 10 kilobytes to store them.

  97.  */

  98. static int y_r_table[256];

  99. static int y_g_table[256];

  100. static int y_b_table[256];

  101. 

  102. static int u_r_table[256];

  103. static int u_g_table[256];

  104. static int u_b_table[256];

  105. 

  106. static int v_r_table[256];

  107. static int v_g_table[256];

  108. static int v_b_table[256];

  109. 

  110. static int xan_decode_init(AVCodecContext *avctx)

  111. {

  112.     XanContext *s = avctx->priv_data;

  113.     int i;

  114. 

  115.     s->avctx = avctx;

  116. 

  117.     if ((avctx->codec->id == CODEC_ID_XAN_WC3) && 

  118.         (s->avctx->extradata_size != PALETTE_CONTROL_SIZE)) {

  119.         printf (" WC3 Xan video: expected extradata_size of %d\n",

  120.             PALETTE_CONTROL_SIZE);

  121.         return -1;

  122.     }

  123. 

  124.     avctx->pix_fmt = PIX_FMT_PAL8;

  125.     avctx->has_b_frames = 0;

  126.     dsputil_init(&s->dsp, avctx);

  127. 

  128.     /* initialize the RGB -> YUV tables */

  129.     for (i = 0; i < 256; i++) {

  130.         y_r_table[i] = Y_R * i;

  131.         y_g_table[i] = Y_G * i;

  132.         y_b_table[i] = Y_B * i;

  133. 

  134.         u_r_table[i] = U_R * i;

  135.         u_g_table[i] = U_G * i;

  136.         u_b_table[i] = U_B * i;

  137. 

  138.         v_r_table[i] = V_R * i;

  139.         v_g_table[i] = V_G * i;

  140.         v_b_table[i] = V_B * i;

  141.     }

  142. 

  143.     s->buffer1 = av_malloc(avctx->width * avctx->height);

  144.     s->buffer2 = av_malloc(avctx->width * avctx->height);

  145.     if (!s->buffer1 || !s->buffer2)

  146.         return -1;

  147. 

  148.     return 0;

  149. }

  150. 

  151. /* This function is used in lieu of memcpy(). This decoder can not use 

  152.  * memcpy because the memory locations often overlap and

  153.  * memcpy doesn't like that; it's not uncommon, for example, for

  154.  * dest = src+1, to turn byte A into  pattern AAAAAAAA.

  155.  * This was originally repz movsb in Intel x86 ASM. */

  156. static inline void bytecopy(unsigned char *dest, unsigned char *src, int count)

  157. {

  158.     int i;

  159. 

  160.     for (i = 0; i < count; i++)

  161.         dest[i] = src[i];

  162. }

  163. 

  164. static int xan_huffman_decode(unsigned char *dest, unsigned char *src)

  165. {

  166.     unsigned char byte = *src++;

  167.     unsigned char ival = byte + 0x16;

  168.     unsigned char * ptr = src + byte*2;

  169.     unsigned char val = ival;

  170.     int counter = 0;

  171. 

  172.     unsigned char bits = *ptr++;

  173. 

  174.     while ( val != 0x16 ) {

  175.         if ( (1 << counter) & bits )

  176.             val = src[byte + val - 0x17];

  177.         else

  178.             val = src[val - 0x17];

  179. 

  180.         if ( val < 0x16 ) {

  181.             *dest++ = val;

  182.             val = ival;

  183.         }

  184. 

  185.         if (counter++ == 7) {

  186.             counter = 0;

  187.             bits = *ptr++;

  188.         }

  189.     }

  190. 

  191.     return 0;

  192. }

  193. 

  194. static void xan_unpack(unsigned char *dest, unsigned char *src)

  195. {

  196.     unsigned char opcode;

  197.     int size;

  198.     int offset;

  199.     int byte1, byte2, byte3;

  200. 

  201.     for (;;) {

  202.         opcode = *src++;

  203. 

  204.         if ( (opcode & 0x80) == 0 ) {

  205. 

  206.             offset = *src++;

  207. 

  208.             size = opcode & 3;

  209.             bytecopy(dest, src, size);  dest += size;  src += size;

  210. 

  211.             size = ((opcode & 0x1c) >> 2) + 3;

  212.             bytecopy (dest, dest - (((opcode & 0x60) << 3) + offset + 1), size);

  213.             dest += size;

  214. 

  215.         } else if ( (opcode & 0x40) == 0 ) {

  216. 

  217.             byte1 = *src++;

  218.             byte2 = *src++;

  219. 

  220.             size = byte1 >> 6;

  221.             bytecopy (dest, src, size);  dest += size;  src += size;

  222. 

  223.             size = (opcode & 0x3f) + 4;

  224.             bytecopy (dest, dest - (((byte1 & 0x3f) << 8) + byte2 + 1), size);

  225.             dest += size;

  226. 

  227.         } else if ( (opcode & 0x20) == 0 ) {

  228. 

  229.             byte1 = *src++;

  230.             byte2 = *src++;

  231.             byte3 = *src++;

  232. 

  233.             size = opcode & 3;

  234.             bytecopy (dest, src, size);  dest += size;  src += size;

  235. 

  236.             size = byte3 + 5 + ((opcode & 0xc) << 6);

  237.             bytecopy (dest,

  238.                 dest - ((((opcode & 0x10) >> 4) << 0x10) + 1 + (byte1 << 8) + byte2),

  239.                 size);

  240.             dest += size;

  241.         } else {

  242.             size = ((opcode & 0x1f) << 2) + 4;

  243. 

  244.             if (size > 0x70)

  245.                 break;

  246. 

  247.             bytecopy (dest, src, size);  dest += size;  src += size;

  248.         }

  249.     }

  250. 

  251.     size = opcode & 3;

  252.     bytecopy(dest, src, size);  dest += size;  src += size;

  253. }

  254. 

  255. static void inline xan_wc3_build_palette(XanContext *s, 

  256.     unsigned char *palette_data)

  257. {

  258.     int i;

  259.     unsigned char r, g, b;

  260.     unsigned short *palette16;

  261.     unsigned int *palette32;

  262. 

  263.     /* transform the palette passed through the palette control structure

  264.      * into the necessary internal format depending on colorspace */

  265. 

  266.     switch (s->avctx->pix_fmt) {

  267. 

  268.     case PIX_FMT_PAL8:

  269.         for (i = 0; i < PALETTE_COUNT; i++) {

  270.             r = *palette_data++;

  271.             g = *palette_data++;

  272.             b = *palette_data++;

  273.             s->palette[i * 4 + 0] = b;

  274.             s->palette[i * 4 + 1] = g;

  275.             s->palette[i * 4 + 2] = r;

  276.         }

  277.         break;

  278. 

  279.     case PIX_FMT_RGB555:

  280.         palette16 = (unsigned short *)s->palette;

  281.         for (i = 0; i < PALETTE_COUNT; i++) {

  282.             r = *palette_data++;

  283.             g = *palette_data++;

  284.             b = *palette_data++;

  285.             palette16[i] = 

  286.                 ((r >> 3) << 10) |

  287.                 ((g >> 3) <<  5) |

  288.                 ((g >> 3) <<  0);

  289.         }

  290.         break;

  291. 

  292.     case PIX_FMT_RGB565:

  293.         palette16 = (unsigned short *)s->palette;

  294.         for (i = 0; i < PALETTE_COUNT; i++) {

  295.             r = *palette_data++;

  296.             g = *palette_data++;

  297.             b = *palette_data++;

  298.             palette16[i] = 

  299.                 ((r >> 3) << 11) |

  300.                 ((g >> 2) <<  5) |

  301.                 ((g >> 3) <<  0);

  302.         }

  303.         break;

  304. 

  305.     case PIX_FMT_RGB24:

  306.         for (i = 0; i < PALETTE_COUNT; i++) {

  307.             s->palette[i * 4 + 0] = *palette_data++;

  308.             s->palette[i * 4 + 1] = *palette_data++;

  309.             s->palette[i * 4 + 2] = *palette_data++;

  310.         }

  311.         break;

  312. 

  313.     case PIX_FMT_BGR24:

  314.         for (i = 0; i < PALETTE_COUNT; i++) {

  315.             r = *palette_data++;

  316.             g = *palette_data++;

  317.             b = *palette_data++;

  318.             s->palette[i * 4 + 0] = b;

  319.             s->palette[i * 4 + 1] = g;

  320.             s->palette[i * 4 + 2] = r;

  321.         }

  322.         break;

  323. 

  324.     case PIX_FMT_RGBA32:

  325.         palette32 = (unsigned int *)s->palette;

  326.         for (i = 0; i < PALETTE_COUNT; i++) {

  327.             r = *palette_data++;

  328.             g = *palette_data++;

  329.             b = *palette_data++;

  330.             palette32[i] = (r << 16) | (g << 8) | (b);

  331.         }

  332.         break;

  333. 

  334.     case PIX_FMT_YUV444P:

  335.         for (i = 0; i < PALETTE_COUNT; i++) {

  336.             r = *palette_data++;

  337.             g = *palette_data++;

  338.             b = *palette_data++;

  339.             s->palette[i * 4 + 0] = COMPUTE_Y(r, g, b);

  340.             s->palette[i * 4 + 1] = COMPUTE_U(r, g, b);

  341.             s->palette[i * 4 + 2] = COMPUTE_V(r, g, b);

  342.         }

  343.         break;

  344. 

  345.     default:

  346.         printf (" Xan WC3: Unhandled colorspace\n");

  347.         break;

  348.     }

  349. }

  350. 

  351. static void inline xan_wc3_output_pixel_run(XanContext *s, 

  352.     unsigned char *pixel_buffer, int x, int y, int pixel_count)

  353. {

  354.     int stride;

  355.     int line_inc;

  356.     int index;

  357.     int current_x;

  358.     int width = s->avctx->width;

  359.     unsigned char pixel;

  360.     unsigned char *palette_plane;

  361.     unsigned char *y_plane;

  362.     unsigned char *u_plane;

  363.     unsigned char *v_plane;

  364.     unsigned char *rgb_plane;

  365.     unsigned short *rgb16_plane;

  366.     unsigned short *palette16;

  367.     unsigned int *rgb32_plane;

  368.     unsigned int *palette32;

  369. 

  370.     switch (s->avctx->pix_fmt) {

  371. 

  372.     case PIX_FMT_PAL8:

  373.         palette_plane = s->current_frame.data[0];

  374.         stride = s->current_frame.linesize[0];

  375.         line_inc = stride - width;

  376.         index = y * stride + x;

  377.         current_x = x;

  378.         while(pixel_count--) {

  379. 

  380.             /* don't do a memcpy() here; keyframes generally copy an entire

  381.              * frame of data and the stride needs to be accounted for */

  382.             palette_plane[index++] = *pixel_buffer++;

  383. 

  384.             current_x++;

  385.             if (current_x >= width) {

  386.                 /* reset accounting variables */

  387.                 index += line_inc;

  388.                 current_x = 0;

  389.             }

  390.         }

  391.         break;

  392. 

  393.     case PIX_FMT_RGB555:

  394.     case PIX_FMT_RGB565:

  395.         rgb16_plane = (unsigned short *)s->current_frame.data[0];

  396.         palette16 = (unsigned short *)s->palette;

  397.         stride = s->current_frame.linesize[0] / 2;

  398.         line_inc = stride - width;

  399.         index = y * stride + x;

  400.         current_x = x;

  401.         while(pixel_count--) {

  402. 

  403.             rgb16_plane[index++] = palette16[*pixel_buffer++];

  404. 

  405.             current_x++;

  406.             if (current_x >= width) {

  407.                 /* reset accounting variables */

  408.                 index += line_inc;

  409.                 current_x = 0;

  410.             }

  411.         }

  412.         break;

  413. 

  414.     case PIX_FMT_RGB24:

  415.     case PIX_FMT_BGR24:

  416.         rgb_plane = s->current_frame.data[0];

  417.         stride = s->current_frame.linesize[0];

  418.         line_inc = stride - width * 3;

  419.         index = y * stride + x * 3;

  420.         current_x = x;

  421.         while(pixel_count--) {

  422.             pixel = *pixel_buffer++;

  423. 

  424.             rgb_plane[index++] = s->palette[pixel * 4 + 0];

  425.             rgb_plane[index++] = s->palette[pixel * 4 + 1];

  426.             rgb_plane[index++] = s->palette[pixel * 4 + 2];

  427. 

  428.             current_x++;

  429.             if (current_x >= width) {

  430.                 /* reset accounting variables */

  431.                 index += line_inc;

  432.                 current_x = 0;

  433.             }

  434.         }

  435.         break;

  436. 

  437.     case PIX_FMT_RGBA32:

  438.         rgb32_plane = (unsigned int *)s->current_frame.data[0];

  439.         palette32 = (unsigned int *)s->palette;

  440.         stride = s->current_frame.linesize[0] / 4;

  441.         line_inc = stride - width;

  442.         index = y * stride + x;

  443.         current_x = x;

  444.         while(pixel_count--) {

  445. 

  446.             rgb32_plane[index++] = palette32[*pixel_buffer++];

  447. 

  448.             current_x++;

  449.             if (current_x >= width) {

  450.                 /* reset accounting variables */

  451.                 index += line_inc;

  452.                 current_x = 0;

  453.             }

  454.         }

  455.         break;

  456. 

  457.     case PIX_FMT_YUV444P:

  458.         y_plane = s->current_frame.data[0];

  459.         u_plane = s->current_frame.data[1];

  460.         v_plane = s->current_frame.data[2];

  461.         stride = s->current_frame.linesize[0];

  462.         line_inc = stride - width;

  463.         index = y * stride + x;

  464.         current_x = x;

  465.         while(pixel_count--) {

  466.             pixel = *pixel_buffer++;

  467. 

  468.             y_plane[index] = s->palette[pixel * 4 + 0];

  469.             u_plane[index] = s->palette[pixel * 4 + 1];

  470.             v_plane[index] = s->palette[pixel * 4 + 2];

  471. 

  472.             index++;

  473.             current_x++;

  474.             if (current_x >= width) {

  475.                 /* reset accounting variables */

  476.                 index += line_inc;

  477.                 current_x = 0;

  478.             }

  479.         }

  480.         break;

  481. 

  482.     default:

  483.         printf (" Xan WC3: Unhandled colorspace\n");

  484.         break;

  485.     }

  486. }

  487. 

  488. static void inline xan_wc3_copy_pixel_run(XanContext *s, 

  489.     int x, int y, int pixel_count, int motion_x, int motion_y)

  490. {

  491.     int stride;

  492.     int line_inc;

  493.     int curframe_index, prevframe_index;

  494.     int curframe_x, prevframe_x;

  495.     int width = s->avctx->width;

  496.     unsigned char *palette_plane, *prev_palette_plane;

  497.     unsigned char *y_plane, *u_plane, *v_plane;

  498.     unsigned char *prev_y_plane, *prev_u_plane, *prev_v_plane;

  499.     unsigned char *rgb_plane, *prev_rgb_plane;

  500.     unsigned short *rgb16_plane, *prev_rgb16_plane;

  501.     unsigned int *rgb32_plane, *prev_rgb32_plane;

  502. 

  503.     switch (s->avctx->pix_fmt) {

  504. 

  505.     case PIX_FMT_PAL8:

  506.         palette_plane = s->current_frame.data[0];

  507.         prev_palette_plane = s->last_frame.data[0];

  508.         stride = s->current_frame.linesize[0];

  509.         line_inc = stride - width;

  510.         curframe_index = y * stride + x;

  511.         curframe_x = x;

  512.         prevframe_index = (y + motion_y) * stride + x + motion_x;

  513.         prevframe_x = x + motion_x;

  514.         while(pixel_count--) {

  515. 

  516.             palette_plane[curframe_index++] = 

  517.                 prev_palette_plane[prevframe_index++];

  518. 

  519.             curframe_x++;

  520.             if (curframe_x >= width) {

  521.                 /* reset accounting variables */

  522.                 curframe_index += line_inc;

  523.                 curframe_x = 0;

  524.             }

  525. 

  526.             prevframe_x++;

  527.             if (prevframe_x >= width) {

  528.                 /* reset accounting variables */

  529.                 prevframe_index += line_inc;

  530.                 prevframe_x = 0;

  531.             }

  532.         }

  533.         break;

  534. 

  535.     case PIX_FMT_RGB555:

  536.     case PIX_FMT_RGB565:

  537.         rgb16_plane = (unsigned short *)s->current_frame.data[0];

  538.         prev_rgb16_plane = (unsigned short *)s->last_frame.data[0];

  539.         stride = s->current_frame.linesize[0] / 2;

  540.         line_inc = stride - width;

  541.         curframe_index = y * stride + x;

  542.         curframe_x = x;

  543.         prevframe_index = (y + motion_y) * stride + x + motion_x;

  544.         prevframe_x = x + motion_x;

  545.         while(pixel_count--) {

  546. 

  547.             rgb16_plane[curframe_index++] = 

  548.                 prev_rgb16_plane[prevframe_index++];

  549. 

  550.             curframe_x++;

  551.             if (curframe_x >= width) {

  552.                 /* reset accounting variables */

  553.                 curframe_index += line_inc;

  554.                 curframe_x = 0;

  555.             }

  556. 

  557.             prevframe_x++;

  558.             if (prevframe_x >= width) {

  559.                 /* reset accounting variables */

  560.                 prevframe_index += line_inc;

  561.                 prevframe_x = 0;

  562.             }

  563.         }

  564.         break;

  565. 

  566.     case PIX_FMT_RGB24:

  567.     case PIX_FMT_BGR24:

  568.         rgb_plane = s->current_frame.data[0];

  569.         prev_rgb_plane = s->last_frame.data[0];

  570.         stride = s->current_frame.linesize[0];

  571.         line_inc = stride - width * 3;

  572.         curframe_index = y * stride + x * 3;

  573.         curframe_x = x;

  574.         prevframe_index = (y + motion_y) * stride + 

  575.             (3 * (x + motion_x));

  576.         prevframe_x = x + motion_x;

  577.         while(pixel_count--) {

  578. 

  579.             rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++];

  580.             rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++];

  581.             rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++];

  582. 

  583.             curframe_x++;

  584.             if (curframe_x >= width) {

  585.                 /* reset accounting variables */

  586.                 curframe_index += line_inc;

  587.                 curframe_x = 0;

  588.             }

  589. 

  590.             prevframe_x++;

  591.             if (prevframe_x >= width) {

  592.                 /* reset accounting variables */

  593.                 prevframe_index += line_inc;

  594.                 prevframe_x = 0;

  595.             }

  596.         }

  597.         break;

  598. 

  599.     case PIX_FMT_RGBA32:

  600.         rgb32_plane = (unsigned int *)s->current_frame.data[0];

  601.         prev_rgb32_plane = (unsigned int *)s->last_frame.data[0];

  602.         stride = s->current_frame.linesize[0] / 4;

  603.         line_inc = stride - width;

  604.         curframe_index = y * stride + x;

  605.         curframe_x = x;

  606.         prevframe_index = (y + motion_y) * stride + x + motion_x;

  607.         prevframe_x = x + motion_x;

  608.         while(pixel_count--) {

  609. 

  610.             rgb32_plane[curframe_index++] = 

  611.                 prev_rgb32_plane[prevframe_index++];

  612. 

  613.             curframe_x++;

  614.             if (curframe_x >= width) {

  615.                 /* reset accounting variables */

  616.                 curframe_index += line_inc;

  617.                 curframe_x = 0;

  618.             }

  619. 

  620.             prevframe_x++;

  621.             if (prevframe_x >= width) {

  622.                 /* reset accounting variables */

  623.                 prevframe_index += line_inc;

  624.                 prevframe_x = 0;

  625.             }

  626.         }

  627.         break;

  628. 

  629.     case PIX_FMT_YUV444P:

  630.         y_plane = s->current_frame.data[0];

  631.         u_plane = s->current_frame.data[1];

  632.         v_plane = s->current_frame.data[2];

  633.         prev_y_plane = s->last_frame.data[0];

  634.         prev_u_plane = s->last_frame.data[1];

  635.         prev_v_plane = s->last_frame.data[2];

  636.         stride = s->current_frame.linesize[0];

  637.         line_inc = stride - width;

  638.         curframe_index = y * stride + x;

  639.         curframe_x = x;

  640.         prevframe_index = (y + motion_y) * stride + x + motion_x;

  641.         prevframe_x = x + motion_x;

  642.         while(pixel_count--) {

  643. 

  644.             y_plane[curframe_index] = prev_y_plane[prevframe_index];

  645.             u_plane[curframe_index] = prev_u_plane[prevframe_index];

  646.             v_plane[curframe_index] = prev_v_plane[prevframe_index];

  647. 

  648.             curframe_index++;

  649.             curframe_x++;

  650.             if (curframe_x >= width) {

  651.                 /* reset accounting variables */

  652.                 curframe_index += line_inc;

  653.                 curframe_x = 0;

  654.             }

  655. 

  656.             prevframe_index++;

  657.             prevframe_x++;

  658.             if (prevframe_x >= width) {

  659.                 /* reset accounting variables */

  660.                 prevframe_index += line_inc;

  661.                 prevframe_x = 0;

  662.             }

  663.         }

  664.         break;

  665. 

  666.     default:

  667.         printf (" Xan WC3: Unhandled colorspace\n");

  668.         break;

  669.     }

  670. }

  671. 

  672. static void xan_wc3_decode_frame(XanContext *s) {

  673. 

  674.     int width = s->avctx->width;

  675.     int height = s->avctx->height;

  676.     int total_pixels = width * height;

  677.     unsigned char opcode;

  678.     unsigned char flag = 0;

  679.     int size = 0;

  680.     int motion_x, motion_y;

  681.     int x, y;

  682. 

  683.     unsigned char *opcode_buffer = s->buffer1;

  684.     unsigned char *imagedata_buffer = s->buffer2;

  685. 

  686.     /* pointers to segments inside the compressed chunk */

  687.     unsigned char *huffman_segment;

  688.     unsigned char *size_segment;

  689.     unsigned char *vector_segment;

  690.     unsigned char *imagedata_segment;

  691. 

  692.     huffman_segment =   s->buf + LE_16(&s->buf[0]);

  693.     size_segment =      s->buf + LE_16(&s->buf[2]);

  694.     vector_segment =    s->buf + LE_16(&s->buf[4]);

  695.     imagedata_segment = s->buf + LE_16(&s->buf[6]);

  696. 

  697.     xan_huffman_decode(opcode_buffer, huffman_segment);

  698. 

  699.     if (imagedata_segment[0] == 2)

  700.         xan_unpack(imagedata_buffer, &imagedata_segment[1]);

  701.     else

  702.         imagedata_buffer = &imagedata_segment[1];

  703. 

  704.     /* use the decoded data segments to build the frame */

  705.     x = y = 0;

  706.     while (total_pixels) {

  707. 

  708.         opcode = *opcode_buffer++;

  709.         size = 0;

  710. 

  711.         switch (opcode) {

  712. 

  713.         case 0:

  714.             flag ^= 1;

  715.             continue;

  716. 

  717.         case 1:

  718.         case 2:

  719.         case 3:

  720.         case 4:

  721.         case 5:

  722.         case 6:

  723.         case 7:

  724.         case 8:

  725.             size = opcode;

  726.             break;

  727. 

  728.         case 12:

  729.         case 13:

  730.         case 14:

  731.         case 15:

  732.         case 16:

  733.         case 17:

  734.         case 18:

  735.             size += (opcode - 10);

  736.             break;

  737. 

  738.         case 9:

  739.         case 19:

  740.             size = *size_segment++;

  741.             break;

  742. 

  743.         case 10:

  744.         case 20:

  745.             size = BE_16(&size_segment[0]);

  746.             size_segment += 2;

  747.             break;

  748. 

  749.         case 11:

  750.         case 21:

  751.             size = (size_segment[0] << 16) | (size_segment[1] << 8) |

  752.                 size_segment[2];

  753.             size_segment += 3;

  754.             break;

  755.         }

  756. 

  757.         if (opcode < 12) {

  758.             flag ^= 1;

  759.             if (flag) {

  760.                 /* run of (size) pixels is unchanged from last frame */

  761.                 xan_wc3_copy_pixel_run(s, x, y, size, 0, 0);

  762.             } else {

  763.                 /* output a run of pixels from imagedata_buffer */

  764.                 xan_wc3_output_pixel_run(s, imagedata_buffer, x, y, size);

  765.                 imagedata_buffer += size;

  766.             }

  767.         } else {

  768.             /* run-based motion compensation from last frame */

  769.             motion_x = (*vector_segment >> 4) & 0xF;

  770.             motion_y = *vector_segment & 0xF;

  771.             vector_segment++;

  772. 

  773.             /* sign extension */

  774.             if (motion_x & 0x8)

  775.                 motion_x |= 0xFFFFFFF0;

  776.             if (motion_y & 0x8)

  777.                 motion_y |= 0xFFFFFFF0;

  778. 

  779.             /* copy a run of pixels from the previous frame */

  780.             xan_wc3_copy_pixel_run(s, x, y, size, motion_x, motion_y);

  781. 

  782.             flag = 0;

  783.         }

  784. 

  785.         /* coordinate accounting */

  786.         total_pixels -= size;

  787.         while (size) {

  788.             if (x + size >= width) {

  789.                 y++;

  790.                 size -= (width - x);

  791.                 x = 0;

  792.             } else {

  793.                 x += size;

  794.                 size = 0;

  795.             }

  796.         }

  797.     }

  798. 

  799.     /* for PAL8, make the palette available on the way out */

  800.     if (s->avctx->pix_fmt == PIX_FMT_PAL8)

  801.         memcpy(s->current_frame.data[1], s->palette, PALETTE_COUNT * 4);

  802. }

  803. 

  804. static void xan_wc4_decode_frame(XanContext *s) {

  805. }

  806. 

  807. static int xan_decode_frame(AVCodecContext *avctx,

  808.                             void *data, int *data_size,

  809.                             uint8_t *buf, int buf_size)

  810. {

  811.     XanContext *s = avctx->priv_data;

  812.     unsigned char *palette_control = avctx->extradata;

  813.     int keyframe = 0;

  814. 

  815.     if (palette_control[0]) {

  816.         /* load the new palette and reset the palette control */

  817.         xan_wc3_build_palette(s, &palette_control[1]);

  818.         palette_control[0] = 0;

  819.         keyframe = 1;

  820.     }

  821. 

  822.     if (avctx->get_buffer(avctx, &s->current_frame)) {

  823.         printf ("  Interplay Video: get_buffer() failed\n");

  824.         return -1;

  825.     }

  826.     s->current_frame.reference = 3;

  827. 

  828.     s->buf = buf;

  829.     s->size = buf_size;

  830. 

  831.     if (avctx->codec->id == CODEC_ID_XAN_WC3)

  832.         xan_wc3_decode_frame(s);

  833.     else if (avctx->codec->id == CODEC_ID_XAN_WC4)

  834.         xan_wc4_decode_frame(s);

  835. 

  836.     /* release the last frame if it is allocated */

  837.     if (s->last_frame.data[0])

  838.         avctx->release_buffer(avctx, &s->last_frame);

  839. 

  840.     /* shuffle frames */

  841.     s->last_frame = s->current_frame;

  842. 

  843.     *data_size = sizeof(AVFrame);

  844.     *(AVFrame*)data = s->current_frame;

  845. 

  846.     /* always report that the buffer was completely consumed */

  847.     return buf_size;

  848. }

  849. 

  850. static int xan_decode_end(AVCodecContext *avctx)

  851. {

  852.     XanContext *s = avctx->priv_data;

  853. 

  854.     /* release the last frame */

  855.     avctx->release_buffer(avctx, &s->last_frame);

  856. 

  857.     av_free(s->buffer1);

  858.     av_free(s->buffer2);

  859. 

  860.     return 0;

  861. }

  862. 

  863. AVCodec xan_wc3_decoder = {

  864.     "xan_wc3",

  865.     CODEC_TYPE_VIDEO,

  866.     CODEC_ID_XAN_WC3,

  867.     sizeof(XanContext),

  868.     xan_decode_init,

  869.     NULL,

  870.     xan_decode_end,

  871.     xan_decode_frame,

  872.     CODEC_CAP_DR1,

  873. };

  874. 

  875. /*

  876. AVCodec xan_wc4_decoder = {

  877.     "xan_wc4",

  878.     CODEC_TYPE_VIDEO,

  879.     CODEC_ID_XAN_WC4,

  880.     sizeof(XanContext),

  881.     xan_decode_init,

  882.     NULL,

  883.     xan_decode_end,

  884.     xan_decode_frame,

  885.     CODEC_CAP_DR1,

  886. };

  887. */