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.
4744 Commits
32 Branches
1.1GB
Tree: 1b51e051c0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1b51e051c0'
${ noResults }
FFmpeg/libavcodec/xan.c

825 lines
23KB
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. /* 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)

  86. 

  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];

  102. 

  103. static int xan_decode_init(AVCodecContext *avctx)

  104. {

  105.     XanContext *s = avctx->priv_data;

  106.     int i;

  107. 

  108.     s->avctx = avctx;

  109. 

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

  111.         (s->avctx->palctrl == NULL)) {

  112.         av_log(avctx, AV_LOG_ERROR, " WC3 Xan video: palette expected.\n");

  113.         return -1;

  114.     }

  115. 

  116.     avctx->pix_fmt = PIX_FMT_PAL8;

  117.     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.     }

  134. 

  135.     if(avcodec_check_dimensions(avctx, avctx->width, avctx->height))

  136.         return -1;

  137.     

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

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

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

  141.         return -1;

  142. 

  143.     return 0;

  144. }

  145. 

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

  147.  * memcpy because the memory locations often overlap and

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

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

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

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

  152. {

  153.     int i;

  154. 

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

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

  157. }

  158. 

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

  160. {

  161.     unsigned char byte = *src++;

  162.     unsigned char ival = byte + 0x16;

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

  164.     unsigned char val = ival;

  165.     int counter = 0;

  166. 

  167.     unsigned char bits = *ptr++;

  168. 

  169.     while ( val != 0x16 ) {

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

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

  172.         else

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

  174. 

  175.         if ( val < 0x16 ) {

  176.             *dest++ = val;

  177.             val = ival;

  178.         }

  179. 

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

  181.             counter = 0;

  182.             bits = *ptr++;

  183.         }

  184.     }

  185. 

  186.     return 0;

  187. }

  188. 

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

  190. {

  191.     unsigned char opcode;

  192.     int size;

  193.     int offset;

  194.     int byte1, byte2, byte3;

  195. 

  196.     for (;;) {

  197.         opcode = *src++;

  198. 

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

  200. 

  201.             offset = *src++;

  202. 

  203.             size = opcode & 3;

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

  205. 

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

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

  208.             dest += size;

  209. 

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

  211. 

  212.             byte1 = *src++;

  213.             byte2 = *src++;

  214. 

  215.             size = byte1 >> 6;

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

  217. 

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

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

  220.             dest += size;

  221. 

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

  223. 

  224.             byte1 = *src++;

  225.             byte2 = *src++;

  226.             byte3 = *src++;

  227. 

  228.             size = opcode & 3;

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

  230. 

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

  232.             bytecopy (dest,

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

  234.                 size);

  235.             dest += size;

  236.         } else {

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

  238. 

  239.             if (size > 0x70)

  240.                 break;

  241. 

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

  243.         }

  244.     }

  245. 

  246.     size = opcode & 3;

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

  248. }

  249. 

  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. 

  349. static void inline xan_wc3_output_pixel_run(XanContext *s, 

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

  351. {

  352.     int stride;

  353.     int line_inc;

  354.     int index;

  355.     int current_x;

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

  357.     unsigned char pix;

  358.     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--) {

  395. 

  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();

  417.         }

  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;

  458.     }

  459. }

  460. 

  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. 

  475. static void inline xan_wc3_copy_pixel_run(XanContext *s, 

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

  477. {

  478.     int stride;

  479.     int line_inc;

  480.     int curframe_index, prevframe_index;

  481.     int curframe_x, prevframe_x;

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

  483.     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();

  595.         }

  596.         break;

  597. 

  598.     default:

  599.         av_log(s->avctx, AV_LOG_ERROR, " Xan WC3: Unhandled colorspace\n");

  600.         break;

  601.     }

  602. }

  603. 

  604. static void xan_wc3_decode_frame(XanContext *s) {

  605. 

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

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

  608.     int total_pixels = width * height;

  609.     unsigned char opcode;

  610.     unsigned char flag = 0;

  611.     int size = 0;

  612.     int motion_x, motion_y;

  613.     int x, y;

  614. 

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

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

  617. 

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

  619.     unsigned char *huffman_segment;

  620.     unsigned char *size_segment;

  621.     unsigned char *vector_segment;

  622.     unsigned char *imagedata_segment;

  623. 

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

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

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

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

  628. 

  629.     xan_huffman_decode(opcode_buffer, huffman_segment);

  630. 

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

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

  633.     else

  634.         imagedata_buffer = &imagedata_segment[1];

  635. 

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

  637.     x = y = 0;

  638.     while (total_pixels) {

  639. 

  640.         opcode = *opcode_buffer++;

  641.         size = 0;

  642. 

  643.         switch (opcode) {

  644. 

  645.         case 0:

  646.             flag ^= 1;

  647.             continue;

  648. 

  649.         case 1:

  650.         case 2:

  651.         case 3:

  652.         case 4:

  653.         case 5:

  654.         case 6:

  655.         case 7:

  656.         case 8:

  657.             size = opcode;

  658.             break;

  659. 

  660.         case 12:

  661.         case 13:

  662.         case 14:

  663.         case 15:

  664.         case 16:

  665.         case 17:

  666.         case 18:

  667.             size += (opcode - 10);

  668.             break;

  669. 

  670.         case 9:

  671.         case 19:

  672.             size = *size_segment++;

  673.             break;

  674. 

  675.         case 10:

  676.         case 20:

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

  678.             size_segment += 2;

  679.             break;

  680. 

  681.         case 11:

  682.         case 21:

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

  684.                 size_segment[2];

  685.             size_segment += 3;

  686.             break;

  687.         }

  688. 

  689.         if (opcode < 12) {

  690.             flag ^= 1;

  691.             if (flag) {

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

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

  694.             } else {

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

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

  697.                 imagedata_buffer += size;

  698.             }

  699.         } else {

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

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

  702.             motion_y = *vector_segment & 0xF;

  703.             vector_segment++;

  704. 

  705.             /* sign extension */

  706.             if (motion_x & 0x8)

  707.                 motion_x |= 0xFFFFFFF0;

  708.             if (motion_y & 0x8)

  709.                 motion_y |= 0xFFFFFFF0;

  710. 

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

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

  713. 

  714.             flag = 0;

  715.         }

  716. 

  717.         /* coordinate accounting */

  718.         total_pixels -= size;

  719.         while (size) {

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

  721.                 y++;

  722.                 size -= (width - x);

  723.                 x = 0;

  724.             } else {

  725.                 x += size;

  726.                 size = 0;

  727.             }

  728.         }

  729.     }

  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.     }

  737. }

  738. 

  739. static void xan_wc4_decode_frame(XanContext *s) {

  740. }

  741. 

  742. static int xan_decode_frame(AVCodecContext *avctx,

  743.                             void *data, int *data_size,

  744.                             uint8_t *buf, int buf_size)

  745. {

  746.     XanContext *s = avctx->priv_data;

  747.     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.     }

  758. 

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

  760.         av_log(s->avctx, AV_LOG_ERROR, "  Xan Video: get_buffer() failed\n");

  761.         return -1;

  762.     }

  763.     s->current_frame.reference = 3;

  764. 

  765.     s->buf = buf;

  766.     s->size = buf_size;

  767. 

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

  769.         xan_wc3_decode_frame(s);

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

  771.         xan_wc4_decode_frame(s);

  772. 

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

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

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

  776. 

  777.     /* shuffle frames */

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

  779. 

  780.     *data_size = sizeof(AVFrame);

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

  782. 

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

  784.     return buf_size;

  785. }

  786. 

  787. static int xan_decode_end(AVCodecContext *avctx)

  788. {

  789.     XanContext *s = avctx->priv_data;

  790. 

  791.     /* release the last frame */

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

  793. 

  794.     av_free(s->buffer1);

  795.     av_free(s->buffer2);

  796. 

  797.     return 0;

  798. }

  799. 

  800. AVCodec xan_wc3_decoder = {

  801.     "xan_wc3",

  802.     CODEC_TYPE_VIDEO,

  803.     CODEC_ID_XAN_WC3,

  804.     sizeof(XanContext),

  805.     xan_decode_init,

  806.     NULL,

  807.     xan_decode_end,

  808.     xan_decode_frame,

  809.     CODEC_CAP_DR1,

  810. };

  811. 

  812. /*

  813. AVCodec xan_wc4_decoder = {

  814.     "xan_wc4",

  815.     CODEC_TYPE_VIDEO,

  816.     CODEC_ID_XAN_WC4,

  817.     sizeof(XanContext),

  818.     xan_decode_init,

  819.     NULL,

  820.     xan_decode_end,

  821.     xan_decode_frame,

  822.     CODEC_CAP_DR1,

  823. };

  824. */