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 "avcodec.h"
  39 #include "decode.h"
  40 #include "bytestream.h"
  41 #include "internal.h"
  42
  43 typedef struct QtrleContext {
  44     AVCodecContext *avctx;
  45     AVFrame *frame;
  46
  47     GetByteContext g;
  48     uint32_t pal[256];
  49 } QtrleContext;
  50
  51 #define CHECK_PIXEL_PTR(n)                                                            \
  52     if ((pixel_ptr + n > pixel_limit) || (pixel_ptr + n < 0)) {                       \
  53         av_log (s->avctx, AV_LOG_ERROR, "Problem: pixel_ptr = %d, pixel_limit = %d\n",\
  54                 pixel_ptr + n, pixel_limit);                                          \
  55         return;                                                                       \
  56     }                                                                                 \
  57
  58 static void qtrle_decode_1bpp(QtrleContext *s, int row_ptr, int lines_to_change)
  59 {
  60     int rle_code;
  61     int pixel_ptr;
  62     int row_inc = s->frame->linesize[0];
  63     uint8_t pi0, pi1;  /* 2 8-pixel values */
  64     uint8_t *rgb = s->frame->data[0];
  65     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
  66     int skip;
  67     /* skip & 0x80 appears to mean 'start a new line', which can be interpreted
  68      * as 'go to next line' during the decoding of a frame but is 'go to first
  69      * line' at the beginning. Since we always interpret it as 'go to next line'
  70      * in the decoding loop (which makes code simpler/faster), the first line
  71      * would not be counted, so we count one more.
  72      * See: https://trac.ffmpeg.org/ticket/226
  73      * In the following decoding loop, row_ptr will be the position of the
  74      * current row. */
  75
  76     row_ptr  -= row_inc;
  77     pixel_ptr = row_ptr;
  78     lines_to_change++;
  79     while (lines_to_change) {
  80         skip     =              bytestream2_get_byte(&s->g);
  81         rle_code = (int8_t)bytestream2_get_byte(&s->g);
  82         if (rle_code == 0)
  83             break;
  84         if(skip & 0x80) {
  85             lines_to_change--;
  86             row_ptr += row_inc;
  87             pixel_ptr = row_ptr + 2 * 8 * (skip & 0x7f);
  88         } else
  89             pixel_ptr += 2 * 8 * skip;
  90         CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
  91
  92         if(rle_code == -1)
  93             continue;
  94
  95         if (rle_code < 0) {
  96             /* decode the run length code */
  97             rle_code = -rle_code;
  98             /* get the next 2 bytes from the stream, treat them as groups
  99              * of 8 pixels, and output them rle_code times */
 100
 101             pi0 = bytestream2_get_byte(&s->g);
 102             pi1 = bytestream2_get_byte(&s->g);
 103             CHECK_PIXEL_PTR(rle_code * 2 * 8);
 104
 105             while (rle_code--) {
 106                 rgb[pixel_ptr++] = (pi0 >> 7) & 0x01;
 107                 rgb[pixel_ptr++] = (pi0 >> 6) & 0x01;
 108                 rgb[pixel_ptr++] = (pi0 >> 5) & 0x01;
 109                 rgb[pixel_ptr++] = (pi0 >> 4) & 0x01;
 110                 rgb[pixel_ptr++] = (pi0 >> 3) & 0x01;
 111                 rgb[pixel_ptr++] = (pi0 >> 2) & 0x01;
 112                 rgb[pixel_ptr++] = (pi0 >> 1) & 0x01;
 113                 rgb[pixel_ptr++] =  pi0       & 0x01;
 114                 rgb[pixel_ptr++] = (pi1 >> 7) & 0x01;
 115                 rgb[pixel_ptr++] = (pi1 >> 6) & 0x01;
 116                 rgb[pixel_ptr++] = (pi1 >> 5) & 0x01;
 117                 rgb[pixel_ptr++] = (pi1 >> 4) & 0x01;
 118                 rgb[pixel_ptr++] = (pi1 >> 3) & 0x01;
 119                 rgb[pixel_ptr++] = (pi1 >> 2) & 0x01;
 120                 rgb[pixel_ptr++] = (pi1 >> 1) & 0x01;
 121                 rgb[pixel_ptr++] =  pi1       & 0x01;
 122             }
 123         } else {
 124             /* copy the same pixel directly to output 2 times */
 125             rle_code *= 2;
 126             CHECK_PIXEL_PTR(rle_code * 8);
 127
 128             while (rle_code--) {
 129                 int x = bytestream2_get_byte(&s->g);
 130                 rgb[pixel_ptr++] = (x >> 7) & 0x01;
 131                 rgb[pixel_ptr++] = (x >> 6) & 0x01;
 132                 rgb[pixel_ptr++] = (x >> 5) & 0x01;
 133                 rgb[pixel_ptr++] = (x >> 4) & 0x01;
 134                 rgb[pixel_ptr++] = (x >> 3) & 0x01;
 135                 rgb[pixel_ptr++] = (x >> 2) & 0x01;
 136                 rgb[pixel_ptr++] = (x >> 1) & 0x01;
 137                 rgb[pixel_ptr++] =  x       & 0x01;
 138             }
 139         }
 140     }
 141 }
 142
 143 static inline void qtrle_decode_2n4bpp(QtrleContext *s, int row_ptr,
 144                                        int lines_to_change, int bpp)
 145 {
 146     int rle_code, i;
 147     int pixel_ptr;
 148     int row_inc = s->frame->linesize[0];
 149     uint8_t pi[16];  /* 16 palette indices */
 150     uint8_t *rgb = s->frame->data[0];
 151     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
 152     int num_pixels = (bpp == 4) ? 8 : 16;
 153
 154     while (lines_to_change--) {
 155         pixel_ptr = row_ptr + (num_pixels * (bytestream2_get_byte(&s->g) - 1));
 156         CHECK_PIXEL_PTR(0);
 157
 158         while ((rle_code = (int8_t)bytestream2_get_byte(&s->g)) != -1) {
 159             if (bytestream2_get_bytes_left(&s->g) < 1)
 160                 return;
 161             if (rle_code == 0) {
 162                 /* there's another skip code in the stream */
 163                 pixel_ptr += (num_pixels * (bytestream2_get_byte(&s->g) - 1));
 164                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 165             } else if (rle_code < 0) {
 166                 /* decode the run length code */
 167                 rle_code = -rle_code;
 168                 /* get the next 4 bytes from the stream, treat them as palette
 169                  * indexes, and output them rle_code times */
 170                 for (i = num_pixels-1; i >= 0; i--) {
 171                     pi[num_pixels-1-i] = (bytestream2_peek_byte(&s->g) >> ((i*bpp) & 0x07)) & ((1<<bpp)-1);
 172                     bytestream2_skip(&s->g, ((i & ((num_pixels>>2)-1)) == 0));
 173                 }
 174                 CHECK_PIXEL_PTR(rle_code * num_pixels);
 175                 while (rle_code--) {
 176                     memcpy(&rgb[pixel_ptr], &pi, num_pixels);
 177                     pixel_ptr += num_pixels;
 178                 }
 179             } else {
 180                 /* copy the same pixel directly to output 4 times */
 181                 rle_code *= 4;
 182                 CHECK_PIXEL_PTR(rle_code*(num_pixels>>2));
 183                 while (rle_code--) {
 184                     if(bpp == 4) {
 185                         int x = bytestream2_get_byte(&s->g);
 186                         rgb[pixel_ptr++] = (x >> 4) & 0x0f;
 187                         rgb[pixel_ptr++] =  x       & 0x0f;
 188                     } else {
 189                         int x = bytestream2_get_byte(&s->g);
 190                         rgb[pixel_ptr++] = (x >> 6) & 0x03;
 191                         rgb[pixel_ptr++] = (x >> 4) & 0x03;
 192                         rgb[pixel_ptr++] = (x >> 2) & 0x03;
 193                         rgb[pixel_ptr++] =  x       & 0x03;
 194                     }
 195                 }
 196             }
 197         }
 198         row_ptr += row_inc;
 199     }
 200 }
 201
 202 static void qtrle_decode_8bpp(QtrleContext *s, int row_ptr, int lines_to_change)
 203 {
 204     int rle_code;
 205     int pixel_ptr;
 206     int row_inc = s->frame->linesize[0];
 207     uint8_t pi1, pi2, pi3, pi4;  /* 4 palette indexes */
 208     uint8_t *rgb = s->frame->data[0];
 209     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
 210
 211     while (lines_to_change--) {
 212         pixel_ptr = row_ptr + (4 * (bytestream2_get_byte(&s->g) - 1));
 213         CHECK_PIXEL_PTR(0);
 214
 215         while ((rle_code = (int8_t)bytestream2_get_byte(&s->g)) != -1) {
 216             if (bytestream2_get_bytes_left(&s->g) < 1)
 217                 return;
 218             if (rle_code == 0) {
 219                 /* there's another skip code in the stream */
 220                 pixel_ptr += (4 * (bytestream2_get_byte(&s->g) - 1));
 221                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 222             } else if (rle_code < 0) {
 223                 /* decode the run length code */
 224                 rle_code = -rle_code;
 225                 /* get the next 4 bytes from the stream, treat them as palette
 226                  * indexes, and output them rle_code times */
 227                 pi1 = bytestream2_get_byte(&s->g);
 228                 pi2 = bytestream2_get_byte(&s->g);
 229                 pi3 = bytestream2_get_byte(&s->g);
 230                 pi4 = bytestream2_get_byte(&s->g);
 231
 232                 CHECK_PIXEL_PTR(rle_code * 4);
 233
 234                 while (rle_code--) {
 235                     rgb[pixel_ptr++] = pi1;
 236                     rgb[pixel_ptr++] = pi2;
 237                     rgb[pixel_ptr++] = pi3;
 238                     rgb[pixel_ptr++] = pi4;
 239                 }
 240             } else {
 241                 /* copy the same pixel directly to output 4 times */
 242                 rle_code *= 4;
 243                 CHECK_PIXEL_PTR(rle_code);
 244
 245                 bytestream2_get_buffer(&s->g, &rgb[pixel_ptr], rle_code);
 246                 pixel_ptr += rle_code;
 247             }
 248         }
 249         row_ptr += row_inc;
 250     }
 251 }
 252
 253 static void qtrle_decode_16bpp(QtrleContext *s, int row_ptr, int lines_to_change)
 254 {
 255     int rle_code;
 256     int pixel_ptr;
 257     int row_inc = s->frame->linesize[0];
 258     uint16_t rgb16;
 259     uint8_t *rgb = s->frame->data[0];
 260     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
 261
 262     while (lines_to_change--) {
 263         pixel_ptr = row_ptr + (bytestream2_get_byte(&s->g) - 1) * 2;
 264         CHECK_PIXEL_PTR(0);
 265
 266         while ((rle_code = (int8_t)bytestream2_get_byte(&s->g)) != -1) {
 267             if (bytestream2_get_bytes_left(&s->g) < 1)
 268                 return;
 269             if (rle_code == 0) {
 270                 /* there's another skip code in the stream */
 271                 pixel_ptr += (bytestream2_get_byte(&s->g) - 1) * 2;
 272                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 273             } else if (rle_code < 0) {
 274                 /* decode the run length code */
 275                 rle_code = -rle_code;
 276                 rgb16 = bytestream2_get_be16(&s->g);
 277
 278                 CHECK_PIXEL_PTR(rle_code * 2);
 279
 280                 while (rle_code--) {
 281                     *(uint16_t *)(&rgb[pixel_ptr]) = rgb16;
 282                     pixel_ptr += 2;
 283                 }
 284             } else {
 285                 CHECK_PIXEL_PTR(rle_code * 2);
 286
 287                 /* copy pixels directly to output */
 288                 while (rle_code--) {
 289                     rgb16 = bytestream2_get_be16(&s->g);
 290                     *(uint16_t *)(&rgb[pixel_ptr]) = rgb16;
 291                     pixel_ptr += 2;
 292                 }
 293             }
 294         }
 295         row_ptr += row_inc;
 296     }
 297 }
 298
 299 static void qtrle_decode_24bpp(QtrleContext *s, int row_ptr, int lines_to_change)
 300 {
 301     int rle_code, rle_code_half;
 302     int pixel_ptr;
 303     int row_inc = s->frame->linesize[0];
 304     uint8_t b;
 305     uint16_t rg;
 306     uint8_t *rgb = s->frame->data[0];
 307     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
 308
 309     while (lines_to_change--) {
 310         pixel_ptr = row_ptr + (bytestream2_get_byte(&s->g) - 1) * 3;
 311         CHECK_PIXEL_PTR(0);
 312
 313         while ((rle_code = (int8_t)bytestream2_get_byte(&s->g)) != -1) {
 314             if (bytestream2_get_bytes_left(&s->g) < 1)
 315                 return;
 316             if (rle_code == 0) {
 317                 /* there's another skip code in the stream */
 318                 pixel_ptr += (bytestream2_get_byte(&s->g) - 1) * 3;
 319                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 320             } else if (rle_code < 0) {
 321                 /* decode the run length code */
 322                 rle_code = -rle_code;
 323                 rg = bytestream2_get_ne16(&s->g);
 324                 b = bytestream2_get_byte(&s->g);
 325
 326                 CHECK_PIXEL_PTR(rle_code * 3);
 327
 328                 while (rle_code--) {
 329                     AV_WN16(rgb + pixel_ptr, rg);
 330                     rgb[pixel_ptr + 2] = b;
 331                     pixel_ptr += 3;
 332                 }
 333             } else {
 334                 CHECK_PIXEL_PTR(rle_code * 3);
 335
 336                 rle_code_half = rle_code / 2;
 337
 338                 while (rle_code_half--) { /* copy 2 raw rgb value at the same time */
 339                     AV_WN32(rgb + pixel_ptr, bytestream2_get_ne32(&s->g)); /* rgbr */
 340                     AV_WN16(rgb + pixel_ptr + 4, bytestream2_get_ne16(&s->g)); /* rgbr */
 341                     pixel_ptr += 6;
 342                 }
 343
 344                 if (rle_code % 2 != 0){ /* not even raw value */
 345                     AV_WN16(rgb + pixel_ptr, bytestream2_get_ne16(&s->g));
 346                     rgb[pixel_ptr + 2] = bytestream2_get_byte(&s->g);
 347                     pixel_ptr += 3;
 348                 }
 349             }
 350         }
 351         row_ptr += row_inc;
 352     }
 353 }
 354
 355 static void qtrle_decode_32bpp(QtrleContext *s, int row_ptr, int lines_to_change)
 356 {
 357     int rle_code, rle_code_half;
 358     int pixel_ptr;
 359     int row_inc = s->frame->linesize[0];
 360     unsigned int argb;
 361     uint8_t *rgb = s->frame->data[0];
 362     int pixel_limit = s->frame->linesize[0] * s->avctx->height;
 363
 364     while (lines_to_change--) {
 365         pixel_ptr = row_ptr + (bytestream2_get_byte(&s->g) - 1) * 4;
 366         CHECK_PIXEL_PTR(0);
 367
 368         while ((rle_code = (int8_t)bytestream2_get_byte(&s->g)) != -1) {
 369             if (bytestream2_get_bytes_left(&s->g) < 1)
 370                 return;
 371             if (rle_code == 0) {
 372                 /* there's another skip code in the stream */
 373                 pixel_ptr += (bytestream2_get_byte(&s->g) - 1) * 4;
 374                 CHECK_PIXEL_PTR(0);  /* make sure pixel_ptr is positive */
 375             } else if (rle_code < 0) {
 376                 /* decode the run length code */
 377                 rle_code = -rle_code;
 378                 argb = bytestream2_get_ne32(&s->g);
 379
 380                 CHECK_PIXEL_PTR(rle_code * 4);
 381
 382                 while (rle_code--) {
 383                     AV_WN32A(rgb + pixel_ptr, argb);
 384                     pixel_ptr += 4;
 385                 }
 386             } else {
 387                 CHECK_PIXEL_PTR(rle_code * 4);
 388
 389                 /* copy pixels directly to output */
 390                 rle_code_half = rle_code / 2;
 391                 while (rle_code_half--) { /* copy 2 argb raw value at the same time */
 392                     AV_WN64(rgb + pixel_ptr, bytestream2_get_ne64(&s->g));
 393                     pixel_ptr += 8;
 394                 }
 395
 396                 if (rle_code % 2 != 0){ /* not even raw value */
 397                     AV_WN32A(rgb + pixel_ptr, bytestream2_get_ne32(&s->g));
 398                     pixel_ptr += 4;
 399                 }
 400             }
 401         }
 402         row_ptr += row_inc;
 403     }
 404 }
 405
 406 static av_cold int qtrle_decode_init(AVCodecContext *avctx)
 407 {
 408     QtrleContext *s = avctx->priv_data;
 409
 410     s->avctx = avctx;
 411     switch (avctx->bits_per_coded_sample) {
 412     case 1:
 413     case 2:
 414     case 4:
 415     case 8:
 416     case 33:
 417     case 34:
 418     case 36:
 419     case 40:
 420         avctx->pix_fmt = AV_PIX_FMT_PAL8;
 421         break;
 422
 423     case 16:
 424         avctx->pix_fmt = AV_PIX_FMT_RGB555;
 425         break;
 426
 427     case 24:
 428         avctx->pix_fmt = AV_PIX_FMT_RGB24;
 429         break;
 430
 431     case 32:
 432         avctx->pix_fmt = AV_PIX_FMT_ARGB;
 433         break;
 434
 435     default:
 436         av_log (avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n",
 437             avctx->bits_per_coded_sample);
 438         return AVERROR_INVALIDDATA;
 439     }
 440
 441     s->frame = av_frame_alloc();
 442     if (!s->frame)
 443         return AVERROR(ENOMEM);
 444
 445     return 0;
 446 }
 447
 448 static int qtrle_decode_frame(AVCodecContext *avctx,
 449                               void *data, int *got_frame,
 450                               AVPacket *avpkt)
 451 {
 452     QtrleContext *s = avctx->priv_data;
 453     int header, start_line;
 454     int height, row_ptr;
 455     int has_palette = 0;
 456     int duplicate = 0;
 457     int ret, size;
 458
 459     bytestream2_init(&s->g, avpkt->data, avpkt->size);
 460
 461     /* check if this frame is even supposed to change */
 462     if (avpkt->size < 8) {
 463         duplicate = 1;
 464         goto done;
 465     }
 466
 467     /* start after the chunk size */
 468     size = bytestream2_get_be32(&s->g) & 0x3FFFFFFF;
 469     if (size - avpkt->size >  size * (int64_t)avctx->discard_damaged_percentage / 100)
 470         return AVERROR_INVALIDDATA;
 471
 472
 473     /* fetch the header */
 474     header = bytestream2_get_be16(&s->g);
 475
 476     /* if a header is present, fetch additional decoding parameters */
 477     if (header & 0x0008) {
 478         if (avpkt->size < 14) {
 479             duplicate = 1;
 480             goto done;
 481         }
 482         start_line = bytestream2_get_be16(&s->g);
 483         bytestream2_skip(&s->g, 2);
 484         height     = bytestream2_get_be16(&s->g);
 485         bytestream2_skip(&s->g, 2);
 486         if (height > s->avctx->height - start_line) {
 487             duplicate = 1;
 488             goto done;
 489         }
 490     } else {
 491         start_line = 0;
 492         height     = s->avctx->height;
 493     }
 494     if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0)
 495         return ret;
 496
 497     row_ptr = s->frame->linesize[0] * start_line;
 498
 499     switch (avctx->bits_per_coded_sample) {
 500     case 1:
 501     case 33:
 502         qtrle_decode_1bpp(s, row_ptr, height);
 503         has_palette = 1;
 504         break;
 505
 506     case 2:
 507     case 34:
 508         qtrle_decode_2n4bpp(s, row_ptr, height, 2);
 509         has_palette = 1;
 510         break;
 511
 512     case 4:
 513     case 36:
 514         qtrle_decode_2n4bpp(s, row_ptr, height, 4);
 515         has_palette = 1;
 516         break;
 517
 518     case 8:
 519     case 40:
 520         qtrle_decode_8bpp(s, row_ptr, height);
 521         has_palette = 1;
 522         break;
 523
 524     case 16:
 525         qtrle_decode_16bpp(s, row_ptr, height);
 526         break;
 527
 528     case 24:
 529         qtrle_decode_24bpp(s, row_ptr, height);
 530         break;
 531
 532     case 32:
 533         qtrle_decode_32bpp(s, row_ptr, height);
 534         break;
 535
 536     default:
 537         av_log (s->avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n",
 538             avctx->bits_per_coded_sample);
 539         break;
 540     }
 541
 542     if(has_palette) {
 543         s->frame->palette_has_changed = ff_copy_palette(s->pal, avpkt, avctx);
 544
 545         /* make the palette available on the way out */
 546         memcpy(s->frame->data[1], s->pal, AVPALETTE_SIZE);
 547     }
 548
 549 done:
 550     if (!s->frame->data[0])
 551         return AVERROR_INVALIDDATA;
 552     if (duplicate) {
 553         // ff_reget_buffer() isn't needed when frames don't change, so just update
 554         // frame props.
 555         ret = ff_decode_frame_props(avctx, s->frame);
 556         if (ret < 0)
 557             return ret;
 558     }
 559
 560     if ((ret = av_frame_ref(data, s->frame)) < 0)
 561         return ret;
 562     *got_frame      = 1;
 563
 564     /* always report that the buffer was completely consumed */
 565     return avpkt->size;
 566 }
 567
 568 static void qtrle_decode_flush(AVCodecContext *avctx)
 569 {
 570     QtrleContext *s = avctx->priv_data;
 571
 572     av_frame_unref(s->frame);
 573 }
 574
 575 static av_cold int qtrle_decode_end(AVCodecContext *avctx)
 576 {
 577     QtrleContext *s = avctx->priv_data;
 578
 579     av_frame_free(&s->frame);
 580
 581     return 0;
 582 }
 583
 584 AVCodec ff_qtrle_decoder = {
 585     .name           = "qtrle",
 586     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),
 587     .type           = AVMEDIA_TYPE_VIDEO,
 588     .id             = AV_CODEC_ID_QTRLE,
 589     .priv_data_size = sizeof(QtrleContext),
 590     .init           = qtrle_decode_init,
 591     .close          = qtrle_decode_end,
 592     .decode         = qtrle_decode_frame,
 593     .flush          = qtrle_decode_flush,
 594     .capabilities   = AV_CODEC_CAP_DR1,
 595 };