libmpcodecs/vd_sgi.c

   1 /*
   2  * Copyright (c) 2003 Todd Kirby <slapcat@pacbell.net>
   3  *
   4  * This file is part of MPlayer.
   5  *
   6  * MPlayer is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * MPlayer is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23
  24 #include <libavutil/intreadwrite.h>
  25
  26 #include "config.h"
  27 #include "mp_msg.h"
  28 #include "mpbswap.h"
  29 #include "vd_internal.h"
  30
  31 #define SGI_HEADER_LEN 512
  32 #define SGI_MAGIC 474
  33
  34 #define SGI_GRAYSCALE_IMAGE 1
  35 #define SGI_RGB_IMAGE 3
  36 #define SGI_RGBA_IMAGE 4
  37
  38 #define OUT_PIXEL_STRIDE 3 /* RGB */
  39
  40
  41 static const vd_info_t info =
  42 {
  43   "SGI Image decoder",
  44   "sgi",
  45   "Todd Kirby",
  46   "Todd Kirby",
  47   ""
  48 };
  49
  50 LIBVD_EXTERN(sgi)
  51
  52 typedef struct {
  53   short magic;
  54   char rle;
  55   char bytes_per_channel;
  56   unsigned short dimension;
  57   unsigned short xsize;
  58   unsigned short ysize;
  59   unsigned short zsize;
  60 } SGIInfo;
  61
  62 static unsigned int outfmt = IMGFMT_BGR24;
  63
  64 static unsigned short last_x = -1;
  65 static unsigned short last_y = -1;
  66
  67
  68 /* to set/get/query special features/parameters */
  69 static int
  70 control(sh_video_t* sh, int cmd, void *arg, ...)
  71 {
  72   switch (cmd)
  73   {
  74     case VDCTRL_QUERY_FORMAT:
  75       if (*((unsigned int *) arg) == outfmt) {
  76         return CONTROL_TRUE;
  77       }
  78       return CONTROL_FALSE;
  79   }
  80   return CONTROL_UNKNOWN;
  81 }
  82
  83
  84 /* init driver */
  85 static int
  86 init(sh_video_t *sh)
  87 {
  88   sh->context = calloc(1, sizeof(SGIInfo));
  89   last_x = -1;
  90
  91   return 1;
  92 }
  93
  94
  95 /* uninit driver */
  96 static void
  97 uninit(sh_video_t *sh)
  98 {
  99   SGIInfo       *info = sh->context;
 100   free(info);
 101 }
 102
 103
 104 /* expand an rle row into a channel */
 105 static void
 106 expandrow(unsigned char *optr, unsigned char *iptr, int chan_offset)
 107 {
 108   unsigned char pixel, count;
 109   optr += chan_offset;
 110
 111   while (1) {
 112     pixel = *iptr++;
 113
 114     if (!(count = (pixel & 0x7f))) {
 115       return;
 116     }
 117     if(pixel & 0x80) {
 118       while (count--) {
 119         *optr = *iptr;
 120         optr += OUT_PIXEL_STRIDE;
 121         iptr++;
 122       }
 123     } else {
 124       pixel = *iptr++;
 125
 126       while (count--) {
 127         *optr = pixel;
 128         optr += OUT_PIXEL_STRIDE;
 129       }
 130     }
 131   }
 132 }
 133
 134
 135 /* expand an rle row into all 3 channels.
 136    a separate function for grayscale so we don't slow down the
 137    more common case rgb function with a bunch of ifs. */
 138 static void
 139 expandrow_gs(unsigned char *optr, unsigned char *iptr)
 140 {
 141   unsigned char pixel, count;
 142
 143   while (1) {
 144     pixel = *iptr++;
 145
 146     if (!(count = (pixel & 0x7f))) {
 147       return;
 148     }
 149     if(pixel & 0x80) {
 150       while (count--) {
 151         optr[0] = *iptr;
 152         optr[1] = *iptr;
 153         optr[2] = *iptr;
 154         optr += OUT_PIXEL_STRIDE;
 155         iptr++;
 156       }
 157     } else {
 158       pixel = *iptr++;
 159
 160       while (count--) {
 161         optr[0] = pixel;
 162         optr[1] = pixel;
 163         optr[2] = pixel;
 164         optr += OUT_PIXEL_STRIDE;
 165       }
 166     }
 167   }
 168 }
 169
 170
 171 /* decode a run length encoded sgi image */
 172 static void
 173 decode_rle_sgi(SGIInfo *info, unsigned char *data, mp_image_t *mpi)
 174 {
 175   unsigned char *rle_data, *dest_row;
 176   uint32_t *starttab;
 177   int y, z, ysize, zsize, chan_offset;
 178   long start_offset;
 179
 180   ysize = info->ysize;
 181   zsize = info->zsize;
 182
 183   /* rle offset table is right after the header */
 184   starttab = (uint32_t*)(data + SGI_HEADER_LEN);
 185
 186    for (z = 0; z < zsize; z++) {
 187
 188      /* set chan_offset so RGB ends up BGR */
 189      chan_offset = (zsize - 1) - z;
 190
 191      /* The origin for SGI images is the lower-left corner
 192         so read scan lines from bottom to top */
 193      for (y = ysize - 1; y >= 0; y--) {
 194        dest_row = mpi->planes[0] + mpi->stride[0] * (ysize - 1 - y);
 195
 196       /* set start of next run (offsets are from start of header) */
 197       start_offset = AV_RB32(&starttab[y + z * ysize]);
 198
 199       rle_data = &data[start_offset];
 200
 201       if(info->zsize == SGI_GRAYSCALE_IMAGE) {
 202         expandrow_gs(dest_row, rle_data);
 203       } else {
 204         expandrow(dest_row, rle_data, chan_offset);
 205       }
 206     }
 207   }
 208 }
 209
 210
 211 /* decode an sgi image */
 212 static void
 213 decode_uncompressed_sgi(SGIInfo *info, unsigned char *data, mp_image_t *mpi)
 214 {
 215   unsigned char *src_row, *dest_row;
 216   int x, y, z, xsize, ysize, zsize, chan_offset;
 217
 218   xsize = info->xsize;
 219   ysize = info->ysize;
 220   zsize = info->zsize;
 221
 222   /* skip header */
 223   data += SGI_HEADER_LEN;
 224
 225   for (z = 0; z < zsize; z++) {
 226
 227     /* set row ptr to start of current plane */
 228     src_row = data + (xsize * ysize * z);
 229
 230     /* set chan_offset for RGB -> BGR */
 231     chan_offset = (zsize - 1) - z;
 232
 233     /* the origin for SGI images is the lower-left corner
 234        so read scan lines from bottom to top. */
 235     for (y = ysize - 1; y >= 0; y--) {
 236       dest_row = mpi->planes[0] + mpi->stride[0] * y;
 237       for (x = 0; x < xsize; x++) {
 238
 239         /* we only do 24 bit output so promote 8 bit pixels to 24 */
 240         if (zsize == SGI_GRAYSCALE_IMAGE) {
 241           /* write greyscale value into all channels */
 242           dest_row[0] = src_row[x];
 243           dest_row[1] = src_row[x];
 244           dest_row[2] = src_row[x];
 245         } else {
 246           dest_row[chan_offset] = src_row[x];
 247         }
 248
 249         dest_row += OUT_PIXEL_STRIDE;
 250       }
 251
 252       /* move to next row of the current source plane */
 253       src_row += xsize;
 254     }
 255   }
 256 }
 257
 258
 259 /* read sgi header fields */
 260 static void
 261 read_sgi_header(unsigned char *buf, SGIInfo *info)
 262 {
 263   /* sgi data is always stored in big endian byte order */
 264   info->magic = AV_RB16(&buf[0]);
 265   info->rle = buf[2];
 266   info->bytes_per_channel = buf[3];
 267   info->dimension = AV_RB16(&buf[4]);
 268   info->xsize = AV_RB16(&buf[6]);
 269   info->ysize = AV_RB16(&buf[8]);
 270   info->zsize = AV_RB16(&buf[10]);
 271 }
 272
 273
 274 /* decode a frame */
 275 static
 276 mp_image_t *decode(sh_video_t *sh, void *raw, int len, int flags)
 277 {
 278   SGIInfo *info = sh->context;
 279   unsigned char *data = raw;
 280   mp_image_t *mpi;
 281
 282   if (len <= 0) {
 283     return NULL; /* skip frame */
 284   }
 285
 286   read_sgi_header(data, info);
 287
 288   /* make sure this is an SGI image file */
 289   if (info->magic != SGI_MAGIC) {
 290     mp_msg(MSGT_DECVIDEO, MSGL_INFO, "Bad magic number in image.\n");
 291     return NULL;
 292   }
 293
 294   /* check image depth */
 295   if (info->bytes_per_channel != 1) {
 296     mp_msg(MSGT_DECVIDEO, MSGL_INFO,
 297         "Unsupported bytes per channel value %i.\n", info->bytes_per_channel);
 298     return NULL;
 299   }
 300
 301   /* check image dimension */
 302   if (info->dimension != 2 && info->dimension != 3) {
 303     mp_msg(MSGT_DECVIDEO, MSGL_INFO, "Unsupported image dimension %i.\n",
 304         info->dimension);
 305     return NULL;
 306   }
 307
 308   /* change rgba images to rgb so alpha channel will be ignored */
 309   if (info->zsize == SGI_RGBA_IMAGE) {
 310     info->zsize = SGI_RGB_IMAGE;
 311   }
 312
 313   /* check image depth */
 314   if (info->zsize != SGI_RGB_IMAGE && info->zsize != SGI_GRAYSCALE_IMAGE) {
 315     mp_msg(MSGT_DECVIDEO, MSGL_INFO, "Unsupported image depth.\n");
 316     return NULL;
 317   }
 318
 319   /* (re)init libvo if image size is changed */
 320   if (last_x != info->xsize || last_y != info->ysize)
 321   {
 322     last_x = info->xsize;
 323     last_y = info->ysize;
 324
 325     if (!mpcodecs_config_vo(sh, info->xsize, info->ysize, outfmt)) {
 326       mp_msg(MSGT_DECVIDEO, MSGL_INFO, "Config vo failed:\n");
 327       return NULL;
 328     }
 329   }
 330
 331   if (!(mpi = mpcodecs_get_image(sh, MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE,
 332           info->xsize, info->ysize))) {
 333     return NULL;
 334   }
 335
 336   if (info->rle) {
 337     decode_rle_sgi(info, data, mpi);
 338   } else {
 339     decode_uncompressed_sgi(info, data, mpi);
 340   }
 341
 342   return mpi;
 343 }