FFmpeg
kmvc.c
Go to the documentation of this file.
1 /*
2  * KMVC decoder
3  * Copyright (c) 2006 Konstantin Shishkov
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  * Karl Morton's Video Codec decoder
25  */
26 
27 #include <stdio.h>
28 
29 #include "avcodec.h"
30 #include "bytestream.h"
31 #include "codec_internal.h"
32 #include "decode.h"
33 #include "libavutil/common.h"
34 
35 #define KMVC_KEYFRAME 0x80
36 #define KMVC_PALETTE 0x40
37 #define KMVC_METHOD 0x0F
38 #define MAX_PALSIZE 256
39 
40 /*
41  * Decoder context
42  */
43 typedef struct KmvcContext {
44  AVCodecContext *avctx;
45 
46  GetByteContext g;
47  uint8_t *cur, *prev;
48  int setpal;
49  int palsize;
50  uint32_t pal[MAX_PALSIZE];
51  uint8_t frm0[320 * 200], frm1[320 * 200];
52 } KmvcContext;
53 
54 typedef struct BitBuf {
55  int bits;
56  int bitbuf;
57 } BitBuf;
58 
59 #define BLK(data, x, y) data[av_clip((x) + (y) * 320, 0, 320 * 200 -1)]
60 
61 #define kmvc_init_getbits(bb, g) bb.bits = 7; bb.bitbuf = bytestream2_get_byte(g);
62 
63 #define kmvc_getbit(bb, g, res) {\
64  res = 0; \
65  if (bb.bitbuf & (1 << bb.bits)) res = 1; \
66  bb.bits--; \
67  if(bb.bits == -1) { \
68  bb.bitbuf = bytestream2_get_byte(g); \
69  bb.bits = 7; \
70  } \
71 }
72 
73 static int kmvc_decode_intra_8x8(KmvcContext * ctx, int w, int h)
74 {
75  BitBuf bb;
76  int res, val;
77  int i, j;
78  int bx, by;
79  int l0x, l1x, l0y, l1y;
80  int mx, my;
81 
82  kmvc_init_getbits(bb, &ctx->g);
83 
84  for (by = 0; by < h; by += 8)
85  for (bx = 0; bx < w; bx += 8) {
86  if (!bytestream2_get_bytes_left(&ctx->g)) {
87  av_log(ctx->avctx, AV_LOG_ERROR, "Data overrun\n");
88  return AVERROR_INVALIDDATA;
89  }
90  kmvc_getbit(bb, &ctx->g, res);
91  if (!res) { // fill whole 8x8 block
92  val = bytestream2_get_byte(&ctx->g);
93  for (i = 0; i < 64; i++)
94  BLK(ctx->cur, bx + (i & 0x7), by + (i >> 3)) = val;
95  } else { // handle four 4x4 subblocks
96  for (i = 0; i < 4; i++) {
97  l0x = bx + (i & 1) * 4;
98  l0y = by + (i & 2) * 2;
99  kmvc_getbit(bb, &ctx->g, res);
100  if (!res) {
101  kmvc_getbit(bb, &ctx->g, res);
102  if (!res) { // fill whole 4x4 block
103  val = bytestream2_get_byte(&ctx->g);
104  for (j = 0; j < 16; j++)
105  BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) = val;
106  } else { // copy block from already decoded place
107  val = bytestream2_get_byte(&ctx->g);
108  mx = val & 0xF;
109  my = val >> 4;
110  if ((l0x-mx) + 320*(l0y-my) < 0 || (l0x-mx) + 320*(l0y-my) > 320*197 - 4) {
111  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n");
112  return AVERROR_INVALIDDATA;
113  }
114  for (j = 0; j < 16; j++)
115  BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) =
116  BLK(ctx->cur, l0x + (j & 3) - mx, l0y + (j >> 2) - my);
117  }
118  } else { // descend to 2x2 sub-sub-blocks
119  for (j = 0; j < 4; j++) {
120  l1x = l0x + (j & 1) * 2;
121  l1y = l0y + (j & 2);
122  kmvc_getbit(bb, &ctx->g, res);
123  if (!res) {
124  kmvc_getbit(bb, &ctx->g, res);
125  if (!res) { // fill whole 2x2 block
126  val = bytestream2_get_byte(&ctx->g);
127  BLK(ctx->cur, l1x, l1y) = val;
128  BLK(ctx->cur, l1x + 1, l1y) = val;
129  BLK(ctx->cur, l1x, l1y + 1) = val;
130  BLK(ctx->cur, l1x + 1, l1y + 1) = val;
131  } else { // copy block from already decoded place
132  val = bytestream2_get_byte(&ctx->g);
133  mx = val & 0xF;
134  my = val >> 4;
135  if ((l1x-mx) + 320*(l1y-my) < 0 || (l1x-mx) + 320*(l1y-my) > 320*199 - 2) {
136  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n");
137  return AVERROR_INVALIDDATA;
138  }
139  BLK(ctx->cur, l1x, l1y) = BLK(ctx->cur, l1x - mx, l1y - my);
140  BLK(ctx->cur, l1x + 1, l1y) =
141  BLK(ctx->cur, l1x + 1 - mx, l1y - my);
142  BLK(ctx->cur, l1x, l1y + 1) =
143  BLK(ctx->cur, l1x - mx, l1y + 1 - my);
144  BLK(ctx->cur, l1x + 1, l1y + 1) =
145  BLK(ctx->cur, l1x + 1 - mx, l1y + 1 - my);
146  }
147  } else { // read values for block
148  BLK(ctx->cur, l1x, l1y) = bytestream2_get_byte(&ctx->g);
149  BLK(ctx->cur, l1x + 1, l1y) = bytestream2_get_byte(&ctx->g);
150  BLK(ctx->cur, l1x, l1y + 1) = bytestream2_get_byte(&ctx->g);
151  BLK(ctx->cur, l1x + 1, l1y + 1) = bytestream2_get_byte(&ctx->g);
152  }
153  }
154  }
155  }
156  }
157  }
158 
159  return 0;
160 }
161 
162 static int kmvc_decode_inter_8x8(KmvcContext * ctx, int w, int h)
163 {
164  BitBuf bb;
165  int res, val;
166  int i, j;
167  int bx, by;
168  int l0x, l1x, l0y, l1y;
169  int mx, my;
170 
171  kmvc_init_getbits(bb, &ctx->g);
172 
173  for (by = 0; by < h; by += 8)
174  for (bx = 0; bx < w; bx += 8) {
175  kmvc_getbit(bb, &ctx->g, res);
176  if (!res) {
177  kmvc_getbit(bb, &ctx->g, res);
178  if (!res) { // fill whole 8x8 block
179  if (!bytestream2_get_bytes_left(&ctx->g)) {
180  av_log(ctx->avctx, AV_LOG_ERROR, "Data overrun\n");
181  return AVERROR_INVALIDDATA;
182  }
183  val = bytestream2_get_byte(&ctx->g);
184  for (i = 0; i < 64; i++)
185  BLK(ctx->cur, bx + (i & 0x7), by + (i >> 3)) = val;
186  } else { // copy block from previous frame
187  for (i = 0; i < 64; i++)
188  BLK(ctx->cur, bx + (i & 0x7), by + (i >> 3)) =
189  BLK(ctx->prev, bx + (i & 0x7), by + (i >> 3));
190  }
191  } else { // handle four 4x4 subblocks
192  if (!bytestream2_get_bytes_left(&ctx->g)) {
193  av_log(ctx->avctx, AV_LOG_ERROR, "Data overrun\n");
194  return AVERROR_INVALIDDATA;
195  }
196  for (i = 0; i < 4; i++) {
197  l0x = bx + (i & 1) * 4;
198  l0y = by + (i & 2) * 2;
199  kmvc_getbit(bb, &ctx->g, res);
200  if (!res) {
201  kmvc_getbit(bb, &ctx->g, res);
202  if (!res) { // fill whole 4x4 block
203  val = bytestream2_get_byte(&ctx->g);
204  for (j = 0; j < 16; j++)
205  BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) = val;
206  } else { // copy block
207  val = bytestream2_get_byte(&ctx->g);
208  mx = (val & 0xF) - 8;
209  my = (val >> 4) - 8;
210  if ((l0x+mx) + 320*(l0y+my) < 0 || (l0x+mx) + 320*(l0y+my) > 320*197 - 4) {
211  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n");
212  return AVERROR_INVALIDDATA;
213  }
214  for (j = 0; j < 16; j++)
215  BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) =
216  BLK(ctx->prev, l0x + (j & 3) + mx, l0y + (j >> 2) + my);
217  }
218  } else { // descend to 2x2 sub-sub-blocks
219  for (j = 0; j < 4; j++) {
220  l1x = l0x + (j & 1) * 2;
221  l1y = l0y + (j & 2);
222  kmvc_getbit(bb, &ctx->g, res);
223  if (!res) {
224  kmvc_getbit(bb, &ctx->g, res);
225  if (!res) { // fill whole 2x2 block
226  val = bytestream2_get_byte(&ctx->g);
227  BLK(ctx->cur, l1x, l1y) = val;
228  BLK(ctx->cur, l1x + 1, l1y) = val;
229  BLK(ctx->cur, l1x, l1y + 1) = val;
230  BLK(ctx->cur, l1x + 1, l1y + 1) = val;
231  } else { // copy block
232  val = bytestream2_get_byte(&ctx->g);
233  mx = (val & 0xF) - 8;
234  my = (val >> 4) - 8;
235  if ((l1x+mx) + 320*(l1y+my) < 0 || (l1x+mx) + 320*(l1y+my) > 320*199 - 2) {
236  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n");
237  return AVERROR_INVALIDDATA;
238  }
239  BLK(ctx->cur, l1x, l1y) = BLK(ctx->prev, l1x + mx, l1y + my);
240  BLK(ctx->cur, l1x + 1, l1y) =
241  BLK(ctx->prev, l1x + 1 + mx, l1y + my);
242  BLK(ctx->cur, l1x, l1y + 1) =
243  BLK(ctx->prev, l1x + mx, l1y + 1 + my);
244  BLK(ctx->cur, l1x + 1, l1y + 1) =
245  BLK(ctx->prev, l1x + 1 + mx, l1y + 1 + my);
246  }
247  } else { // read values for block
248  BLK(ctx->cur, l1x, l1y) = bytestream2_get_byte(&ctx->g);
249  BLK(ctx->cur, l1x + 1, l1y) = bytestream2_get_byte(&ctx->g);
250  BLK(ctx->cur, l1x, l1y + 1) = bytestream2_get_byte(&ctx->g);
251  BLK(ctx->cur, l1x + 1, l1y + 1) = bytestream2_get_byte(&ctx->g);
252  }
253  }
254  }
255  }
256  }
257  }
258 
259  return 0;
260 }
261 
262 static int decode_frame(AVCodecContext * avctx, AVFrame *frame,
263  int *got_frame, AVPacket *avpkt)
264 {
265  KmvcContext *const ctx = avctx->priv_data;
266  uint8_t *out, *src;
267  int i, ret;
268  int header;
269  int blocksize;
270 
271  bytestream2_init(&ctx->g, avpkt->data, avpkt->size);
272 
273  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
274  return ret;
275 
276 #if FF_API_PALETTE_HAS_CHANGED
277 FF_DISABLE_DEPRECATION_WARNINGS
278  frame->palette_has_changed =
279 #endif
280  ff_copy_palette(ctx->pal, avpkt, avctx);
281 #if FF_API_PALETTE_HAS_CHANGED
282 FF_ENABLE_DEPRECATION_WARNINGS
283 #endif
284 
285  header = bytestream2_get_byte(&ctx->g);
286 
287  /* blocksize 127 is really palette change event */
288  if (bytestream2_peek_byte(&ctx->g) == 127) {
289  bytestream2_skip(&ctx->g, 3);
290  for (i = 0; i < 127; i++) {
291  ctx->pal[i + (header & 0x81)] = 0xFFU << 24 | bytestream2_get_be24(&ctx->g);
292  bytestream2_skip(&ctx->g, 1);
293  }
294  bytestream2_seek(&ctx->g, -127 * 4 - 3, SEEK_CUR);
295  }
296 
297  if (header & KMVC_KEYFRAME) {
298  frame->flags |= AV_FRAME_FLAG_KEY;
299  frame->pict_type = AV_PICTURE_TYPE_I;
300  } else {
301  frame->flags &= ~AV_FRAME_FLAG_KEY;
302  frame->pict_type = AV_PICTURE_TYPE_P;
303  }
304 
305  if (header & KMVC_PALETTE) {
306 #if FF_API_PALETTE_HAS_CHANGED
307 FF_DISABLE_DEPRECATION_WARNINGS
308  frame->palette_has_changed = 1;
309 FF_ENABLE_DEPRECATION_WARNINGS
310 #endif
311  // palette starts from index 1 and has 127 entries
312  for (i = 1; i <= ctx->palsize; i++) {
313  ctx->pal[i] = 0xFFU << 24 | bytestream2_get_be24(&ctx->g);
314  }
315  }
316 
317  if (ctx->setpal) {
318  ctx->setpal = 0;
319 #if FF_API_PALETTE_HAS_CHANGED
320 FF_DISABLE_DEPRECATION_WARNINGS
321  frame->palette_has_changed = 1;
322 FF_ENABLE_DEPRECATION_WARNINGS
323 #endif
324  }
325 
326  /* make the palette available on the way out */
327  memcpy(frame->data[1], ctx->pal, 1024);
328 
329  blocksize = bytestream2_get_byte(&ctx->g);
330 
331  if (blocksize != 8 && blocksize != 127) {
332  av_log(avctx, AV_LOG_ERROR, "Block size = %i\n", blocksize);
333  return AVERROR_INVALIDDATA;
334  }
335  memset(ctx->cur, 0, 320 * 200);
336  switch (header & KMVC_METHOD) {
337  case 0:
338  case 1: // used in palette changed event
339  memcpy(ctx->cur, ctx->prev, 320 * 200);
340  break;
341  case 3:
342  kmvc_decode_intra_8x8(ctx, avctx->width, avctx->height);
343  break;
344  case 4:
345  kmvc_decode_inter_8x8(ctx, avctx->width, avctx->height);
346  break;
347  default:
348  av_log(avctx, AV_LOG_ERROR, "Unknown compression method %i\n", header & KMVC_METHOD);
349  return AVERROR_INVALIDDATA;
350  }
351 
352  out = frame->data[0];
353  src = ctx->cur;
354  for (i = 0; i < avctx->height; i++) {
355  memcpy(out, src, avctx->width);
356  src += 320;
357  out += frame->linesize[0];
358  }
359 
360  /* flip buffers */
361  FFSWAP(uint8_t *, ctx->cur, ctx->prev);
362 
363  *got_frame = 1;
364 
365  /* always report that the buffer was completely consumed */
366  return avpkt->size;
367 }
368 
369 
370 
371 /*
372  * Init kmvc decoder
373  */
374 static av_cold int decode_init(AVCodecContext * avctx)
375 {
376  KmvcContext *const c = avctx->priv_data;
377  int i;
378 
379  c->avctx = avctx;
380 
381  if (avctx->width > 320 || avctx->height > 200) {
382  av_log(avctx, AV_LOG_ERROR, "KMVC supports frames <= 320x200\n");
383  return AVERROR(EINVAL);
384  }
385 
386  c->cur = c->frm0;
387  c->prev = c->frm1;
388 
389  for (i = 0; i < 256; i++) {
390  c->pal[i] = 0xFFU << 24 | i * 0x10101;
391  }
392 
393  if (avctx->extradata_size < 12) {
394  av_log(avctx, AV_LOG_WARNING,
395  "Extradata missing, decoding may not work properly...\n");
396  c->palsize = 127;
397  } else {
398  c->palsize = AV_RL16(avctx->extradata + 10);
399  if (c->palsize >= (unsigned)MAX_PALSIZE) {
400  c->palsize = 127;
401  av_log(avctx, AV_LOG_ERROR, "KMVC palette too large\n");
402  return AVERROR_INVALIDDATA;
403  }
404  }
405 
406  if (avctx->extradata_size == 1036) { // palette in extradata
407  uint8_t *src = avctx->extradata + 12;
408  for (i = 0; i < 256; i++) {
409  c->pal[i] = AV_RL32(src);
410  src += 4;
411  }
412  c->setpal = 1;
413  }
414 
415  avctx->pix_fmt = AV_PIX_FMT_PAL8;
416 
417  return 0;
418 }
419 
420 const FFCodec ff_kmvc_decoder = {
421  .p.name = "kmvc",
422  CODEC_LONG_NAME("Karl Morton's video codec"),
423  .p.type = AVMEDIA_TYPE_VIDEO,
424  .p.id = AV_CODEC_ID_KMVC,
425  .priv_data_size = sizeof(KmvcContext),
426  .init = decode_init,
427  FF_CODEC_DECODE_CB(decode_frame),
428  .p.capabilities = AV_CODEC_CAP_DR1,
429 };
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVFrame::palette_has_changed
attribute_deprecated int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:546
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
out
FILE * out
Definition: movenc.c:54
GetByteContext
Definition: bytestream.h:33
KmvcContext
Definition: kmvc.c:43
BitBuf
uint32_t BitBuf
Definition: put_bits.h:43
KmvcContext::prev
uint8_t * prev
Definition: kmvc.c:47
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:340
w
uint8_t w
Definition: llviddspenc.c:38
AVPacket::data
uint8_t * data
Definition: packet.h:491
kmvc_decode_intra_8x8
static int kmvc_decode_intra_8x8(KmvcContext *ctx, int w, int h)
Definition: kmvc.c:73
KmvcContext::palsize
int palsize
Definition: kmvc.c:49
FFCodec
Definition: codec_internal.h:127
KMVC_KEYFRAME
#define KMVC_KEYFRAME
Definition: kmvc.c:35
ff_kmvc_decoder
const FFCodec ff_kmvc_decoder
Definition: kmvc.c:420
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
KmvcContext::frm0
uint8_t frm0[320 *200]
Definition: kmvc.c:51
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
val
static double val(void *priv, double ch)
Definition: aeval.c:78
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
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:628
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:543
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
AV_CODEC_ID_KMVC
@ AV_CODEC_ID_KMVC
Definition: codec_id.h:137
kmvc_getbit
#define kmvc_getbit(bb, g, res)
Definition: kmvc.c:63
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.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
KMVC_METHOD
#define KMVC_METHOD
Definition: kmvc.c:37
KmvcContext::cur
uint8_t * cur
Definition: kmvc.c:47
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
KmvcContext::avctx
AVCodecContext * avctx
Definition: kmvc.c:44
BitBuf
Definition: kmvc.c:54
BLK
#define BLK(data, x, y)
Definition: kmvc.c:59
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1617
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:492
codec_internal.h
header
static const uint8_t header[24]
Definition: sdr2.c:67
MAX_PALSIZE
#define MAX_PALSIZE
Definition: kmvc.c:38
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
kmvc_init_getbits
#define kmvc_init_getbits(bb, g)
Definition: kmvc.c:61
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:542
common.h
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: kmvc.c:262
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::height
int height
Definition: avcodec.h:621
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:658
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
KmvcContext::pal
uint32_t pal[MAX_PALSIZE]
Definition: kmvc.c:50
AVCodecContext
main external API structure.
Definition: avcodec.h:441
KmvcContext::frm1
uint8_t frm1[320 *200]
Definition: kmvc.c:51
BitBuf::bitbuf
int bitbuf
Definition: kmvc.c:56
KmvcContext::setpal
int setpal
Definition: kmvc.c:48
BitBuf::bits
int bits
Definition: kmvc.c:55
KmvcContext::g
GetByteContext g
Definition: kmvc.c:46
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:468
AVPacket
This structure stores compressed data.
Definition: packet.h:468
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
kmvc_decode_inter_8x8
static int kmvc_decode_inter_8x8(KmvcContext *ctx, int w, int h)
Definition: kmvc.c:162
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:621
bytestream.h
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:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: kmvc.c:374
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
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:1823
KMVC_PALETTE
#define KMVC_PALETTE
Definition: kmvc.c:36
Generated on Thu Apr 18 2024 22:41:53 for FFmpeg by   doxygen 1.8.17