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.
3135 Commits
32 Branches
698MB
Tree: 68951ecf0c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '68951ecf0c'
${ noResults }
FFmpeg/libavcodec/xan.c

829 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. #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->palctrl == NULL)) {

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

  120.         return -1;

  121.     }

  122. 

  123.     avctx->pix_fmt = PIX_FMT_PAL8;

  124.     avctx->has_b_frames = 0;

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

  126. 

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

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

  129.         y_r_table[i] = Y_R * i;

  130.         y_g_table[i] = Y_G * i;

  131.         y_b_table[i] = Y_B * i;

  132. 

  133.         u_r_table[i] = U_R * i;

  134.         u_g_table[i] = U_G * i;

  135.         u_b_table[i] = U_B * i;

  136. 

  137.         v_r_table[i] = V_R * i;

  138.         v_g_table[i] = V_G * i;

  139.         v_b_table[i] = V_B * i;

  140.     }

  141. 

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

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

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

  145.         return -1;

  146. 

  147.     return 0;

  148. }

  149. 

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

  151.  * memcpy because the memory locations often overlap and

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

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

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

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

  156. {

  157.     int i;

  158. 

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

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

  161. }

  162. 

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

  164. {

  165.     unsigned char byte = *src++;

  166.     unsigned char ival = byte + 0x16;

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

  168.     unsigned char val = ival;

  169.     int counter = 0;

  170. 

  171.     unsigned char bits = *ptr++;

  172. 

  173.     while ( val != 0x16 ) {

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

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

  176.         else

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

  178. 

  179.         if ( val < 0x16 ) {

  180.             *dest++ = val;

  181.             val = ival;

  182.         }

  183. 

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

  185.             counter = 0;

  186.             bits = *ptr++;

  187.         }

  188.     }

  189. 

  190.     return 0;

  191. }

  192. 

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

  194. {

  195.     unsigned char opcode;

  196.     int size;

  197.     int offset;

  198.     int byte1, byte2, byte3;

  199. 

  200.     for (;;) {

  201.         opcode = *src++;

  202. 

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

  204. 

  205.             offset = *src++;

  206. 

  207.             size = opcode & 3;

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

  209. 

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

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

  212.             dest += size;

  213. 

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

  215. 

  216.             byte1 = *src++;

  217.             byte2 = *src++;

  218. 

  219.             size = byte1 >> 6;

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

  221. 

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

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

  224.             dest += size;

  225. 

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

  227. 

  228.             byte1 = *src++;

  229.             byte2 = *src++;

  230.             byte3 = *src++;

  231. 

  232.             size = opcode & 3;

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

  234. 

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

  236.             bytecopy (dest,

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

  238.                 size);

  239.             dest += size;

  240.         } else {

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

  242. 

  243.             if (size > 0x70)

  244.                 break;

  245. 

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

  247.         }

  248.     }

  249. 

  250.     size = opcode & 3;

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

  252. }

  253. 

  254. static void inline xan_wc3_build_palette(XanContext *s, 

  255.     unsigned int *palette_data)

  256. {

  257.     int i;

  258.     unsigned char r, g, b;

  259.     unsigned short *palette16;

  260.     unsigned int *palette32;

  261.     unsigned int pal_elem;

  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_RGB555:

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

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

  271.             pal_elem = palette_data[i];

  272.             r = (pal_elem >> 16) & 0xff;

  273.             g = (pal_elem >> 8) & 0xff;

  274.             b = pal_elem & 0xff;

  275.             palette16[i] = 

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

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

  278.                 ((b >> 3) <<  0);

  279.         }

  280.         break;

  281. 

  282.     case PIX_FMT_RGB565:

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

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

  285.             pal_elem = palette_data[i];

  286.             r = (pal_elem >> 16) & 0xff;

  287.             g = (pal_elem >> 8) & 0xff;

  288.             b = pal_elem & 0xff;

  289.             palette16[i] = 

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

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

  292.                 ((b >> 3) <<  0);

  293.         }

  294.         break;

  295. 

  296.     case PIX_FMT_RGB24:

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

  298.             pal_elem = palette_data[i];

  299.             r = (pal_elem >> 16) & 0xff;

  300.             g = (pal_elem >> 8) & 0xff;

  301.             b = pal_elem & 0xff;

  302.             s->palette[i * 4 + 0] = r;

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

  304.             s->palette[i * 4 + 2] = b;

  305.         }

  306.         break;

  307. 

  308.     case PIX_FMT_BGR24:

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

  310.             pal_elem = palette_data[i];

  311.             r = (pal_elem >> 16) & 0xff;

  312.             g = (pal_elem >> 8) & 0xff;

  313.             b = pal_elem & 0xff;

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

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

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

  317.         }

  318.         break;

  319. 

  320.     case PIX_FMT_PAL8:

  321.     case PIX_FMT_RGBA32:

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

  323.         memcpy (palette32, palette_data, PALETTE_COUNT * sizeof(unsigned int));

  324.         break;

  325. 

  326.     case PIX_FMT_YUV444P:

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

  328.             pal_elem = palette_data[i];

  329.             r = (pal_elem >> 16) & 0xff;

  330.             g = (pal_elem >> 8) & 0xff;

  331.             b = pal_elem & 0xff;

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

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

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

  335.         }

  336.         break;

  337. 

  338.     default:

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

  340.         break;

  341.     }

  342. }

  343. 

  344. /* advance current_x variable; reset accounting variables if current_x

  345.  * moves beyond width */

  346. #define ADVANCE_CURRENT_X() \

  347.     current_x++; \

  348.     if (current_x >= width) { \

  349.         index += line_inc; \

  350.         current_x = 0; \

  351.     }

  352. 

  353. static void inline xan_wc3_output_pixel_run(XanContext *s, 

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

  355. {

  356.     int stride;

  357.     int line_inc;

  358.     int index;

  359.     int current_x;

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

  361.     unsigned char pix;

  362.     unsigned char *palette_plane;

  363.     unsigned char *y_plane;

  364.     unsigned char *u_plane;

  365.     unsigned char *v_plane;

  366.     unsigned char *rgb_plane;

  367.     unsigned short *rgb16_plane;

  368.     unsigned short *palette16;

  369.     unsigned int *rgb32_plane;

  370.     unsigned int *palette32;

  371. 

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

  373. 

  374.     case PIX_FMT_PAL8:

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

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

  377.         line_inc = stride - width;

  378.         index = y * stride + x;

  379.         current_x = x;

  380.         while(pixel_count--) {

  381. 

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

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

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

  385. 

  386.             ADVANCE_CURRENT_X();

  387.         }

  388.         break;

  389. 

  390.     case PIX_FMT_RGB555:

  391.     case PIX_FMT_RGB565:

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

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

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

  395.         line_inc = stride - width;

  396.         index = y * stride + x;

  397.         current_x = x;

  398.         while(pixel_count--) {

  399. 

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

  401. 

  402.             ADVANCE_CURRENT_X();

  403.         }

  404.         break;

  405. 

  406.     case PIX_FMT_RGB24:

  407.     case PIX_FMT_BGR24:

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

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

  410.         line_inc = stride - width * 3;

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

  412.         current_x = x;

  413.         while(pixel_count--) {

  414.             pix = *pixel_buffer++;

  415. 

  416.             rgb_plane[index++] = s->palette[pix * 4 + 0];

  417.             rgb_plane[index++] = s->palette[pix * 4 + 1];

  418.             rgb_plane[index++] = s->palette[pix * 4 + 2];

  419. 

  420.             ADVANCE_CURRENT_X();

  421.         }

  422.         break;

  423. 

  424.     case PIX_FMT_RGBA32:

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

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

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

  428.         line_inc = stride - width;

  429.         index = y * stride + x;

  430.         current_x = x;

  431.         while(pixel_count--) {

  432. 

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

  434. 

  435.             ADVANCE_CURRENT_X();

  436.         }

  437.         break;

  438. 

  439.     case PIX_FMT_YUV444P:

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

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

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

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

  444.         line_inc = stride - width;

  445.         index = y * stride + x;

  446.         current_x = x;

  447.         while(pixel_count--) {

  448.             pix = *pixel_buffer++;

  449. 

  450.             y_plane[index] = s->palette[pix * 4 + 0];

  451.             u_plane[index] = s->palette[pix * 4 + 1];

  452.             v_plane[index] = s->palette[pix * 4 + 2];

  453. 

  454.             index++;

  455.             ADVANCE_CURRENT_X();

  456.         }

  457.         break;

  458. 

  459.     default:

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

  461.         break;

  462.     }

  463. }

  464. 

  465. #define ADVANCE_CURFRAME_X() \

  466.     curframe_x++; \

  467.     if (curframe_x >= width) { \

  468.         curframe_index += line_inc; \

  469.         curframe_x = 0; \

  470.     }

  471. 

  472. #define ADVANCE_PREVFRAME_X() \

  473.     prevframe_x++; \

  474.     if (prevframe_x >= width) { \

  475.         prevframe_index += line_inc; \

  476.         prevframe_x = 0; \

  477.     }

  478. 

  479. static void inline xan_wc3_copy_pixel_run(XanContext *s, 

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

  481. {

  482.     int stride;

  483.     int line_inc;

  484.     int curframe_index, prevframe_index;

  485.     int curframe_x, prevframe_x;

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

  487.     unsigned char *palette_plane, *prev_palette_plane;

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

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

  490.     unsigned char *rgb_plane, *prev_rgb_plane;

  491.     unsigned short *rgb16_plane, *prev_rgb16_plane;

  492.     unsigned int *rgb32_plane, *prev_rgb32_plane;

  493. 

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

  495. 

  496.     case PIX_FMT_PAL8:

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

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

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

  500.         line_inc = stride - width;

  501.         curframe_index = y * stride + x;

  502.         curframe_x = x;

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

  504.         prevframe_x = x + motion_x;

  505.         while(pixel_count--) {

  506. 

  507.             palette_plane[curframe_index++] = 

  508.                 prev_palette_plane[prevframe_index++];

  509. 

  510.             ADVANCE_CURFRAME_X();

  511.             ADVANCE_PREVFRAME_X();

  512.         }

  513.         break;

  514. 

  515.     case PIX_FMT_RGB555:

  516.     case PIX_FMT_RGB565:

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

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

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

  520.         line_inc = stride - width;

  521.         curframe_index = y * stride + x;

  522.         curframe_x = x;

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

  524.         prevframe_x = x + motion_x;

  525.         while(pixel_count--) {

  526. 

  527.             rgb16_plane[curframe_index++] = 

  528.                 prev_rgb16_plane[prevframe_index++];

  529. 

  530.             ADVANCE_CURFRAME_X();

  531.             ADVANCE_PREVFRAME_X();

  532.         }

  533.         break;

  534. 

  535.     case PIX_FMT_RGB24:

  536.     case PIX_FMT_BGR24:

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

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

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

  540.         line_inc = stride - width * 3;

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

  542.         curframe_x = x;

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

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

  545.         prevframe_x = x + motion_x;

  546.         while(pixel_count--) {

  547. 

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

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

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

  551. 

  552.             ADVANCE_CURFRAME_X();

  553.             ADVANCE_PREVFRAME_X();

  554.         }

  555.         break;

  556. 

  557.     case PIX_FMT_RGBA32:

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

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

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

  561.         line_inc = stride - width;

  562.         curframe_index = y * stride + x;

  563.         curframe_x = x;

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

  565.         prevframe_x = x + motion_x;

  566.         while(pixel_count--) {

  567. 

  568.             rgb32_plane[curframe_index++] = 

  569.                 prev_rgb32_plane[prevframe_index++];

  570. 

  571.             ADVANCE_CURFRAME_X();

  572.             ADVANCE_PREVFRAME_X();

  573.         }

  574.         break;

  575. 

  576.     case PIX_FMT_YUV444P:

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

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

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

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

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

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

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

  584.         line_inc = stride - width;

  585.         curframe_index = y * stride + x;

  586.         curframe_x = x;

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

  588.         prevframe_x = x + motion_x;

  589.         while(pixel_count--) {

  590. 

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

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

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

  594. 

  595.             curframe_index++;

  596.             ADVANCE_CURFRAME_X();

  597.             prevframe_index++;

  598.             ADVANCE_PREVFRAME_X();

  599.         }

  600.         break;

  601. 

  602.     default:

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

  604.         break;

  605.     }

  606. }

  607. 

  608. static void xan_wc3_decode_frame(XanContext *s) {

  609. 

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

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

  612.     int total_pixels = width * height;

  613.     unsigned char opcode;

  614.     unsigned char flag = 0;

  615.     int size = 0;

  616.     int motion_x, motion_y;

  617.     int x, y;

  618. 

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

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

  621. 

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

  623.     unsigned char *huffman_segment;

  624.     unsigned char *size_segment;

  625.     unsigned char *vector_segment;

  626.     unsigned char *imagedata_segment;

  627. 

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

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

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

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

  632. 

  633.     xan_huffman_decode(opcode_buffer, huffman_segment);

  634. 

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

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

  637.     else

  638.         imagedata_buffer = &imagedata_segment[1];

  639. 

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

  641.     x = y = 0;

  642.     while (total_pixels) {

  643. 

  644.         opcode = *opcode_buffer++;

  645.         size = 0;

  646. 

  647.         switch (opcode) {

  648. 

  649.         case 0:

  650.             flag ^= 1;

  651.             continue;

  652. 

  653.         case 1:

  654.         case 2:

  655.         case 3:

  656.         case 4:

  657.         case 5:

  658.         case 6:

  659.         case 7:

  660.         case 8:

  661.             size = opcode;

  662.             break;

  663. 

  664.         case 12:

  665.         case 13:

  666.         case 14:

  667.         case 15:

  668.         case 16:

  669.         case 17:

  670.         case 18:

  671.             size += (opcode - 10);

  672.             break;

  673. 

  674.         case 9:

  675.         case 19:

  676.             size = *size_segment++;

  677.             break;

  678. 

  679.         case 10:

  680.         case 20:

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

  682.             size_segment += 2;

  683.             break;

  684. 

  685.         case 11:

  686.         case 21:

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

  688.                 size_segment[2];

  689.             size_segment += 3;

  690.             break;

  691.         }

  692. 

  693.         if (opcode < 12) {

  694.             flag ^= 1;

  695.             if (flag) {

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

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

  698.             } else {

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

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

  701.                 imagedata_buffer += size;

  702.             }

  703.         } else {

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

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

  706.             motion_y = *vector_segment & 0xF;

  707.             vector_segment++;

  708. 

  709.             /* sign extension */

  710.             if (motion_x & 0x8)

  711.                 motion_x |= 0xFFFFFFF0;

  712.             if (motion_y & 0x8)

  713.                 motion_y |= 0xFFFFFFF0;

  714. 

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

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

  717. 

  718.             flag = 0;

  719.         }

  720. 

  721.         /* coordinate accounting */

  722.         total_pixels -= size;

  723.         while (size) {

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

  725.                 y++;

  726.                 size -= (width - x);

  727.                 x = 0;

  728.             } else {

  729.                 x += size;

  730.                 size = 0;

  731.             }

  732.         }

  733.     }

  734. 

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

  736.     if (s->avctx->pix_fmt == PIX_FMT_PAL8) {

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

  738.         s->current_frame.palette_has_changed = 1;

  739.         s->avctx->palctrl->palette_changed = 0;

  740.     }

  741. }

  742. 

  743. static void xan_wc4_decode_frame(XanContext *s) {

  744. }

  745. 

  746. static int xan_decode_frame(AVCodecContext *avctx,

  747.                             void *data, int *data_size,

  748.                             uint8_t *buf, int buf_size)

  749. {

  750.     XanContext *s = avctx->priv_data;

  751.     AVPaletteControl *palette_control = avctx->palctrl;

  752.     int keyframe = 0;

  753. 

  754.     if (palette_control->palette_changed) {

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

  756.         xan_wc3_build_palette(s, palette_control->palette);

  757.         /* If pal8 we clear flag when we copy palette */

  758.         if (s->avctx->pix_fmt != PIX_FMT_PAL8)

  759.             palette_control->palette_changed = 0;

  760.         keyframe = 1;

  761.     }

  762. 

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

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

  765.         return -1;

  766.     }

  767.     s->current_frame.reference = 3;

  768. 

  769.     s->buf = buf;

  770.     s->size = buf_size;

  771. 

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

  773.         xan_wc3_decode_frame(s);

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

  775.         xan_wc4_decode_frame(s);

  776. 

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

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

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

  780. 

  781.     /* shuffle frames */

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

  783. 

  784.     *data_size = sizeof(AVFrame);

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

  786. 

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

  788.     return buf_size;

  789. }

  790. 

  791. static int xan_decode_end(AVCodecContext *avctx)

  792. {

  793.     XanContext *s = avctx->priv_data;

  794. 

  795.     /* release the last frame */

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

  797. 

  798.     av_free(s->buffer1);

  799.     av_free(s->buffer2);

  800. 

  801.     return 0;

  802. }

  803. 

  804. AVCodec xan_wc3_decoder = {

  805.     "xan_wc3",

  806.     CODEC_TYPE_VIDEO,

  807.     CODEC_ID_XAN_WC3,

  808.     sizeof(XanContext),

  809.     xan_decode_init,

  810.     NULL,

  811.     xan_decode_end,

  812.     xan_decode_frame,

  813.     CODEC_CAP_DR1,

  814. };

  815. 

  816. /*

  817. AVCodec xan_wc4_decoder = {

  818.     "xan_wc4",

  819.     CODEC_TYPE_VIDEO,

  820.     CODEC_ID_XAN_WC4,

  821.     sizeof(XanContext),

  822.     xan_decode_init,

  823.     NULL,

  824.     xan_decode_end,

  825.     xan_decode_frame,

  826.     CODEC_CAP_DR1,

  827. };

  828. */