view libmpcodecs/native/fli.c @ 10256:b3dc48745013

Sync

/*
    FLI Decoder for MPlayer
    
    (C) 2001 Mike Melanson
    
    32bpp support (c) alex

    Additional code and bug fixes by Roberto Togni

    For information on the FLI format, as well as various traps to
    avoid while programming one, visit:
      http://www.pcisys.net/~melanson/codecs/
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
#include "bswap.h"
#include "mp_msg.h"

#define LE_16(x) (le2me_16(*(unsigned short *)(x)))
#define LE_32(x) (le2me_32(*(unsigned int *)(x)))

#define FLI_256_COLOR 4
#define FLI_DELTA     7
#define FLI_COLOR     11
#define FLI_LC        12
#define FLI_BLACK     13
#define FLI_BRUN      15
#define FLI_COPY      16
#define FLI_MINI      18

// 256 RGB entries; 25% of these bytes will be unused, but it's faster
// to index 4-byte entries
#define PALETTE_SIZE 1024
static unsigned char palette[PALETTE_SIZE];

void *init_fli_decoder(int width, int height)
{
  memset(palette, 0, PALETTE_SIZE);

  return malloc(width * height * sizeof (unsigned char));
}

void decode_fli_frame(
  unsigned char *encoded,
  int encoded_size,
  unsigned char *decoded,
  int width,
  int height,
  int bytes_per_pixel,
  void *context)
{
  int stream_ptr = 0;
  int stream_ptr_after_color_chunk;
  int pixel_ptr;
  int palette_ptr1;
  int palette_ptr2;
  unsigned char palette_idx1;
  unsigned char palette_idx2;

  unsigned int frame_size;
  int num_chunks;

  unsigned int chunk_size;
  int chunk_type;

  int i, j;

  int color_packets;
  int color_changes;
  int color_scale;

  int lines;
  int compressed_lines;
  int starting_line;
  signed short line_packets;
  int y_ptr;
  int line_inc = width * bytes_per_pixel;
  signed char byte_run;
  int pixel_skip;
  int update_whole_frame = 0; // Palette change flag
  unsigned char *fli_ghost_image = (unsigned char *)context;
  int ghost_pixel_ptr;
  int ghost_y_ptr;

  frame_size = LE_32(&encoded[stream_ptr]);
  stream_ptr += 6;  // skip the magic number
  num_chunks = LE_16(&encoded[stream_ptr]);
  stream_ptr += 10;  // skip padding

  // iterate through the chunks
  frame_size -= 16;
  while ((frame_size > 0) && (num_chunks > 0))
  {
    chunk_size = LE_32(&encoded[stream_ptr]);
    stream_ptr += 4;
    chunk_type = LE_16(&encoded[stream_ptr]);
    stream_ptr += 2;

    switch (chunk_type)
    {
    case FLI_256_COLOR:
    case FLI_COLOR:
      stream_ptr_after_color_chunk = stream_ptr + chunk_size - 6;
      if (chunk_type == FLI_COLOR)
        color_scale = 4;
      else
        color_scale = 1;
      // set up the palette
      color_packets = LE_16(&encoded[stream_ptr]);
      stream_ptr += 2;
      palette_ptr1 = 0;
      for (i = 0; i < color_packets; i++)
      {
        // first byte is how many colors to skip
        palette_ptr1 += (encoded[stream_ptr++] * 4);
        // wrap around, for good measure
        if (palette_ptr1 >= PALETTE_SIZE)
          palette_ptr1 = 0;
        // next byte indicates how many entries to change
        color_changes = encoded[stream_ptr++];
        // if there are 0 color changes, there are actually 256
        if (color_changes == 0)
          color_changes = 256;
        for (j = 0; j < color_changes; j++)
        {
          palette[palette_ptr1++] = encoded[stream_ptr + 2] * color_scale;
          palette[palette_ptr1++] = encoded[stream_ptr + 1] * color_scale;
          palette[palette_ptr1++] = encoded[stream_ptr + 0] * color_scale;
          palette_ptr1++;
          stream_ptr += 3;
        }
      }

      // color chunks sometimes have weird 16-bit alignment issues;
      // therefore, take the hardline approach and set the stream_ptr
      // to the value calculate w.r.t. the size specified by the color
      // chunk header
      stream_ptr = stream_ptr_after_color_chunk;

      /* Palette has changed, must update frame */
      update_whole_frame = 1;
      break;

    case FLI_DELTA:
      y_ptr = ghost_y_ptr = 0;
      compressed_lines = LE_16(&encoded[stream_ptr]);
      stream_ptr += 2;
      while (compressed_lines > 0)
      {
        line_packets = LE_16(&encoded[stream_ptr]);
        stream_ptr += 2;
        if (line_packets < 0)
        {
          line_packets = -line_packets;
          y_ptr += (line_packets * line_inc);
          ghost_y_ptr += (line_packets * width);
        }
        else
        {
          pixel_ptr = y_ptr;
          ghost_pixel_ptr = ghost_y_ptr;
          for (i = 0; i < line_packets; i++)
          {
            // account for the skip bytes
            pixel_skip = encoded[stream_ptr++];
            pixel_ptr += pixel_skip * bytes_per_pixel;
            ghost_pixel_ptr += pixel_skip;
            byte_run = encoded[stream_ptr++];
            if (byte_run < 0)
            {
              byte_run = -byte_run;
              palette_ptr1 = (palette_idx1 = encoded[stream_ptr++]) * 4;
              palette_ptr2 = (palette_idx2 = encoded[stream_ptr++]) * 4;
              for (j = 0; j < byte_run; j++)
              {
                fli_ghost_image[ghost_pixel_ptr++] = palette_idx1;
                decoded[pixel_ptr++] = palette[palette_ptr1 + 0];
                decoded[pixel_ptr++] = palette[palette_ptr1 + 1];
                decoded[pixel_ptr++] = palette[palette_ptr1 + 2];
		if (bytes_per_pixel == 4) /* 32bpp */
		    pixel_ptr++;

                fli_ghost_image[ghost_pixel_ptr++] = palette_idx2;
                decoded[pixel_ptr++] = palette[palette_ptr2 + 0];
                decoded[pixel_ptr++] = palette[palette_ptr2 + 1];
                decoded[pixel_ptr++] = palette[palette_ptr2 + 2];
		if (bytes_per_pixel == 4) /* 32bpp */
		    pixel_ptr++;
              }
            }
            else
            {
              for (j = 0; j < byte_run * 2; j++)
              {
                palette_ptr1 = (palette_idx1 = encoded[stream_ptr++]) * 4;
                fli_ghost_image[ghost_pixel_ptr++] = palette_idx1;
                decoded[pixel_ptr++] = palette[palette_ptr1 + 0];
                decoded[pixel_ptr++] = palette[palette_ptr1 + 1];
                decoded[pixel_ptr++] = palette[palette_ptr1 + 2];
		if (bytes_per_pixel == 4) /* 32bpp */
		    pixel_ptr++;
              }
            }
          }
          y_ptr += line_inc;
          ghost_y_ptr += width;
          compressed_lines--;
        }
      }
      break;

    case FLI_LC:
      // line compressed
      starting_line = LE_16(&encoded[stream_ptr]);
      stream_ptr += 2;
      y_ptr = starting_line * line_inc;
      ghost_y_ptr = starting_line * width;

      compressed_lines = LE_16(&encoded[stream_ptr]);
      stream_ptr += 2;
      while (compressed_lines > 0)
      {
        pixel_ptr = y_ptr;
        ghost_pixel_ptr = ghost_y_ptr;
        line_packets = encoded[stream_ptr++];
        if (line_packets > 0)
        {
          for (i = 0; i < line_packets; i++)
          {
            // account for the skip bytes
            pixel_skip = encoded[stream_ptr++];
            pixel_ptr += pixel_skip * bytes_per_pixel;
            ghost_pixel_ptr += pixel_skip;
            byte_run = encoded[stream_ptr++];
            if (byte_run > 0)
            {
              for (j = 0; j < byte_run; j++)
              {
                palette_ptr1 = (palette_idx1 = encoded[stream_ptr++]) * 4;
                fli_ghost_image[ghost_pixel_ptr++] = palette_idx1;
                decoded[pixel_ptr++] = palette[palette_ptr1 + 0];
                decoded[pixel_ptr++] = palette[palette_ptr1 + 1];
                decoded[pixel_ptr++] = palette[palette_ptr1 + 2];
		if (bytes_per_pixel == 4) /* 32bpp */
		    pixel_ptr++;
              }
            }
            else
            {
              byte_run = -byte_run;
              palette_ptr1 = (palette_idx1 = encoded[stream_ptr++]) * 4;
              for (j = 0; j < byte_run; j++)
              {
                fli_ghost_image[ghost_pixel_ptr++] = palette_idx1;
                decoded[pixel_ptr++] = palette[palette_ptr1 + 0];
                decoded[pixel_ptr++] = palette[palette_ptr1 + 1];
                decoded[pixel_ptr++] = palette[palette_ptr1 + 2];
		if (bytes_per_pixel == 4) /* 32bpp */
		    pixel_ptr++;
              }
            }
          }
        }

        y_ptr += line_inc;
        ghost_y_ptr += width;
        compressed_lines--;
      }
      break;

    case FLI_BLACK:
      // set the whole frame to color 0 (which is usually black) by
      // clearing the ghost image and trigger a full frame update
      memset(fli_ghost_image, 0, width * height * sizeof(unsigned char));
      update_whole_frame = 1;
      break;

    case FLI_BRUN:
      // byte run compression
      y_ptr = 0;
      ghost_y_ptr = 0;
      for (lines = 0; lines < height; lines++)
      {
        pixel_ptr = y_ptr;
        ghost_pixel_ptr = ghost_y_ptr;
        line_packets = encoded[stream_ptr++];
        for (i = 0; i < line_packets; i++)
        {
          byte_run = encoded[stream_ptr++];
          if (byte_run > 0)
          {
            palette_ptr1 = (palette_idx1 = encoded[stream_ptr++]) * 4;
            for (j = 0; j < byte_run; j++)
            {
              fli_ghost_image[ghost_pixel_ptr++] = palette_idx1;
              decoded[pixel_ptr++] = palette[palette_ptr1 + 0];
              decoded[pixel_ptr++] = palette[palette_ptr1 + 1];
              decoded[pixel_ptr++] = palette[palette_ptr1 + 2];
	      if (bytes_per_pixel == 4) /* 32bpp */
		pixel_ptr++;
            }
          }
          else  // copy bytes if byte_run < 0
          {
            byte_run = -byte_run;
            for (j = 0; j < byte_run; j++)
            {
              palette_ptr1 = (palette_idx1 = encoded[stream_ptr++]) * 4;
              fli_ghost_image[ghost_pixel_ptr++] = palette_idx1;
              decoded[pixel_ptr++] = palette[palette_ptr1 + 0];
              decoded[pixel_ptr++] = palette[palette_ptr1 + 1];
              decoded[pixel_ptr++] = palette[palette_ptr1 + 2];
	      if (bytes_per_pixel == 4) /* 32bpp */
		pixel_ptr++;
            }
          }
        }

        y_ptr += line_inc;
        ghost_y_ptr += width;
      }
      break;

    case FLI_COPY:
      // copy the chunk (uncompressed frame) to the ghost image and
      // schedule the whole frame to be updated
      if (chunk_size - 6 > width * height)
      {
        mp_msg(MSGT_DECVIDEO, MSGL_WARN,
         "FLI: in chunk FLI_COPY : source data (%d bytes) bigger than image," \
         " skipping chunk\n",
         chunk_size - 6);
         break;
      }
      else
        memcpy(fli_ghost_image, &encoded[stream_ptr], chunk_size - 6);
      stream_ptr += chunk_size - 6;
      update_whole_frame = 1;
      break;

    case FLI_MINI:
      // sort of a thumbnail? disregard this chunk...
      stream_ptr += chunk_size - 6;
      break;

    default:
      mp_msg (MSGT_DECVIDEO, MSGL_WARN,
       "FLI: Unrecognized chunk type: %d\n", chunk_type);
      break;
    }

    frame_size -= chunk_size;
    num_chunks--;
  }

  if (update_whole_frame)
  {
    pixel_ptr = ghost_pixel_ptr = 0;
    while (pixel_ptr < (width * height * bytes_per_pixel))
    {
      palette_ptr1 = fli_ghost_image[ghost_pixel_ptr++] * 4;
      decoded[pixel_ptr++] = palette[palette_ptr1 + 0];
      decoded[pixel_ptr++] = palette[palette_ptr1 + 1];
      decoded[pixel_ptr++] = palette[palette_ptr1 + 2];
      if (bytes_per_pixel == 4) /* 32bpp */
        pixel_ptr++;
    }
  }

  // by the end of the chunk, the stream ptr should equal the frame 
  // size (minus 1, possibly); if it doesn't, issue a warning
  if ((stream_ptr != encoded_size) && (stream_ptr != encoded_size - 1))
    mp_msg(MSGT_DECVIDEO, MSGL_WARN,
      "  warning: processed FLI chunk where encoded size = %d\n" \
      "  and final chunk ptr = %d\n",
      encoded_size, stream_ptr);
}