FFmpeg
qtrle.c
Go to the documentation of this file.
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 {
46 
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 
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 
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 
569 {
570  QtrleContext *s = avctx->priv_data;
571 
572  av_frame_unref(s->frame);
573 }
574 
576 {
577  QtrleContext *s = avctx->priv_data;
578 
579  av_frame_free(&s->frame);
580 
581  return 0;
582 }
583 
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),
591  .close = qtrle_decode_end,
594  .capabilities = AV_CODEC_CAP_DR1,
595  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
596 };
qtrle_decode_8bpp
static void qtrle_decode_8bpp(QtrleContext *s, int row_ptr, int lines_to_change)
Definition: qtrle.c:202
AVCodec
AVCodec.
Definition: codec.h:197
CHECK_PIXEL_PTR
#define CHECK_PIXEL_PTR(n)
Definition: qtrle.c:51
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
GetByteContext
Definition: bytestream.h:33
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
qtrle_decode_32bpp
static void qtrle_decode_32bpp(QtrleContext *s, int row_ptr, int lines_to_change)
Definition: qtrle.c:355
b
#define b
Definition: input.c:40
data
const char data[16]
Definition: mxf.c:143
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
bytestream2_get_ne64
#define bytestream2_get_ne64
Definition: bytestream.h:122
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
rgb
Definition: rpzaenc.c:59
qtrle_decode_16bpp
static void qtrle_decode_16bpp(QtrleContext *s, int row_ptr, int lines_to_change)
Definition: qtrle.c:253
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
ff_qtrle_decoder
const AVCodec ff_qtrle_decoder
Definition: qtrle.c:584
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
s
#define s(width, name)
Definition: cbs_vp9.c:257
decode.h
qtrle_decode_init
static av_cold int qtrle_decode_init(AVCodecContext *avctx)
Definition: qtrle.c:406
bytestream2_get_ne32
#define bytestream2_get_ne32
Definition: bytestream.h:121
QtrleContext::avctx
AVCodecContext * avctx
Definition: qtrle.c:44
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
bytestream2_get_buffer
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
QtrleContext::g
GetByteContext g
Definition: qtrle.c:47
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:327
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
bytestream2_get_ne16
#define bytestream2_get_ne16
Definition: bytestream.h:119
QtrleContext
Definition: qtrle.c:43
size
int size
Definition: twinvq_data.h:10344
header
static const uint8_t header[24]
Definition: sdr2.c:67
height
#define height
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1414
i
int i
Definition: input.c:406
qtrle_decode_frame
static int qtrle_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: qtrle.c:448
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:377
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:437
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:589
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
ff_reget_buffer
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.
Definition: decode.c:1755
ret
ret
Definition: filter_design.txt:187
QtrleContext::frame
AVFrame * frame
Definition: qtrle.c:45
ff_decode_frame_props
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1485
AVCodecContext
main external API structure.
Definition: avcodec.h:379
qtrle_decode_flush
static void qtrle_decode_flush(AVCodecContext *avctx)
Definition: qtrle.c:568
AVCodecContext::discard_damaged_percentage
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:1961
qtrle_decode_2n4bpp
static void qtrle_decode_2n4bpp(QtrleContext *s, int row_ptr, int lines_to_change, int bpp)
Definition: qtrle.c:143
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_CODEC_ID_QTRLE
@ AV_CODEC_ID_QTRLE
Definition: codec_id.h:105
QtrleContext::pal
uint32_t pal[256]
Definition: qtrle.c:48
qtrle_decode_end
static av_cold int qtrle_decode_end(AVCodecContext *avctx)
Definition: qtrle.c:575
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
qtrle_decode_24bpp
static void qtrle_decode_24bpp(QtrleContext *s, int row_ptr, int lines_to_change)
Definition: qtrle.c:299
qtrle_decode_1bpp
static void qtrle_decode_1bpp(QtrleContext *s, int row_ptr, int lines_to_change)
Definition: qtrle.c:58
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_WN64
#define AV_WN64(p, v)
Definition: intreadwrite.h:380
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_copy_palette
int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
Check whether the side-data of src contains a palette of size AVPALETTE_SIZE; if so,...
Definition: decode.c:1850
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:372