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  int size;
544  const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
545 
546  if (pal && size == AVPALETTE_SIZE) {
547  s->frame->palette_has_changed = 1;
548  memcpy(s->pal, pal, AVPALETTE_SIZE);
549  } else if (pal) {
550  av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
551  }
552 
553  /* make the palette available on the way out */
554  memcpy(s->frame->data[1], s->pal, AVPALETTE_SIZE);
555  }
556 
557 done:
558  if (!s->frame->data[0])
559  return AVERROR_INVALIDDATA;
560  if (duplicate) {
561  // ff_reget_buffer() isn't needed when frames don't change, so just update
562  // frame props.
563  ret = ff_decode_frame_props(avctx, s->frame);
564  if (ret < 0)
565  return ret;
566  }
567 
568  if ((ret = av_frame_ref(data, s->frame)) < 0)
569  return ret;
570  *got_frame = 1;
571 
572  /* always report that the buffer was completely consumed */
573  return avpkt->size;
574 }
575 
577 {
578  QtrleContext *s = avctx->priv_data;
579 
580  av_frame_unref(s->frame);
581 }
582 
584 {
585  QtrleContext *s = avctx->priv_data;
586 
587  av_frame_free(&s->frame);
588 
589  return 0;
590 }
591 
593  .name = "qtrle",
594  .long_name = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),
595  .type = AVMEDIA_TYPE_VIDEO,
596  .id = AV_CODEC_ID_QTRLE,
597  .priv_data_size = sizeof(QtrleContext),
599  .close = qtrle_decode_end,
602  .capabilities = AV_CODEC_CAP_DR1,
603 };
static void qtrle_decode_2n4bpp(QtrleContext *s, int row_ptr, int lines_to_change, int bpp)
Definition: qtrle.c:143
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
GetByteContext g
Definition: qtrle.c:47
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AVFrame * frame
Definition: qtrle.c:45
int size
Definition: packet.h:364
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
static void qtrle_decode_flush(AVCodecContext *avctx)
Definition: qtrle.c:576
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1704
AVCodec.
Definition: codec.h:190
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
#define bytestream2_get_ne32
Definition: bytestream.h:121
uint8_t
#define av_cold
Definition: attributes.h:88
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
static void qtrle_decode_24bpp(QtrleContext *s, int row_ptr, int lines_to_change)
Definition: qtrle.c:299
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
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:456
AVCodecContext * avctx
Definition: qtrle.c:44
#define height
uint8_t * data
Definition: packet.h:363
static av_cold int qtrle_decode_init(AVCodecContext *avctx)
Definition: qtrle.c:406
static void qtrle_decode_1bpp(QtrleContext *s, int row_ptr, int lines_to_change)
Definition: qtrle.c:58
ptrdiff_t size
Definition: opengl_enc.c:100
static const uint8_t header[24]
Definition: sdr2.c:67
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1750
#define av_log(a,...)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: packet.h:46
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#define bytestream2_get_ne16
Definition: bytestream.h:119
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
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:1985
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
const char * name
Name of the codec implementation.
Definition: codec.h:197
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
#define b
Definition: input.c:41
#define bytestream2_get_ne64
Definition: bytestream.h:122
static void qtrle_decode_8bpp(QtrleContext *s, int row_ptr, int lines_to_change)
Definition: qtrle.c:202
#define s(width, name)
Definition: cbs_vp9.c:257
uint32_t pal[256]
Definition: qtrle.c:48
#define CHECK_PIXEL_PTR(n)
Definition: qtrle.c:51
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:2336
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
main external API structure.
Definition: avcodec.h:526
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:465
static void qtrle_decode_32bpp(QtrleContext *s, int row_ptr, int lines_to_change)
Definition: qtrle.c:355
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:566
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
common internal api header.
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
static int qtrle_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: qtrle.c:448
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:387
void * priv_data
Definition: avcodec.h:553
AVCodec ff_qtrle_decoder
Definition: qtrle.c:592
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
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
static void qtrle_decode_16bpp(QtrleContext *s, int row_ptr, int lines_to_change)
Definition: qtrle.c:253
static av_cold int qtrle_decode_end(AVCodecContext *avctx)
Definition: qtrle.c:583
This structure stores compressed data.
Definition: packet.h:340
Definition: rpzaenc.c:58
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int i
Definition: input.c:407
#define AV_WN64(p, v)
Definition: intreadwrite.h:380