FFmpeg: libavcodec/rawdec.c Source File

FFmpeg
rawdec.c
Go to the documentation of this file.
1 /*
2  * Raw Video Decoder
3  * Copyright (c) 2001 Fabrice Bellard
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  * Raw Video Decoder
25  */
26 
27 #include "avcodec.h"
28 #include "bswapdsp.h"
29 #include "codec_internal.h"
30 #include "decode.h"
31 #include "get_bits.h"
32 #include "raw.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/buffer.h"
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/mem.h"
38 #include "libavutil/opt.h"
39 
40  typedef struct RawVideoContext {
41   AVClass *av_class;
42   AVBufferRef *palette;
43   int frame_size; /* size of the frame in bytes */
44   int flip;
45   int is_1_2_4_8_bpp; // 1, 2, 4 and 8 bpp in avi/mov, 1 and 8 bpp in nut
46   int is_mono;
47   int is_pal8;
48   int is_nut_mono;
49   int is_nut_pal8;
50   int is_yuv2;
51   int is_lt_16bpp; // 16bpp pixfmt and bits_per_coded_sample < 16
52   int tff;
53 
54   BswapDSPContext bbdsp;
55   void *bitstream_buf;
56   unsigned int bitstream_buf_size;
57 } RawVideoContext;
58 
59  static const AVOption options[]={
60 {"top", "top field first", offsetof(RawVideoContext, tff), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM|AV_OPT_FLAG_VIDEO_PARAM},
61 {NULL}
62 };
63 
64  static const AVClass rawdec_class = {
65  .class_name = "rawdec",
66  .option = options,
67  .version = LIBAVUTIL_VERSION_INT,
68 };
69 
70  static av_cold int raw_init_decoder(AVCodecContext *avctx)
71 {
72  RawVideoContext *context = avctx->priv_data;
73  const AVPixFmtDescriptor *desc;
74 
75  ff_bswapdsp_init(&context->bbdsp);
76 
77  if ( avctx->codec_tag == MKTAG('r','a','w',' ')
78  || avctx->codec_tag == MKTAG('N','O','1','6'))
79  avctx->pix_fmt = avpriv_pix_fmt_find(PIX_FMT_LIST_MOV,
80  avctx->bits_per_coded_sample);
81  else if (avctx->codec_tag == MKTAG('W', 'R', 'A', 'W'))
82  avctx->pix_fmt = avpriv_pix_fmt_find(PIX_FMT_LIST_AVI,
83  avctx->bits_per_coded_sample);
84  else if (avctx->codec_tag && (avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0))
85  avctx->pix_fmt = avpriv_pix_fmt_find(PIX_FMT_LIST_RAW, avctx->codec_tag);
86  else if (avctx->pix_fmt == AV_PIX_FMT_NONE && avctx->bits_per_coded_sample)
87  avctx->pix_fmt = avpriv_pix_fmt_find(PIX_FMT_LIST_AVI,
88  avctx->bits_per_coded_sample);
89 
90  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
91  if (!desc) {
92  av_log(avctx, AV_LOG_ERROR, "Invalid pixel format.\n");
93  return AVERROR(EINVAL);
94  }
95 
96  if (desc->flags & AV_PIX_FMT_FLAG_PAL) {
97  context->palette = av_buffer_alloc(AVPALETTE_SIZE);
98  if (!context->palette)
99  return AVERROR(ENOMEM);
100  memset(context->palette->data, 0, AVPALETTE_SIZE);
101  if (avctx->bits_per_coded_sample == 1)
102  memset(context->palette->data, 0xff, 4);
103  }
104 
105  if ((avctx->extradata_size >= 9 &&
106  !memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
107  avctx->codec_tag == MKTAG('c','y','u','v') ||
108  avctx->codec_tag == MKTAG(3, 0, 0, 0) ||
109  avctx->codec_tag == MKTAG('W','R','A','W'))
110  context->flip = 1;
111 
112  if (avctx->pix_fmt == AV_PIX_FMT_MONOWHITE ||
113  avctx->pix_fmt == AV_PIX_FMT_MONOBLACK)
114  context->is_mono = 1;
115  else if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
116  context->is_pal8 = 1;
117 
118  if (avctx->codec_tag == MKTAG('B','1','W','0') ||
119  avctx->codec_tag == MKTAG('B','0','W','1'))
120  context->is_nut_mono = 1;
121  else if (avctx->codec_tag == MKTAG('P','A','L',8))
122  context->is_nut_pal8 = 1;
123 
124  if (avctx->codec_tag == AV_RL32("yuv2") &&
125  avctx->pix_fmt == AV_PIX_FMT_YUYV422)
126  context->is_yuv2 = 1;
127 
128  return 0;
129 }
130 
131  static void flip(AVCodecContext *avctx, AVFrame *frame)
132 {
133  frame->data[0] += frame->linesize[0] * (avctx->height - 1);
134  frame->linesize[0] *= -1;
135 }
136 
137 /*
138  * Scale sample to 16-bit resolution
139  */
140  #define SCALE16(x, bits) (((x) << (16 - (bits))) | ((x) >> (2 * (bits) - 16)))
141 
142 /**
143  * Scale buffer to 16 bits per coded sample resolution
144  */
145  #define MKSCALE16(name, r16, w16) \
146 static void name(AVCodecContext *avctx, uint8_t * dst, const uint8_t *buf, int buf_size, int packed) \
147 { \
148  int i; \
149  if (!packed) { \
150  for (i = 0; i + 1 < buf_size; i += 2) \
151  w16(dst + i, SCALE16(r16(buf + i), avctx->bits_per_coded_sample)); \
152  } else { \
153  GetBitContext gb; \
154  init_get_bits(&gb, buf, buf_size * 8); \
155  for (i = 0; i < avctx->width * avctx->height; i++) { \
156  int sample = get_bits(&gb, avctx->bits_per_coded_sample); \
157  w16(dst + i*2, SCALE16(sample, avctx->bits_per_coded_sample)); \
158  } \
159  } \
160 }
161 
162 MKSCALE16(scale16be, AV_RB16, AV_WB16)
163 MKSCALE16(scale16le, AV_RL16, AV_WL16)
164 
165  static int raw_decode(AVCodecContext *avctx, AVFrame *frame,
166  int *got_frame, AVPacket *avpkt)
167 {
168  const AVPixFmtDescriptor *desc;
169  RawVideoContext *context = avctx->priv_data;
170  const uint8_t *buf = avpkt->data;
171  int buf_size = avpkt->size;
172  int linesize_align = 4;
173  int stride;
174  int res, len;
175  int need_copy;
176 
177  if (avctx->width <= 0) {
178  av_log(avctx, AV_LOG_ERROR, "width is not set\n");
179  return AVERROR_INVALIDDATA;
180  }
181  if (avctx->height <= 0) {
182  av_log(avctx, AV_LOG_ERROR, "height is not set\n");
183  return AVERROR_INVALIDDATA;
184  }
185 
186  if (context->is_nut_mono)
187  stride = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
188  else if (context->is_nut_pal8)
189  stride = avctx->width;
190  else
191  stride = avpkt->size / avctx->height;
192 
193  av_log(avctx, AV_LOG_DEBUG, "PACKET SIZE: %d, STRIDE: %d\n", avpkt->size, stride);
194 
195  if (stride == 0 || avpkt->size < stride * avctx->height) {
196  av_log(avctx, AV_LOG_ERROR, "Packet too small (%d)\n", avpkt->size);
197  return AVERROR_INVALIDDATA;
198  }
199 
200  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
201 
202  if ((avctx->bits_per_coded_sample == 8 || avctx->bits_per_coded_sample == 4 ||
203  avctx->bits_per_coded_sample == 2 || avctx->bits_per_coded_sample == 1 ||
204  (avctx->bits_per_coded_sample == 0 && (context->is_nut_pal8 || context->is_mono)) ) &&
205  (context->is_mono || context->is_pal8) &&
206  (!avctx->codec_tag || avctx->codec_tag == MKTAG('r','a','w',' ') ||
207  context->is_nut_mono || context->is_nut_pal8)) {
208  context->is_1_2_4_8_bpp = 1;
209  if (context->is_mono) {
210  int row_bytes = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
211  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
212  FFALIGN(row_bytes, 16) * 8,
213  avctx->height, 1);
214  } else
215  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
216  FFALIGN(avctx->width, 16),
217  avctx->height, 1);
218  } else {
219  context->is_lt_16bpp = av_get_bits_per_pixel(desc) == 16 && avctx->bits_per_coded_sample > 8 && avctx->bits_per_coded_sample < 16;
220  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt, avctx->width,
221  avctx->height, 1);
222  }
223  if (context->frame_size < 0)
224  return context->frame_size;
225 
226  need_copy = !avpkt->buf || context->is_1_2_4_8_bpp || context->is_yuv2 || context->is_lt_16bpp;
227 
228  res = ff_decode_frame_props(avctx, frame);
229  if (res < 0)
230  return res;
231 
232  if (context->tff >= 0) {
233  frame->flags |= AV_FRAME_FLAG_INTERLACED;
234  if (context->tff == 1)
235  frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
236  }
237 
238  if ((res = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
239  return res;
240 
241  if (need_copy)
242  frame->buf[0] = av_buffer_alloc(FFMAX(context->frame_size, buf_size));
243  else
244  frame->buf[0] = av_buffer_ref(avpkt->buf);
245  if (!frame->buf[0])
246  return AVERROR(ENOMEM);
247 
248  // 1, 2, 4 and 8 bpp in avi/mov, 1 and 8 bpp in nut
249  if (context->is_1_2_4_8_bpp) {
250  int i, j, row_pix = 0;
251  uint8_t *dst = frame->buf[0]->data;
252  buf_size = context->frame_size - (context->is_pal8 ? AVPALETTE_SIZE : 0);
253  if (avctx->bits_per_coded_sample == 8 || context->is_nut_pal8 || context->is_mono) {
254  int pix_per_byte = context->is_mono ? 8 : 1;
255  for (i = 0, j = 0; j < buf_size && i<avpkt->size; i++, j++) {
256  dst[j] = buf[i];
257  row_pix += pix_per_byte;
258  if (row_pix >= avctx->width) {
259  i += stride - (i % stride) - 1;
260  j += 16 - (j % 16) - 1;
261  row_pix = 0;
262  }
263  }
264  } else if (avctx->bits_per_coded_sample == 4) {
265  for (i = 0, j = 0; 2 * j + 1 < buf_size && i<avpkt->size; i++, j++) {
266  dst[2 * j + 0] = buf[i] >> 4;
267  dst[2 * j + 1] = buf[i] & 15;
268  row_pix += 2;
269  if (row_pix >= avctx->width) {
270  i += stride - (i % stride) - 1;
271  j += 8 - (j % 8) - 1;
272  row_pix = 0;
273  }
274  }
275  } else if (avctx->bits_per_coded_sample == 2) {
276  for (i = 0, j = 0; 4 * j + 3 < buf_size && i<avpkt->size; i++, j++) {
277  dst[4 * j + 0] = buf[i] >> 6;
278  dst[4 * j + 1] = buf[i] >> 4 & 3;
279  dst[4 * j + 2] = buf[i] >> 2 & 3;
280  dst[4 * j + 3] = buf[i] & 3;
281  row_pix += 4;
282  if (row_pix >= avctx->width) {
283  i += stride - (i % stride) - 1;
284  j += 4 - (j % 4) - 1;
285  row_pix = 0;
286  }
287  }
288  } else {
289  av_assert0(avctx->bits_per_coded_sample == 1);
290  for (i = 0, j = 0; 8 * j + 7 < buf_size && i<avpkt->size; i++, j++) {
291  dst[8 * j + 0] = buf[i] >> 7;
292  dst[8 * j + 1] = buf[i] >> 6 & 1;
293  dst[8 * j + 2] = buf[i] >> 5 & 1;
294  dst[8 * j + 3] = buf[i] >> 4 & 1;
295  dst[8 * j + 4] = buf[i] >> 3 & 1;
296  dst[8 * j + 5] = buf[i] >> 2 & 1;
297  dst[8 * j + 6] = buf[i] >> 1 & 1;
298  dst[8 * j + 7] = buf[i] & 1;
299  row_pix += 8;
300  if (row_pix >= avctx->width) {
301  i += stride - (i % stride) - 1;
302  j += 2 - (j % 2) - 1;
303  row_pix = 0;
304  }
305  }
306  }
307  linesize_align = 16;
308  buf = dst;
309  } else if (context->is_lt_16bpp) {
310  uint8_t *dst = frame->buf[0]->data;
311  int packed = (avctx->codec_tag & 0xFFFFFF) == MKTAG('B','I','T', 0);
312  int swap = avctx->codec_tag >> 24;
313 
314  if (packed && swap) {
315  av_fast_padded_malloc(&context->bitstream_buf, &context->bitstream_buf_size, buf_size);
316  if (!context->bitstream_buf)
317  return AVERROR(ENOMEM);
318  if (swap == 16)
319  context->bbdsp.bswap16_buf(context->bitstream_buf, (const uint16_t*)buf, buf_size / 2);
320  else if (swap == 32)
321  context->bbdsp.bswap_buf(context->bitstream_buf, (const uint32_t*)buf, buf_size / 4);
322  else
323  return AVERROR_INVALIDDATA;
324  buf = context->bitstream_buf;
325  }
326 
327  if (desc->flags & AV_PIX_FMT_FLAG_BE)
328  scale16be(avctx, dst, buf, buf_size, packed);
329  else
330  scale16le(avctx, dst, buf, buf_size, packed);
331 
332  buf = dst;
333  } else if (need_copy) {
334  memcpy(frame->buf[0]->data, buf, buf_size);
335  buf = frame->buf[0]->data;
336  }
337 
338  if (avctx->codec_tag == MKTAG('A', 'V', '1', 'x') ||
339  avctx->codec_tag == MKTAG('A', 'V', 'u', 'p'))
340  buf += buf_size - context->frame_size;
341 
342  len = context->frame_size - (avctx->pix_fmt==AV_PIX_FMT_PAL8 ? AVPALETTE_SIZE : 0);
343  if (buf_size < len && ((avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0) || !need_copy)) {
344  av_log(avctx, AV_LOG_ERROR, "Invalid buffer size, packet size %d < expected frame_size %d\n", buf_size, len);
345  av_buffer_unref(&frame->buf[0]);
346  return AVERROR(EINVAL);
347  }
348 
349  if ((res = av_image_fill_arrays(frame->data, frame->linesize,
350  buf, avctx->pix_fmt,
351  avctx->width, avctx->height, 1)) < 0) {
352  av_buffer_unref(&frame->buf[0]);
353  return res;
354  }
355 
356  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
357  int ret;
358 
359  if (!context->palette)
360  context->palette = av_buffer_alloc(AVPALETTE_SIZE);
361  if (!context->palette) {
362  av_buffer_unref(&frame->buf[0]);
363  return AVERROR(ENOMEM);
364  }
365  ret = av_buffer_make_writable(&context->palette);
366  if (ret < 0) {
367  av_buffer_unref(&frame->buf[0]);
368  return ret;
369  }
370 
371  if (!ff_copy_palette(context->palette->data, avpkt, avctx) && context->is_nut_pal8) {
372  int vid_size = avctx->width * avctx->height;
373  int pal_size = avpkt->size - vid_size;
374 
375  if (avpkt->size > vid_size && pal_size <= AVPALETTE_SIZE) {
376  const uint8_t *pal = avpkt->data + vid_size;
377  memcpy(context->palette->data, pal, pal_size);
378  }
379  }
380  }
381 
382  if ((avctx->pix_fmt==AV_PIX_FMT_RGB24 ||
383  avctx->pix_fmt==AV_PIX_FMT_BGR24 ||
384  avctx->pix_fmt==AV_PIX_FMT_GRAY8 ||
385  avctx->pix_fmt==AV_PIX_FMT_RGB555LE ||
386  avctx->pix_fmt==AV_PIX_FMT_RGB555BE ||
387  avctx->pix_fmt==AV_PIX_FMT_RGB565LE ||
388  avctx->pix_fmt==AV_PIX_FMT_MONOWHITE ||
389  avctx->pix_fmt==AV_PIX_FMT_MONOBLACK ||
390  avctx->pix_fmt==AV_PIX_FMT_PAL8) &&
391  FFALIGN(frame->linesize[0], linesize_align) * avctx->height <= buf_size)
392  frame->linesize[0] = FFALIGN(frame->linesize[0], linesize_align);
393 
394  if (avctx->pix_fmt == AV_PIX_FMT_NV12 && avctx->codec_tag == MKTAG('N', 'V', '1', '2') &&
395  FFALIGN(frame->linesize[0], linesize_align) * avctx->height +
396  FFALIGN(frame->linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
397  int la0 = FFALIGN(frame->linesize[0], linesize_align);
398  frame->data[1] += (la0 - frame->linesize[0]) * avctx->height;
399  frame->linesize[0] = la0;
400  frame->linesize[1] = FFALIGN(frame->linesize[1], linesize_align);
401  }
402 
403  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 && buf_size < context->frame_size) {
404  frame->buf[1] = av_buffer_ref(context->palette);
405  if (!frame->buf[1]) {
406  av_buffer_unref(&frame->buf[0]);
407  return AVERROR(ENOMEM);
408  }
409  frame->data[1] = frame->buf[1]->data;
410  }
411 
412  if (avctx->pix_fmt == AV_PIX_FMT_BGR24 &&
413  ((frame->linesize[0] + 3) & ~3) * avctx->height <= buf_size)
414  frame->linesize[0] = (frame->linesize[0] + 3) & ~3;
415 
416  if (context->flip)
417  flip(avctx, frame);
418 
419  if (avctx->codec_tag == MKTAG('Y', 'V', '1', '2') ||
420  avctx->codec_tag == MKTAG('Y', 'V', '1', '6') ||
421  avctx->codec_tag == MKTAG('Y', 'V', '2', '4') ||
422  avctx->codec_tag == MKTAG('Y', 'V', 'U', '9'))
423  FFSWAP(uint8_t *, frame->data[1], frame->data[2]);
424 
425  if (avctx->codec_tag == AV_RL32("I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
426  frame->data[1] = frame->data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
427  frame->data[2] = frame->data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
428  }
429 
430  if (avctx->codec_tag == AV_RL32("yuv2") &&
431  avctx->pix_fmt == AV_PIX_FMT_YUYV422) {
432  int x, y;
433  uint8_t *line = frame->data[0];
434  for (y = 0; y < avctx->height; y++) {
435  for (x = 0; x < avctx->width; x++)
436  line[2 * x + 1] ^= 0x80;
437  line += frame->linesize[0];
438  }
439  }
440 
441  if (avctx->codec_tag == AV_RL32("b64a") &&
442  avctx->pix_fmt == AV_PIX_FMT_RGBA64BE) {
443  uint8_t *dst = frame->data[0];
444  uint64_t v;
445  int x, y;
446  for (y = 0; y < avctx->height; y++) {
447  for (x = 0; x >> 3 < avctx->width; x += 8) {
448  v = AV_RB64(&dst[x]);
449  AV_WB64(&dst[x], v << 16 | v >> 48);
450  }
451  dst += frame->linesize[0];
452  }
453  }
454 
455  if (avctx->field_order > AV_FIELD_PROGRESSIVE) { /* we have interlaced material flagged in container */
456  frame->flags |= AV_FRAME_FLAG_INTERLACED;
457  if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
458  frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
459  }
460 
461  *got_frame = 1;
462  return buf_size;
463 }
464 
465  static av_cold int raw_close_decoder(AVCodecContext *avctx)
466 {
467  RawVideoContext *context = avctx->priv_data;
468 
469  av_buffer_unref(&context->palette);
470  av_freep(&context->bitstream_buf);
471  return 0;
472 }
473 
474  const FFCodec ff_rawvideo_decoder = {
475  .p.name = "rawvideo",
476  CODEC_LONG_NAME("raw video"),
477  .p.type = AVMEDIA_TYPE_VIDEO,
478  .p.id = AV_CODEC_ID_RAWVIDEO,
479  .priv_data_size = sizeof(RawVideoContext),
480  .init = raw_init_decoder,
481  .close = raw_close_decoder,
482  FF_CODEC_DECODE_CB(raw_decode),
483  .p.priv_class = &rawdec_class,
484  .p.capabilities = AV_CODEC_CAP_PARAM_CHANGE,
485 };
raw_init_decoder
static av_cold int raw_init_decoder(AVCodecContext *avctx)
Definition: rawdec.c:70
RawVideoContext::frame_size
int frame_size
Definition: rawdec.c:43
bswapdsp.h
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
opt.h
raw_decode
static int raw_decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: rawdec.c:165
RawVideoContext::flip
int flip
Definition: rawdec.c:44
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:213
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
RawVideoContext::is_nut_mono
int is_nut_mono
Definition: rawdec.c:48
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:202
RawVideoContext::bbdsp
BswapDSPContext bbdsp
Definition: rawdec.c:54
RawVideoContext::bitstream_buf_size
unsigned int bitstream_buf_size
Definition: rawdec.c:56
AVOption
AVOption.
Definition: opt.h:429
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:82
FFCodec
Definition: codec_internal.h:127
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:3408
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AV_PIX_FMT_RGB555BE
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:114
AV_WB64
#define AV_WB64(p, v)
Definition: intreadwrite.h:429
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:655
close
static av_cold void close(AVCodecParserContext *s)
Definition: apv_parser.c:136
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:214
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:216
raw.h
avassert.h
RawVideoContext::is_lt_16bpp
int is_lt_16bpp
Definition: rawdec.c:51
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:106
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:515
options
static const AVOption options[]
Definition: rawdec.c:59
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:347
intreadwrite.h
frame_size
int frame_size
Definition: mxfenc.c:2487
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
decode.h
get_bits.h
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
PIX_FMT_LIST_AVI
@ PIX_FMT_LIST_AVI
Definition: raw.h:39
RawVideoContext::is_pal8
int is_pal8
Definition: rawdec.c:47
RawVideoContext
Definition: rawdec.c:40
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:113
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
NULL
#define NULL
Definition: coverity.c:32
RawVideoContext::is_1_2_4_8_bpp
int is_1_2_4_8_bpp
Definition: rawdec.c:45
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:401
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:74
RawVideoContext::palette
AVBufferRef * palette
Definition: rawdec.c:42
AV_PIX_FMT_MONOBLACK
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:83
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
options
Definition: swscale.c:43
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
RawVideoContext::is_yuv2
int is_yuv2
Definition: rawdec.c:50
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:550
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
RawVideoContext::bitstream_buf
void * bitstream_buf
Definition: rawdec.c:55
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:131
avpriv_pix_fmt_find
enum AVPixelFormat avpriv_pix_fmt_find(enum PixelFormatTagLists list, unsigned fourcc)
Definition: raw.c:78
av_image_fill_arrays
int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4], const uint8_t *src, enum AVPixelFormat pix_fmt, int width, int height, int align)
Setup the data pointers and linesizes based on the specified image parameters and the provided array.
Definition: imgutils.c:446
codec_internal.h
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
PIX_FMT_LIST_RAW
@ PIX_FMT_LIST_RAW
Definition: raw.h:38
av_buffer_make_writable
int av_buffer_make_writable(AVBufferRef **pbuf)
Create a writable reference from a given buffer reference, avoiding data copy if possible.
Definition: buffer.c:165
MKSCALE16
#define MKSCALE16(name, r16, w16)
Scale buffer to 16 bits per coded sample resolution.
Definition: rawdec.c:145
buffer.h
RawVideoContext::is_nut_pal8
int is_nut_pal8
Definition: rawdec.c:49
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:408
av_image_get_buffer_size
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters.
Definition: imgutils.c:466
line
Definition: graph2dot.c:48
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1546
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:115
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:514
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:53
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:358
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:116
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
ff_rawvideo_decoder
const FFCodec ff_rawvideo_decoder
Definition: rawdec.c:474
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:650
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
raw_close_decoder
static av_cold int raw_close_decoder(AVCodecContext *avctx)
Definition: rawdec.c:465
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
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:1570
AVCodecContext
main external API structure.
Definition: avcodec.h:431
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
rawdec_class
static const AVClass rawdec_class
Definition: rawdec.c:64
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:103
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:356
desc
const char * desc
Definition: libsvtav1.c:78
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
RawVideoContext::tff
int tff
Definition: rawdec.c:52
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:456
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:565
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
PIX_FMT_LIST_MOV
@ PIX_FMT_LIST_MOV
Definition: raw.h:40
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
imgutils.h
RawVideoContext::av_class
AVClass * av_class
Definition: rawdec.c:41
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
BswapDSPContext
Definition: bswapdsp.h:24
stride
#define stride
Definition: h264pred_template.c:536
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
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:2263
RawVideoContext::is_mono
int is_mono
Definition: rawdec.c:46
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:120
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
Generated on Tue Nov 18 2025 19:22:40 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /