FFmpeg
photocd.c
Go to the documentation of this file.
1 /*
2  * Kodak PhotoCD (a.k.a. ImagePac) image decoder
3  *
4  * Copyright (c) 1996-2002 Gerd Knorr
5  * Copyright (c) 2010 Kenneth Vermeirsch
6  * Copyright (c) 2020 Paul B Mahol
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /**
26  * @file
27  * Kodak PhotoCD (a.k.a. ImagePac) image decoder
28  *
29  * Supports resolutions up to 3072x2048.
30  */
31 
32 #define CACHED_BITSTREAM_READER !ARCH_X86_32
33 
34 #include "libavutil/intreadwrite.h"
35 #include "libavutil/opt.h"
36 #include "avcodec.h"
37 #include "bytestream.h"
38 #include "get_bits.h"
39 #include "internal.h"
40 #include "thread.h"
41 
42 typedef struct PhotoCDContext {
43  AVClass *class;
44  int lowres;
45 
47  int thumbnails; //* number of thumbnails; 0 for normal image */
50 
51  int streampos;
52 
53  uint8_t bits[256];
54  uint16_t codes[256];
55  uint8_t syms[256];
56 
57  VLC vlc[3];
59 
60 typedef struct ImageInfo {
61  uint32_t start;
62  uint16_t width, height;
63 } ImageInfo;
64 
65 static const ImageInfo img_info[6] = {
66  {8192, 192, 128},
67  {47104, 384, 256},
68  {196608, 768, 512},
69  {0, 1536, 1024},
70  {0, 3072, 2048},
71  {0, 6144, 4096},
72 };
73 
75  int width, int height)
76 {
77  GetByteContext *gb = &s->gb;
78  int start = s->streampos + img_info[2].start;
79  uint8_t *ptr, *ptr1, *ptr2;
80  uint8_t *dst;
81  int fill;
82 
83  ptr = picture->data[0];
84  ptr1 = picture->data[1];
85  ptr2 = picture->data[2];
86 
87  bytestream2_seek(gb, start, SEEK_SET);
88 
89  for (int y = 0; y < height; y += 2) {
90  dst = ptr;
91  for (int x = 0; x < width - 1; x++) {
92  fill = bytestream2_get_byte(gb);
93  *(dst++) = fill;
94  *(dst++) = (fill + bytestream2_peek_byte(gb) + 1) >> 1;
95  }
96  fill = bytestream2_get_byte(gb);
97  *(dst++) = fill;
98  *(dst++) = fill;
99 
100  ptr += picture->linesize[0] << 1;
101 
102  dst = ptr;
103  for (int x = 0; x < width - 1; x++) {
104  fill = bytestream2_get_byte(gb);
105  *(dst++) = fill;
106  *(dst++) = (fill + bytestream2_peek_byte(gb) + 1) >> 1;
107  }
108  fill = bytestream2_get_byte(gb);
109  *(dst++) = fill;
110  *(dst++) = fill;
111 
112  ptr += picture->linesize[0] << 1;
113 
114  dst = ptr1;
115  for (int x = 0; x < (width >> 1) - 1; x++) {
116  fill = bytestream2_get_byte(gb);
117  *(dst++) = fill;
118  *(dst++) = (fill + bytestream2_peek_byte(gb) + 1) >> 1;
119  }
120  fill = bytestream2_get_byte(gb);
121  *(dst++) = fill;
122  *(dst++) = fill;
123 
124  ptr1 += picture->linesize[1] << 1;
125 
126  dst = ptr2;
127  for (int x = 0; x < (width >> 1) - 1; x++) {
128  fill = bytestream2_get_byte(gb);
129  *(dst++) = fill;
130  *(dst++) = (fill + bytestream2_peek_byte(gb) + 1) >> 1;
131  }
132  fill = bytestream2_get_byte(gb);
133  *(dst++) = fill;
134  *(dst++) = fill;
135 
136  ptr2 += picture->linesize[2] << 1;
137  }
138 
139  s->streampos += bytestream2_tell(gb) - start;
140 }
141 
142 static av_noinline void interp_lines(uint8_t *ptr, int linesize,
143  int width, int height)
144 {
145  const uint8_t *src1;
146  uint8_t *dst;
147  int x;
148 
149  for (int y = 0; y < height - 2; y += 2) {
150  const uint8_t *src1 = ptr;
151  uint8_t *dst = ptr + linesize;
152  const uint8_t *src2 = dst + linesize;
153  for (x = 0; x < width - 2; x += 2) {
154  dst[x] = (src1[x] + src2[x] + 1) >> 1;
155  dst[x + 1] = (src1[x] + src2[x] + src1[x + 2] + src2[x + 2] + 2) >> 2;
156  }
157  dst[x] = dst[x + 1] = (src1[x] + src2[x] + 1) >> 1;
158 
159  ptr += linesize << 1;
160  }
161 
162  src1 = ptr;
163  dst = ptr + linesize;
164  for (x = 0; x < width - 2; x += 2) {
165  dst[x] = src1[x];
166  dst[x + 1] = (src1[x] + src1[x + 2] + 1) >> 1;
167  }
168  dst[x] = dst[x + 1] = src1[x];
169 }
170 
171 static av_noinline void interp_pixels(uint8_t *ptr, int linesize,
172  int width, int height)
173 {
174  for (int y = height - 2; y >= 0; y -= 2) {
175  const uint8_t *src = ptr + (y >> 1) * linesize;
176  uint8_t *dst = ptr + y * linesize;
177 
178  dst[width - 2] = dst[width - 1] = src[(width >> 1) - 1];
179  for (int x = width - 4; x >= 0; x -= 2) {
180  dst[x] = src[x >> 1];
181  dst[x + 1] = (src[x >> 1] + src[(x >> 1) + 1] + 1) >> 1;
182  }
183  }
184 }
185 
187 {
188  PhotoCDContext *s = avctx->priv_data;
189  GetByteContext *gb = &s->gb;
190  int start = s->streampos;
191  int count, ret;
192 
193  bytestream2_seek(gb, start, SEEK_SET);
194 
195  count = bytestream2_get_byte(gb) + 1;
196  if (bytestream2_get_bytes_left(gb) < count * 4)
197  return AVERROR_INVALIDDATA;
198 
199  for (int j = 0; j < count; j++) {
200  const int bit = bytestream2_get_byteu(gb) + 1;
201  const int code = bytestream2_get_be16u(gb);
202  const int sym = bytestream2_get_byteu(gb);
203 
204  if (bit > 16)
205  return AVERROR_INVALIDDATA;
206 
207  s->bits[j] = bit;
208  s->codes[j] = code >> (16 - bit);
209  s->syms[j] = sym;
210  }
211 
212  ff_free_vlc(vlc);
213  ret = ff_init_vlc_sparse(vlc, 12, count,
214  s->bits, sizeof(*s->bits), sizeof(*s->bits),
215  s->codes, sizeof(*s->codes), sizeof(*s->codes),
216  s->syms, sizeof(*s->syms), sizeof(*s->syms), 0);
217 
218  s->streampos = bytestream2_tell(gb);
219 
220  return ret;
221 }
222 
224  int target_res, int curr_res)
225 {
226  PhotoCDContext *s = avctx->priv_data;
228  GetByteContext *gb = &s->gb;
229  int ret, y = 0, type, height;
230  int start = s->streampos;
231  unsigned shiftreg;
232  const int scaling = target_res - curr_res;
233  const uint8_t type2idx[] = { 0, 0xff, 1, 2 };
234 
235  bytestream2_seek(gb, start, SEEK_SET);
237  if (ret < 0)
238  return ret;
239 
240  height = img_info[curr_res].height;
241 
242  while (y < height) {
243  uint8_t *data;
244  int x2, idx;
245 
246  for (; get_bits_left(&g) > 0;) {
247  if (show_bits(&g, 12) == 0xfff)
248  break;
249  skip_bits(&g, 8);
250  }
251 
252  shiftreg = show_bits(&g, 24);
253  while (shiftreg != 0xfffffe) {
254  if (get_bits_left(&g) <= 0)
255  return AVERROR_INVALIDDATA;
256  skip_bits(&g, 1);
257  shiftreg = show_bits(&g, 24);
258  }
259  skip_bits(&g, 24);
260  y = show_bits(&g, 15) & 0x1fff;
261  if (y >= height)
262  break;
263  type = get_bits(&g, 2);
264  skip_bits(&g, 14);
265 
266  if (type == 1)
267  return AVERROR_INVALIDDATA;
268  idx = type2idx[type];
269 
270  data = frame->data[idx] + (y >> !!idx) * frame->linesize[idx];
271 
272  x2 = avctx->width >> (scaling + !!idx);
273  for (int x = 0; x < x2; x++) {
274  int m;
275 
276  if (get_bits_left(&g) <= 0)
277  return AVERROR_INVALIDDATA;
278  m = get_vlc2(&g, s->vlc[idx].table, s->vlc[idx].bits, 2);
279  if (m < 0)
280  return AVERROR_INVALIDDATA;
281  m = sign_extend(m, 8);
282  data[x] = av_clip_uint8(data[x] + m);
283  }
284  }
285 
286  s->streampos += (get_bits_count(&g) + 7) >> 3;
287  s->streampos = (s->streampos + 0x6000 + 2047) & ~0x7ff;
288 
289  return 0;
290 }
291 
292 static int photocd_decode_frame(AVCodecContext *avctx, void *data,
293  int *got_frame, AVPacket *avpkt)
294 {
295  PhotoCDContext *s = avctx->priv_data;
296  ThreadFrame frame = { .f = data };
297  const uint8_t *buf = avpkt->data;
298  GetByteContext *gb = &s->gb;
299  AVFrame *p = data;
300  uint8_t *ptr, *ptr1, *ptr2;
301  int ret;
302 
303  if (avpkt->size < img_info[0].start)
304  return AVERROR_INVALIDDATA;
305 
306  if (!memcmp("PCD_OPA", buf, 7)) {
307  s->thumbnails = AV_RL16(buf + 10);
308  av_log(avctx, AV_LOG_WARNING, "this is a thumbnails file, "
309  "reading first thumbnail only\n");
310  } else if (avpkt->size < 786432) {
311  return AVERROR_INVALIDDATA;
312  } else if (memcmp("PCD_IPI", buf + 0x800, 7)) {
313  return AVERROR_INVALIDDATA;
314  }
315 
316  s->orientation = s->thumbnails ? buf[12] & 3 : buf[0x48] & 3;
317 
318  if (s->thumbnails)
319  s->resolution = 0;
320  else if (avpkt->size <= 788480)
321  s->resolution = 2;
322  else
323  s->resolution = av_clip(4 - s->lowres, 0, 4);
324 
325  ret = ff_set_dimensions(avctx, img_info[s->resolution].width, img_info[s->resolution].height);
326  if (ret < 0)
327  return ret;
328 
329  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
330  return ret;
331 
333  p->key_frame = 1;
334 
335  bytestream2_init(gb, avpkt->data, avpkt->size);
336 
337  if (s->resolution < 3) {
338  ptr = p->data[0];
339  ptr1 = p->data[1];
340  ptr2 = p->data[2];
341 
342  if (s->thumbnails)
343  bytestream2_seek(gb, 10240, SEEK_SET);
344  else
345  bytestream2_seek(gb, img_info[s->resolution].start, SEEK_SET);
346 
347  for (int y = 0; y < avctx->height; y += 2) {
348  bytestream2_get_buffer(gb, ptr, avctx->width);
349  ptr += p->linesize[0];
350 
351  bytestream2_get_buffer(gb, ptr, avctx->width);
352  ptr += p->linesize[0];
353 
354  bytestream2_get_buffer(gb, ptr1, avctx->width >> 1);
355  ptr1 += p->linesize[1];
356 
357  bytestream2_get_buffer(gb, ptr2, avctx->width >> 1);
358  ptr2 += p->linesize[2];
359  }
360  } else {
361  s->streampos = 0;
362  ptr = p->data[0];
363  ptr1 = p->data[1];
364  ptr2 = p->data[2];
365 
367 
368  interp_lines(ptr1, p->linesize[1], img_info[2].width, img_info[2].height);
369  interp_lines(ptr2, p->linesize[2], img_info[2].width, img_info[2].height);
370 
371  if (s->resolution == 4) {
372  interp_pixels(ptr1, p->linesize[1], img_info[3].width, img_info[3].height);
373  interp_lines (ptr1, p->linesize[1], img_info[3].width, img_info[3].height);
374  interp_pixels(ptr2, p->linesize[2], img_info[3].width, img_info[3].height);
375  interp_lines (ptr2, p->linesize[2], img_info[3].width, img_info[3].height);
376  }
377 
378  interp_lines(ptr, p->linesize[0], img_info[3].width, img_info[3].height);
379 
380  s->streampos = 0xc2000;
381  for (int n = 0; n < 3; n++) {
382  if ((ret = read_hufftable(avctx, &s->vlc[n])) < 0)
383  return ret;
384  }
385  s->streampos = (s->streampos + 2047) & ~0x3ff;
386  if (decode_huff(avctx, p, s->resolution, 3) < 0)
387  return AVERROR_INVALIDDATA;
388 
389  if (s->resolution == 4) {
390  interp_pixels(ptr, p->linesize[0], img_info[4].width, img_info[4].height);
391  interp_lines (ptr, p->linesize[0], img_info[4].width, img_info[4].height);
392 
393  for (int n = 0; n < 3; n++) {
394  if ((ret = read_hufftable(avctx, &s->vlc[n])) < 0)
395  return ret;
396  }
397  s->streampos = (s->streampos + 2047) & ~0x3ff;
398  if (decode_huff(avctx, p, 4, 4) < 0)
399  return AVERROR_INVALIDDATA;
400  }
401  }
402 
403  {
404  ptr1 = p->data[1];
405  ptr2 = p->data[2];
406 
407  for (int y = 0; y < avctx->height >> 1; y++) {
408  for (int x = 0; x < avctx->width >> 1; x++) {
409  ptr1[x] = av_clip_uint8(ptr1[x] - 28);
410  ptr2[x] = av_clip_uint8(ptr2[x] - 9);
411  }
412 
413  ptr1 += p->linesize[1];
414  ptr2 += p->linesize[2];
415  }
416  }
417 
418  *got_frame = 1;
419 
420  return 0;
421 }
422 
424 {
425  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
426  avctx->colorspace = AVCOL_SPC_BT709;
429  avctx->color_range = AVCOL_RANGE_JPEG;
430 
431  return 0;
432 }
433 
435 {
436  PhotoCDContext *s = avctx->priv_data;
437 
438  for (int i = 0; i < 3; i++)
439  ff_free_vlc(&s->vlc[i]);
440 
441  return 0;
442 }
443 
444 #define OFFSET(x) offsetof(PhotoCDContext, x)
445 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
446 
447 static const AVOption options[] = {
448  { "lowres", "Lower the decoding resolution by a power of two",
449  OFFSET(lowres), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 4, VD },
450  { NULL },
451 };
452 
453 static const AVClass photocd_class = {
454  .class_name = "photocd",
455  .item_name = av_default_item_name,
456  .option = options,
457  .version = LIBAVUTIL_VERSION_INT,
458 };
459 
461  .name = "photocd",
462  .type = AVMEDIA_TYPE_VIDEO,
463  .id = AV_CODEC_ID_PHOTOCD,
464  .priv_data_size = sizeof(PhotoCDContext),
465  .priv_class = &photocd_class,
467  .close = photocd_decode_close,
470  .long_name = NULL_IF_CONFIG_SMALL("Kodak Photo CD"),
471  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
472 };
AVCodec
AVCodec.
Definition: codec.h:202
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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
av_clip
#define av_clip
Definition: common.h:96
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
opt.h
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:960
photocd_decode_close
static av_cold int photocd_decode_close(AVCodecContext *avctx)
Definition: photocd.c:434
PhotoCDContext::gb
GetByteContext gb
Definition: photocd.c:46
ff_photocd_decoder
const AVCodec ff_photocd_decoder
Definition: photocd.c:460
GetByteContext
Definition: bytestream.h:33
VD
#define VD
Definition: photocd.c:445
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:310
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:953
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:579
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
data
const char data[16]
Definition: mxf.c:143
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:798
decode_huff
static av_noinline int decode_huff(AVCodecContext *avctx, AVFrame *frame, int target_res, int curr_res)
Definition: photocd.c:223
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:329
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:58
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:490
GetBitContext
Definition: get_bits.h:62
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
ImageInfo::start
uint32_t start
Definition: photocd.c:61
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:400
av_noinline
#define av_noinline
Definition: attributes.h:72
type
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 type
Definition: writing_filters.txt:86
interp_pixels
static av_noinline void interp_pixels(uint8_t *ptr, int linesize, int width, int height)
Definition: photocd.c:171
OFFSET
#define OFFSET(x)
Definition: photocd.c:444
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:946
interp_lines
static av_noinline void interp_lines(uint8_t *ptr, int linesize, int width, int height)
Definition: photocd.c:142
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
g
const char * g
Definition: vf_curves.c:117
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
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
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
PhotoCDContext::codes
uint16_t codes[256]
Definition: photocd.c:54
PhotoCDContext::vlc
VLC vlc[3]
Definition: photocd.c:57
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.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:66
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:967
read_hufftable
static av_noinline int read_hufftable(AVCodecContext *avctx, VLC *vlc)
Definition: photocd.c:186
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:453
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
src
#define src
Definition: vp8dsp.c:255
interp_lowres
static av_noinline void interp_lowres(PhotoCDContext *s, AVFrame *picture, int width, int height)
Definition: photocd.c:74
bytestream2_get_buffer
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
lowres
static int lowres
Definition: ffplay.c:334
ff_init_vlc_sparse
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:323
photocd_decode_frame
static int photocd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: photocd.c:292
img_info
static const ImageInfo img_info[6]
Definition: photocd.c:65
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
AV_CODEC_ID_PHOTOCD
@ AV_CODEC_ID_PHOTOCD
Definition: codec_id.h:304
PhotoCDContext::lowres
int lowres
Definition: photocd.c:44
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:405
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
photocd_class
static const AVClass photocd_class
Definition: photocd.c:453
height
#define height
ImageInfo::height
uint16_t height
Definition: photocd.c:62
PhotoCDContext::resolution
int resolution
Definition: photocd.c:48
src1
#define src1
Definition: h264pred.c:140
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:447
PhotoCDContext::streampos
int streampos
Definition: photocd.c:51
PhotoCDContext
Definition: photocd.c:42
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
avcodec.h
ret
ret
Definition: filter_design.txt:187
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:71
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:264
PhotoCDContext::bits
uint8_t bits[256]
Definition: photocd.c:53
options
static const AVOption options[]
Definition: photocd.c:447
AVCodecContext
main external API structure.
Definition: avcodec.h:383
PhotoCDContext::orientation
int orientation
Definition: photocd.c:49
ThreadFrame
Definition: thread.h:34
PhotoCDContext::thumbnails
int thumbnails
Definition: photocd.c:47
VLC
Definition: vlc.h:26
photocd_decode_init
static av_cold int photocd_decode_init(AVCodecContext *avctx)
Definition: photocd.c:423
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
av_clip_uint8
#define av_clip_uint8
Definition: common.h:102
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:86
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
bytestream.h
PhotoCDContext::syms
uint8_t syms[256]
Definition: photocd.c:55
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:353
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:507
ImageInfo
Definition: photocd.c:60
ImageInfo::width
uint16_t width
Definition: photocd.c:62