git.sesse.net Git - ffmpeg/blob - libavcodec/qtrle.c

   1 /*
   2  * Quicktime Animation (RLE) Video Decoder
   3  * Copyright (C) 2004 the ffmpeg project
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * QT RLE Video Decoder by Mike Melanson (melanson@pcisys.net)
  25  * For more information about the QT RLE format, visit:
  26  *   http://www.pcisys.net/~melanson/codecs/
  27  *
  28  * The QT RLE decoder has seven modes of operation:
  29  * 1, 2, 4, 8, 16, 24, and 32 bits per pixel. For modes 1, 2, 4, and 8
  30  * the decoder outputs PAL8 colorspace data. 16-bit data yields RGB555
  31  * data. 24-bit data is RGB24 and 32-bit data is RGB32.
  32  */
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37
  38 #include "libavutil/intreadwrite.h"
  39 #include "avcodec.h"
  40
  41 typedef struct QtrleContext {
  42
  43     AVCodecContext *avctx;
  44     AVFrame frame;
  45
  46     const unsigned char *buf;
  47     int size;
  48
  49     uint32_t pal[256];
  50 } QtrleContext;
  51
  52 #define CHECK_STREAM_PTR(n) \
  53   if ((stream_ptr + n) > s->size) { \
  54     av_log (s->avctx, AV_LOG_INFO, "Problem: stream_ptr out of bounds (%d >= %d)\n", \
  55       stream_ptr + n, s->size); \
  56     return; \
  57   }
  58
  59 #define CHECK_PIXEL_PTR(n) \
  60   if ((pixel_ptr + n > pixel_limit) || (pixel_ptr + n < 0)) { \
  61     av_log (s->avctx, AV_LOG_INFO, "Problem: pixel_ptr = %d, pixel_limit = %d\n", \
  62       pixel_ptr + n, pixel_limit); \
  63     return; \
  64   } \
  65
  66 static void qtrle_decode_1bpp(QtrleContext *s, int stream_ptr, int row_ptr, int lines_to_change)
  67 {
  68     int rle_code;
  69     int pixel_ptr = 0;
  70     int row_inc = s->frame.linesize[0];
  71     unsigned char pi0, pi1;  /* 2 8-pixel values */
  72     unsigned char *rgb = s->frame.data[0];
  73     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
  74     int skip;
  75     /* skip & 0x80 appears to mean 'start a new line', which can be interpreted
  76      * as 'go to next line' during the decoding of a frame but is 'go to first
  77      * line' at the beginning. Since we always interpret it as 'go to next line'
  78      * in the decoding loop (which makes code simpler/faster), the first line
  79      * would not be counted, so we count one more.
  80      * See: https://ffmpeg.org/trac/ffmpeg/ticket/226
  81      * In the following decoding loop, row_ptr will be the position of the
  82      * _next_ row. */
  83     lines_to_change++;
  84
  85     while (lines_to_change) {
  86         CHECK_STREAM_PTR(2);
  87         skip = s->buf[stream_ptr++];
  88         rle_code = (signed char)s->buf[stream_ptr++];
  89         if (rle_code == 0)
  90             break;
  91         if(skip & 0x80) {
  92             lines_to_change--;
  93             pixel_ptr = row_ptr + 2 * (skip & 0x7f);
  94             row_ptr += row_inc;
  95         } else
  96             pixel_ptr += 2 * skip;
  97         CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
  98
  99         if(rle_code == -1)
 100             continue;
 101
 102         if (rle_code < 0) {
 103             /* decode the run length code */
 104             rle_code = -rle_code;
 105             /* get the next 2 bytes from the stream, treat them as groups
 106              * of 8 pixels, and output them rle_code times */
 107             CHECK_STREAM_PTR(2);
 108             pi0 = s->buf[stream_ptr++];
 109             pi1 = s->buf[stream_ptr++];
 110             CHECK_PIXEL_PTR(rle_code * 2);
 111
 112             while (rle_code--) {
 113                 rgb[pixel_ptr++] = pi0;
 114                 rgb[pixel_ptr++] = pi1;
 115             }
 116         } else {
 117             /* copy the same pixel directly to output 2 times */
 118             rle_code *= 2;
 119             CHECK_STREAM_PTR(rle_code);
 120             CHECK_PIXEL_PTR(rle_code);
 121
 122             while (rle_code--)
 123                 rgb[pixel_ptr++] = s->buf[stream_ptr++];
 124         }
 125     }
 126 }
 127
 128 static inline void qtrle_decode_2n4bpp(QtrleContext *s, int stream_ptr,
 129                              int row_ptr, int lines_to_change, int bpp)
 130 {
 131     int rle_code, i;
 132     int pixel_ptr;
 133     int row_inc = s->frame.linesize[0];
 134     unsigned char pi[16];  /* 16 palette indices */
 135     unsigned char *rgb = s->frame.data[0];
 136     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
 137     int num_pixels = (bpp == 4) ? 8 : 16;
 138
 139     while (lines_to_change--) {
 140         CHECK_STREAM_PTR(2);
 141         pixel_ptr = row_ptr + (num_pixels * (s->buf[stream_ptr++] - 1));
 142         CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 143
 144         while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) {
 145             if (rle_code == 0) {
 146                 /* there's another skip code in the stream */
 147                 CHECK_STREAM_PTR(1);
 148                 pixel_ptr += (num_pixels * (s->buf[stream_ptr++] - 1));
 149                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 150             } else if (rle_code < 0) {
 151                 /* decode the run length code */
 152                 rle_code = -rle_code;
 153                 /* get the next 4 bytes from the stream, treat them as palette
 154                  * indexes, and output them rle_code times */
 155                 CHECK_STREAM_PTR(4);
 156                 for (i = num_pixels-1; i >= 0; i--) {
 157                     pi[num_pixels-1-i] = (s->buf[stream_ptr] >> ((i*bpp) & 0x07)) & ((1<<bpp)-1);
 158                     stream_ptr+= ((i & ((num_pixels>>2)-1)) == 0);
 159                 }
 160                 CHECK_PIXEL_PTR(rle_code * num_pixels);
 161                 while (rle_code--) {
 162                     for (i = 0; i < num_pixels; i++)
 163                         rgb[pixel_ptr++] = pi[i];
 164                 }
 165             } else {
 166                 /* copy the same pixel directly to output 4 times */
 167                 rle_code *= 4;
 168                 CHECK_STREAM_PTR(rle_code);
 169                 CHECK_PIXEL_PTR(rle_code*(num_pixels>>2));
 170                 while (rle_code--) {
 171                     if(bpp == 4) {
 172                         rgb[pixel_ptr++] = ((s->buf[stream_ptr]) >> 4) & 0x0f;
 173                         rgb[pixel_ptr++] = (s->buf[stream_ptr++]) & 0x0f;
 174                     } else {
 175                         rgb[pixel_ptr++] = ((s->buf[stream_ptr]) >> 6) & 0x03;
 176                         rgb[pixel_ptr++] = ((s->buf[stream_ptr]) >> 4) & 0x03;
 177                         rgb[pixel_ptr++] = ((s->buf[stream_ptr]) >> 2) & 0x03;
 178                         rgb[pixel_ptr++] = (s->buf[stream_ptr++]) & 0x03;
 179                     }
 180                 }
 181             }
 182         }
 183         row_ptr += row_inc;
 184     }
 185 }
 186
 187 static void qtrle_decode_8bpp(QtrleContext *s, int stream_ptr, int row_ptr, int lines_to_change)
 188 {
 189     int rle_code;
 190     int pixel_ptr;
 191     int row_inc = s->frame.linesize[0];
 192     unsigned char pi1, pi2, pi3, pi4;  /* 4 palette indexes */
 193     unsigned char *rgb = s->frame.data[0];
 194     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
 195
 196     while (lines_to_change--) {
 197         CHECK_STREAM_PTR(2);
 198         pixel_ptr = row_ptr + (4 * (s->buf[stream_ptr++] - 1));
 199         CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 200
 201         while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) {
 202             if (rle_code == 0) {
 203                 /* there's another skip code in the stream */
 204                 CHECK_STREAM_PTR(1);
 205                 pixel_ptr += (4 * (s->buf[stream_ptr++] - 1));
 206                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 207             } else if (rle_code < 0) {
 208                 /* decode the run length code */
 209                 rle_code = -rle_code;
 210                 /* get the next 4 bytes from the stream, treat them as palette
 211                  * indexes, and output them rle_code times */
 212                 CHECK_STREAM_PTR(4);
 213                 pi1 = s->buf[stream_ptr++];
 214                 pi2 = s->buf[stream_ptr++];
 215                 pi3 = s->buf[stream_ptr++];
 216                 pi4 = s->buf[stream_ptr++];
 217
 218                 CHECK_PIXEL_PTR(rle_code * 4);
 219
 220                 while (rle_code--) {
 221                     rgb[pixel_ptr++] = pi1;
 222                     rgb[pixel_ptr++] = pi2;
 223                     rgb[pixel_ptr++] = pi3;
 224                     rgb[pixel_ptr++] = pi4;
 225                 }
 226             } else {
 227                 /* copy the same pixel directly to output 4 times */
 228                 rle_code *= 4;
 229                 CHECK_STREAM_PTR(rle_code);
 230                 CHECK_PIXEL_PTR(rle_code);
 231
 232                 while (rle_code--) {
 233                     rgb[pixel_ptr++] = s->buf[stream_ptr++];
 234                 }
 235             }
 236         }
 237         row_ptr += row_inc;
 238     }
 239 }
 240
 241 static void qtrle_decode_16bpp(QtrleContext *s, int stream_ptr, int row_ptr, int lines_to_change)
 242 {
 243     int rle_code;
 244     int pixel_ptr;
 245     int row_inc = s->frame.linesize[0];
 246     unsigned short rgb16;
 247     unsigned char *rgb = s->frame.data[0];
 248     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
 249
 250     while (lines_to_change--) {
 251         CHECK_STREAM_PTR(2);
 252         pixel_ptr = row_ptr + (s->buf[stream_ptr++] - 1) * 2;
 253         CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 254
 255         while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) {
 256             if (rle_code == 0) {
 257                 /* there's another skip code in the stream */
 258                 CHECK_STREAM_PTR(1);
 259                 pixel_ptr += (s->buf[stream_ptr++] - 1) * 2;
 260                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 261             } else if (rle_code < 0) {
 262                 /* decode the run length code */
 263                 rle_code = -rle_code;
 264                 CHECK_STREAM_PTR(2);
 265                 rgb16 = AV_RB16(&s->buf[stream_ptr]);
 266                 stream_ptr += 2;
 267
 268                 CHECK_PIXEL_PTR(rle_code * 2);
 269
 270                 while (rle_code--) {
 271                     *(unsigned short *)(&rgb[pixel_ptr]) = rgb16;
 272                     pixel_ptr += 2;
 273                 }
 274             } else {
 275                 CHECK_STREAM_PTR(rle_code * 2);
 276                 CHECK_PIXEL_PTR(rle_code * 2);
 277
 278                 /* copy pixels directly to output */
 279                 while (rle_code--) {
 280                     rgb16 = AV_RB16(&s->buf[stream_ptr]);
 281                     stream_ptr += 2;
 282                     *(unsigned short *)(&rgb[pixel_ptr]) = rgb16;
 283                     pixel_ptr += 2;
 284                 }
 285             }
 286         }
 287         row_ptr += row_inc;
 288     }
 289 }
 290
 291 static void qtrle_decode_24bpp(QtrleContext *s, int stream_ptr, int row_ptr, int lines_to_change)
 292 {
 293     int rle_code;
 294     int pixel_ptr;
 295     int row_inc = s->frame.linesize[0];
 296     unsigned char r, g, b;
 297     unsigned char *rgb = s->frame.data[0];
 298     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
 299
 300     while (lines_to_change--) {
 301         CHECK_STREAM_PTR(2);
 302         pixel_ptr = row_ptr + (s->buf[stream_ptr++] - 1) * 3;
 303         CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 304
 305         while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) {
 306             if (rle_code == 0) {
 307                 /* there's another skip code in the stream */
 308                 CHECK_STREAM_PTR(1);
 309                 pixel_ptr += (s->buf[stream_ptr++] - 1) * 3;
 310                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 311             } else if (rle_code < 0) {
 312                 /* decode the run length code */
 313                 rle_code = -rle_code;
 314                 CHECK_STREAM_PTR(3);
 315                 r = s->buf[stream_ptr++];
 316                 g = s->buf[stream_ptr++];
 317                 b = s->buf[stream_ptr++];
 318
 319                 CHECK_PIXEL_PTR(rle_code * 3);
 320
 321                 while (rle_code--) {
 322                     rgb[pixel_ptr++] = r;
 323                     rgb[pixel_ptr++] = g;
 324                     rgb[pixel_ptr++] = b;
 325                 }
 326             } else {
 327                 CHECK_STREAM_PTR(rle_code * 3);
 328                 CHECK_PIXEL_PTR(rle_code * 3);
 329
 330                 /* copy pixels directly to output */
 331                 while (rle_code--) {
 332                     rgb[pixel_ptr++] = s->buf[stream_ptr++];
 333                     rgb[pixel_ptr++] = s->buf[stream_ptr++];
 334                     rgb[pixel_ptr++] = s->buf[stream_ptr++];
 335                 }
 336             }
 337         }
 338         row_ptr += row_inc;
 339     }
 340 }
 341
 342 static void qtrle_decode_32bpp(QtrleContext *s, int stream_ptr, int row_ptr, int lines_to_change)
 343 {
 344     int rle_code;
 345     int pixel_ptr;
 346     int row_inc = s->frame.linesize[0];
 347     unsigned int argb;
 348     unsigned char *rgb = s->frame.data[0];
 349     int pixel_limit = s->frame.linesize[0] * s->avctx->height;
 350
 351     while (lines_to_change--) {
 352         CHECK_STREAM_PTR(2);
 353         pixel_ptr = row_ptr + (s->buf[stream_ptr++] - 1) * 4;
 354         CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 355
 356         while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) {
 357             if (rle_code == 0) {
 358                 /* there's another skip code in the stream */
 359                 CHECK_STREAM_PTR(1);
 360                 pixel_ptr += (s->buf[stream_ptr++] - 1) * 4;
 361                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 362             } else if (rle_code < 0) {
 363                 /* decode the run length code */
 364                 rle_code = -rle_code;
 365                 CHECK_STREAM_PTR(4);
 366                 argb = AV_RB32(s->buf + stream_ptr);
 367                 stream_ptr += 4;
 368
 369                 CHECK_PIXEL_PTR(rle_code * 4);
 370
 371                 while (rle_code--) {
 372                     AV_WN32A(rgb + pixel_ptr, argb);
 373                     pixel_ptr += 4;
 374                 }
 375             } else {
 376                 CHECK_STREAM_PTR(rle_code * 4);
 377                 CHECK_PIXEL_PTR(rle_code * 4);
 378
 379                 /* copy pixels directly to output */
 380                 while (rle_code--) {
 381                     argb = AV_RB32(s->buf + stream_ptr);
 382                     AV_WN32A(rgb + pixel_ptr, argb);
 383                     stream_ptr += 4;
 384                     pixel_ptr  += 4;
 385                 }
 386             }
 387         }
 388         row_ptr += row_inc;
 389     }
 390 }
 391
 392 static av_cold int qtrle_decode_init(AVCodecContext *avctx)
 393 {
 394     QtrleContext *s = avctx->priv_data;
 395
 396     s->avctx = avctx;
 397     switch (avctx->bits_per_coded_sample) {
 398     case 1:
 399     case 33:
 400         avctx->pix_fmt = PIX_FMT_MONOWHITE;
 401         break;
 402
 403     case 2:
 404     case 4:
 405     case 8:
 406     case 34:
 407     case 36:
 408     case 40:
 409         avctx->pix_fmt = PIX_FMT_PAL8;
 410         break;
 411
 412     case 16:
 413         avctx->pix_fmt = PIX_FMT_RGB555;
 414         break;
 415
 416     case 24:
 417         avctx->pix_fmt = PIX_FMT_RGB24;
 418         break;
 419
 420     case 32:
 421         avctx->pix_fmt = PIX_FMT_RGB32;
 422         break;
 423
 424     default:
 425         av_log (avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n",
 426             avctx->bits_per_coded_sample);
 427         break;
 428     }
 429
 430     avcodec_get_frame_defaults(&s->frame);
 431     s->frame.data[0] = NULL;
 432
 433     return 0;
 434 }
 435
 436 static int qtrle_decode_frame(AVCodecContext *avctx,
 437                               void *data, int *data_size,
 438                               AVPacket *avpkt)
 439 {
 440     const uint8_t *buf = avpkt->data;
 441     int buf_size = avpkt->size;
 442     QtrleContext *s = avctx->priv_data;
 443     int header, start_line;
 444     int stream_ptr, height, row_ptr;
 445     int has_palette = 0;
 446
 447     s->buf = buf;
 448     s->size = buf_size;
 449
 450     s->frame.reference = 3;
 451     s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE |
 452                             FF_BUFFER_HINTS_REUSABLE | FF_BUFFER_HINTS_READABLE;
 453     if (avctx->reget_buffer(avctx, &s->frame)) {
 454         av_log (s->avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
 455         return -1;
 456     }
 457
 458     /* check if this frame is even supposed to change */
 459     if (s->size < 8)
 460         goto done;
 461
 462     /* start after the chunk size */
 463     stream_ptr = 4;
 464
 465     /* fetch the header */
 466     header = AV_RB16(&s->buf[stream_ptr]);
 467     stream_ptr += 2;
 468
 469     /* if a header is present, fetch additional decoding parameters */
 470     if (header & 0x0008) {
 471         if(s->size < 14)
 472             goto done;
 473         start_line = AV_RB16(&s->buf[stream_ptr]);
 474         stream_ptr += 4;
 475         height = AV_RB16(&s->buf[stream_ptr]);
 476         stream_ptr += 4;
 477         if (height > s->avctx->height - start_line)
 478             goto done;
 479     } else {
 480         start_line = 0;
 481         height = s->avctx->height;
 482     }
 483     row_ptr = s->frame.linesize[0] * start_line;
 484
 485     switch (avctx->bits_per_coded_sample) {
 486     case 1:
 487     case 33:
 488         qtrle_decode_1bpp(s, stream_ptr, row_ptr, height);
 489         break;
 490
 491     case 2:
 492     case 34:
 493         qtrle_decode_2n4bpp(s, stream_ptr, row_ptr, height, 2);
 494         has_palette = 1;
 495         break;
 496
 497     case 4:
 498     case 36:
 499         qtrle_decode_2n4bpp(s, stream_ptr, row_ptr, height, 4);
 500         has_palette = 1;
 501         break;
 502
 503     case 8:
 504     case 40:
 505         qtrle_decode_8bpp(s, stream_ptr, row_ptr, height);
 506         has_palette = 1;
 507         break;
 508
 509     case 16:
 510         qtrle_decode_16bpp(s, stream_ptr, row_ptr, height);
 511         break;
 512
 513     case 24:
 514         qtrle_decode_24bpp(s, stream_ptr, row_ptr, height);
 515         break;
 516
 517     case 32:
 518         qtrle_decode_32bpp(s, stream_ptr, row_ptr, height);
 519         break;
 520
 521     default:
 522         av_log (s->avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n",
 523             avctx->bits_per_coded_sample);
 524         break;
 525     }
 526
 527     if(has_palette) {
 528         const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
 529
 530         if (pal) {
 531             s->frame.palette_has_changed = 1;
 532             memcpy(s->pal, pal, AVPALETTE_SIZE);
 533         }
 534
 535         /* make the palette available on the way out */
 536         memcpy(s->frame.data[1], s->pal, AVPALETTE_SIZE);
 537     }
 538
 539 done:
 540     *data_size = sizeof(AVFrame);
 541     *(AVFrame*)data = s->frame;
 542
 543     /* always report that the buffer was completely consumed */
 544     return buf_size;
 545 }
 546
 547 static av_cold int qtrle_decode_end(AVCodecContext *avctx)
 548 {
 549     QtrleContext *s = avctx->priv_data;
 550
 551     if (s->frame.data[0])
 552         avctx->release_buffer(avctx, &s->frame);
 553
 554     return 0;
 555 }
 556
 557 AVCodec ff_qtrle_decoder = {
 558     .name           = "qtrle",
 559     .type           = AVMEDIA_TYPE_VIDEO,
 560     .id             = CODEC_ID_QTRLE,
 561     .priv_data_size = sizeof(QtrleContext),
 562     .init           = qtrle_decode_init,
 563     .close          = qtrle_decode_end,
 564     .decode         = qtrle_decode_frame,
 565     .capabilities   = CODEC_CAP_DR1,
 566     .long_name = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),
 567 };
 568