FFmpeg  4.4.5
zmbv.c
Go to the documentation of this file.
1 /*
2  * Zip Motion Blocks Video (ZMBV) 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  * Zip Motion Blocks Video decoder
25  */
26 
27 #include <stdio.h>
28 #include <stdlib.h>
29 
30 #include "libavutil/common.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/intreadwrite.h"
33 #include "avcodec.h"
34 #include "internal.h"
35 
36 #include <zlib.h>
37 
38 #define ZMBV_KEYFRAME 1
39 #define ZMBV_DELTAPAL 2
40 
41 enum ZmbvFormat {
50  ZMBV_FMT_32BPP = 8
51 };
52 
53 /*
54  * Decoder context
55  */
56 typedef struct ZmbvContext {
58 
59  int bpp;
60  int alloc_bpp;
61  unsigned int decomp_size;
63  uint8_t pal[768];
65  int width, height;
66  int fmt;
67  int comp;
68  int flags;
69  int stride;
70  int bw, bh, bx, by;
73  z_stream zstream;
74  int (*decode_xor)(struct ZmbvContext *c);
75 } ZmbvContext;
76 
77 /**
78  * Decode XOR'ed frame - 8bpp version
79  */
80 
82 {
83  uint8_t *src = c->decomp_buf;
84  uint8_t *output, *prev;
85  int8_t *mvec;
86  int x, y;
87  int d, dx, dy, bw2, bh2;
88  int block;
89  int i, j;
90  int mx, my;
91 
92  output = c->cur;
93  prev = c->prev;
94 
95  if (c->flags & ZMBV_DELTAPAL) {
96  for (i = 0; i < 768; i++)
97  c->pal[i] ^= *src++;
98  }
99 
100  mvec = (int8_t*)src;
101  src += ((c->bx * c->by * 2 + 3) & ~3);
102 
103  block = 0;
104  for (y = 0; y < c->height; y += c->bh) {
105  bh2 = ((c->height - y) > c->bh) ? c->bh : (c->height - y);
106  for (x = 0; x < c->width; x += c->bw) {
107  uint8_t *out, *tprev;
108 
109  d = mvec[block] & 1;
110  dx = mvec[block] >> 1;
111  dy = mvec[block + 1] >> 1;
112  block += 2;
113 
114  bw2 = ((c->width - x) > c->bw) ? c->bw : (c->width - x);
115 
116  /* copy block - motion vectors out of bounds are used to zero blocks */
117  out = output + x;
118  tprev = prev + x + dx + dy * c->width;
119  mx = x + dx;
120  my = y + dy;
121  for (j = 0; j < bh2; j++) {
122  if (my + j < 0 || my + j >= c->height) {
123  memset(out, 0, bw2);
124  } else if (mx >= 0 && mx + bw2 <= c->width){
125  memcpy(out, tprev, sizeof(*out) * bw2);
126  } else {
127  for (i = 0; i < bw2; i++) {
128  if (mx + i < 0 || mx + i >= c->width)
129  out[i] = 0;
130  else
131  out[i] = tprev[i];
132  }
133  }
134  out += c->width;
135  tprev += c->width;
136  }
137 
138  if (d) { /* apply XOR'ed difference */
139  out = output + x;
140  for (j = 0; j < bh2; j++) {
141  for (i = 0; i < bw2; i++)
142  out[i] ^= *src++;
143  out += c->width;
144  }
145  }
146  }
147  output += c->width * c->bh;
148  prev += c->width * c->bh;
149  }
150  if (src - c->decomp_buf != c->decomp_len)
151  av_log(c->avctx, AV_LOG_ERROR, "Used %"PTRDIFF_SPECIFIER" of %i bytes\n",
152  src-c->decomp_buf, c->decomp_len);
153  return 0;
154 }
155 
156 /**
157  * Decode XOR'ed frame - 15bpp and 16bpp version
158  */
159 
161 {
162  uint8_t *src = c->decomp_buf;
163  uint16_t *output, *prev;
164  int8_t *mvec;
165  int x, y;
166  int d, dx, dy, bw2, bh2;
167  int block;
168  int i, j;
169  int mx, my;
170 
171  output = (uint16_t*)c->cur;
172  prev = (uint16_t*)c->prev;
173 
174  mvec = (int8_t*)src;
175  src += ((c->bx * c->by * 2 + 3) & ~3);
176 
177  block = 0;
178  for (y = 0; y < c->height; y += c->bh) {
179  bh2 = ((c->height - y) > c->bh) ? c->bh : (c->height - y);
180  for (x = 0; x < c->width; x += c->bw) {
181  uint16_t *out, *tprev;
182 
183  d = mvec[block] & 1;
184  dx = mvec[block] >> 1;
185  dy = mvec[block + 1] >> 1;
186  block += 2;
187 
188  bw2 = ((c->width - x) > c->bw) ? c->bw : (c->width - x);
189 
190  /* copy block - motion vectors out of bounds are used to zero blocks */
191  out = output + x;
192  tprev = prev + x + dx + dy * c->width;
193  mx = x + dx;
194  my = y + dy;
195  for (j = 0; j < bh2; j++) {
196  if (my + j < 0 || my + j >= c->height) {
197  memset(out, 0, bw2 * 2);
198  } else if (mx >= 0 && mx + bw2 <= c->width){
199  memcpy(out, tprev, sizeof(*out) * bw2);
200  } else {
201  for (i = 0; i < bw2; i++) {
202  if (mx + i < 0 || mx + i >= c->width)
203  out[i] = 0;
204  else
205  out[i] = tprev[i];
206  }
207  }
208  out += c->width;
209  tprev += c->width;
210  }
211 
212  if (d) { /* apply XOR'ed difference */
213  out = output + x;
214  for (j = 0; j < bh2; j++){
215  for (i = 0; i < bw2; i++) {
216  out[i] ^= *((uint16_t*)src);
217  src += 2;
218  }
219  out += c->width;
220  }
221  }
222  }
223  output += c->width * c->bh;
224  prev += c->width * c->bh;
225  }
226  if (src - c->decomp_buf != c->decomp_len)
227  av_log(c->avctx, AV_LOG_ERROR, "Used %"PTRDIFF_SPECIFIER" of %i bytes\n",
228  src-c->decomp_buf, c->decomp_len);
229  return 0;
230 }
231 
232 #ifdef ZMBV_ENABLE_24BPP
233 /**
234  * Decode XOR'ed frame - 24bpp version
235  */
236 
237 static int zmbv_decode_xor_24(ZmbvContext *c)
238 {
239  uint8_t *src = c->decomp_buf;
240  uint8_t *output, *prev;
241  int8_t *mvec;
242  int x, y;
243  int d, dx, dy, bw2, bh2;
244  int block;
245  int i, j;
246  int mx, my;
247  int stride;
248 
249  output = c->cur;
250  prev = c->prev;
251 
252  stride = c->width * 3;
253  mvec = (int8_t*)src;
254  src += ((c->bx * c->by * 2 + 3) & ~3);
255 
256  block = 0;
257  for (y = 0; y < c->height; y += c->bh) {
258  bh2 = ((c->height - y) > c->bh) ? c->bh : (c->height - y);
259  for (x = 0; x < c->width; x += c->bw) {
260  uint8_t *out, *tprev;
261 
262  d = mvec[block] & 1;
263  dx = mvec[block] >> 1;
264  dy = mvec[block + 1] >> 1;
265  block += 2;
266 
267  bw2 = ((c->width - x) > c->bw) ? c->bw : (c->width - x);
268 
269  /* copy block - motion vectors out of bounds are used to zero blocks */
270  out = output + x * 3;
271  tprev = prev + (x + dx) * 3 + dy * stride;
272  mx = x + dx;
273  my = y + dy;
274  for (j = 0; j < bh2; j++) {
275  if (my + j < 0 || my + j >= c->height) {
276  memset(out, 0, bw2 * 3);
277  } else if (mx >= 0 && mx + bw2 <= c->width){
278  memcpy(out, tprev, 3 * bw2);
279  } else {
280  for (i = 0; i < bw2; i++){
281  if (mx + i < 0 || mx + i >= c->width) {
282  out[i * 3 + 0] = 0;
283  out[i * 3 + 1] = 0;
284  out[i * 3 + 2] = 0;
285  } else {
286  out[i * 3 + 0] = tprev[i * 3 + 0];
287  out[i * 3 + 1] = tprev[i * 3 + 1];
288  out[i * 3 + 2] = tprev[i * 3 + 2];
289  }
290  }
291  }
292  out += stride;
293  tprev += stride;
294  }
295 
296  if (d) { /* apply XOR'ed difference */
297  out = output + x * 3;
298  for (j = 0; j < bh2; j++) {
299  for (i = 0; i < bw2; i++) {
300  out[i * 3 + 0] ^= *src++;
301  out[i * 3 + 1] ^= *src++;
302  out[i * 3 + 2] ^= *src++;
303  }
304  out += stride;
305  }
306  }
307  }
308  output += stride * c->bh;
309  prev += stride * c->bh;
310  }
311  if (src - c->decomp_buf != c->decomp_len)
312  av_log(c->avctx, AV_LOG_ERROR, "Used %"PTRDIFF_SPECIFIER" of %i bytes\n",
313  src-c->decomp_buf, c->decomp_len);
314  return 0;
315 }
316 #endif //ZMBV_ENABLE_24BPP
317 
318 /**
319  * Decode XOR'ed frame - 32bpp version
320  */
321 
323 {
324  uint8_t *src = c->decomp_buf;
325  uint32_t *output, *prev;
326  int8_t *mvec;
327  int x, y;
328  int d, dx, dy, bw2, bh2;
329  int block;
330  int i, j;
331  int mx, my;
332 
333  output = (uint32_t*)c->cur;
334  prev = (uint32_t*)c->prev;
335 
336  mvec = (int8_t*)src;
337  src += ((c->bx * c->by * 2 + 3) & ~3);
338 
339  block = 0;
340  for (y = 0; y < c->height; y += c->bh) {
341  bh2 = ((c->height - y) > c->bh) ? c->bh : (c->height - y);
342  for (x = 0; x < c->width; x += c->bw) {
343  uint32_t *out, *tprev;
344 
345  d = mvec[block] & 1;
346  dx = mvec[block] >> 1;
347  dy = mvec[block + 1] >> 1;
348  block += 2;
349 
350  bw2 = ((c->width - x) > c->bw) ? c->bw : (c->width - x);
351 
352  /* copy block - motion vectors out of bounds are used to zero blocks */
353  out = output + x;
354  tprev = prev + x + dx + dy * c->width;
355  mx = x + dx;
356  my = y + dy;
357  for (j = 0; j < bh2; j++) {
358  if (my + j < 0 || my + j >= c->height) {
359  memset(out, 0, bw2 * 4);
360  } else if (mx >= 0 && mx + bw2 <= c->width){
361  memcpy(out, tprev, sizeof(*out) * bw2);
362  } else {
363  for (i = 0; i < bw2; i++){
364  if (mx + i < 0 || mx + i >= c->width)
365  out[i] = 0;
366  else
367  out[i] = tprev[i];
368  }
369  }
370  out += c->width;
371  tprev += c->width;
372  }
373 
374  if (d) { /* apply XOR'ed difference */
375  out = output + x;
376  for (j = 0; j < bh2; j++){
377  for (i = 0; i < bw2; i++) {
378  out[i] ^= *((uint32_t *) src);
379  src += 4;
380  }
381  out += c->width;
382  }
383  }
384  }
385  output += c->width * c->bh;
386  prev += c->width * c->bh;
387  }
388  if (src - c->decomp_buf != c->decomp_len)
389  av_log(c->avctx, AV_LOG_ERROR, "Used %"PTRDIFF_SPECIFIER" of %i bytes\n",
390  src-c->decomp_buf, c->decomp_len);
391  return 0;
392 }
393 
394 /**
395  * Decode intraframe
396  */
398 {
399  uint8_t *src = c->decomp_buf;
400 
401  /* make the palette available on the way out */
402  if (c->fmt == ZMBV_FMT_8BPP) {
403  memcpy(c->pal, src, 768);
404  src += 768;
405  }
406 
407  memcpy(c->cur, src, c->width * c->height * (c->bpp / 8));
408  return 0;
409 }
410 
411 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
412 {
413  AVFrame *frame = data;
414  const uint8_t *buf = avpkt->data;
415  int buf_size = avpkt->size;
416  ZmbvContext * const c = avctx->priv_data;
417  int zret = Z_OK; // Zlib return code
418  int len = buf_size;
419  int hi_ver, lo_ver, ret;
420  int expected_size;
421 
422  /* parse header */
423  if (len < 1)
424  return AVERROR_INVALIDDATA;
425  c->flags = buf[0];
426  buf++; len--;
427  if (c->flags & ZMBV_KEYFRAME) {
428  c->got_keyframe = 0;
429 
430  if (len < 6)
431  return AVERROR_INVALIDDATA;
432  hi_ver = buf[0];
433  lo_ver = buf[1];
434  c->comp = buf[2];
435  c->fmt = buf[3];
436  c->bw = buf[4];
437  c->bh = buf[5];
438  c->decode_xor = NULL;
439 
440  buf += 6;
441  len -= 6;
443  "Flags=%X ver=%i.%i comp=%i fmt=%i blk=%ix%i\n",
444  c->flags,hi_ver,lo_ver,c->comp,c->fmt,c->bw,c->bh);
445  if (hi_ver != 0 || lo_ver != 1) {
446  avpriv_request_sample(avctx, "Version %i.%i", hi_ver, lo_ver);
447  return AVERROR_PATCHWELCOME;
448  }
449  if (c->bw == 0 || c->bh == 0) {
450  avpriv_request_sample(avctx, "Block size %ix%i", c->bw, c->bh);
451  return AVERROR_PATCHWELCOME;
452  }
453  if (c->comp != 0 && c->comp != 1) {
454  avpriv_request_sample(avctx, "Compression type %i", c->comp);
455  return AVERROR_PATCHWELCOME;
456  }
457 
458  switch (c->fmt) {
459  case ZMBV_FMT_8BPP:
460  c->bpp = 8;
461  c->decode_xor = zmbv_decode_xor_8;
463  c->stride = c->width;
464  break;
465  case ZMBV_FMT_15BPP:
466  case ZMBV_FMT_16BPP:
467  c->bpp = 16;
468  c->decode_xor = zmbv_decode_xor_16;
469  if (c->fmt == ZMBV_FMT_15BPP)
471  else
473  c->stride = c->width * 2;
474  break;
475 #ifdef ZMBV_ENABLE_24BPP
476  case ZMBV_FMT_24BPP:
477  c->bpp = 24;
478  c->decode_xor = zmbv_decode_xor_24;
480  c->stride = c->width * 3;
481  break;
482 #endif //ZMBV_ENABLE_24BPP
483  case ZMBV_FMT_32BPP:
484  c->bpp = 32;
485  c->decode_xor = zmbv_decode_xor_32;
487  c->stride = c->width * 4;
488  break;
489  default:
490  c->decode_xor = NULL;
491  avpriv_request_sample(avctx, "Format %i", c->fmt);
492  return AVERROR_PATCHWELCOME;
493  }
494 
495  zret = inflateReset(&c->zstream);
496  if (zret != Z_OK) {
497  av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
498  return AVERROR_UNKNOWN;
499  }
500 
501  if (c->alloc_bpp < c->bpp) {
502  c->cur = av_realloc_f(c->cur, avctx->width * avctx->height, (c->bpp / 8));
503  c->prev = av_realloc_f(c->prev, avctx->width * avctx->height, (c->bpp / 8));
504  c->alloc_bpp = c->bpp;
505  }
506  c->bx = (c->width + c->bw - 1) / c->bw;
507  c->by = (c->height+ c->bh - 1) / c->bh;
508  if (!c->cur || !c->prev) {
509  c->alloc_bpp = 0;
510  return AVERROR(ENOMEM);
511  }
512  memset(c->cur, 0, avctx->width * avctx->height * (c->bpp / 8));
513  memset(c->prev, 0, avctx->width * avctx->height * (c->bpp / 8));
514  c->got_keyframe = 1;
515  }
516  if (c->flags & ZMBV_KEYFRAME) {
517  expected_size = avctx->width * avctx->height * (c->bpp / 8);
518  } else {
519  expected_size = (c->bx * c->by * 2 + 3) & ~3;
520  }
521  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 &&
522  (c->flags & (ZMBV_DELTAPAL | ZMBV_KEYFRAME)))
523  expected_size += 768;
524 
525  if (!c->got_keyframe) {
526  av_log(avctx, AV_LOG_ERROR, "Error! Got no format or no keyframe!\n");
527  return AVERROR_INVALIDDATA;
528  }
529 
530  if (c->comp == 0) { // uncompressed data
531  if (c->decomp_size < len) {
532  av_log(avctx, AV_LOG_ERROR, "Buffer too small\n");
533  return AVERROR_INVALIDDATA;
534  }
535  memcpy(c->decomp_buf, buf, len);
536  c->decomp_len = len;
537  } else { // ZLIB-compressed data
538  c->zstream.total_in = c->zstream.total_out = 0;
539  c->zstream.next_in = buf;
540  c->zstream.avail_in = len;
541  c->zstream.next_out = c->decomp_buf;
542  c->zstream.avail_out = c->decomp_size;
543  zret = inflate(&c->zstream, Z_SYNC_FLUSH);
544  if (zret != Z_OK && zret != Z_STREAM_END) {
545  av_log(avctx, AV_LOG_ERROR, "inflate error %d\n", zret);
546  return AVERROR_INVALIDDATA;
547  }
548  c->decomp_len = c->zstream.total_out;
549  }
550  if (expected_size > c->decomp_len ||
551  (c->flags & ZMBV_KEYFRAME) && expected_size < c->decomp_len) {
552  av_log(avctx, AV_LOG_ERROR, "decompressed size %d is incorrect, expected %d\n", c->decomp_len, expected_size);
553  return AVERROR_INVALIDDATA;
554  }
555  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
556  return ret;
557 
558  if (c->flags & ZMBV_KEYFRAME) {
559  frame->key_frame = 1;
562  } else {
563  frame->key_frame = 0;
565  if (c->decomp_len < 2LL * ((c->width + c->bw - 1) / c->bw) * ((c->height + c->bh - 1) / c->bh))
566  return AVERROR_INVALIDDATA;
567  if (c->decomp_len)
568  c->decode_xor(c);
569  }
570 
571  /* update frames */
572  {
573  uint8_t *out, *src;
574  int j;
575 
576  out = frame->data[0];
577  src = c->cur;
578  switch (c->fmt) {
579  case ZMBV_FMT_8BPP:
580  for (j = 0; j < 256; j++)
581  AV_WN32(&frame->data[1][j * 4], 0xFFU << 24 | AV_RB24(&c->pal[j * 3]));
582  case ZMBV_FMT_15BPP:
583  case ZMBV_FMT_16BPP:
584 #ifdef ZMBV_ENABLE_24BPP
585  case ZMBV_FMT_24BPP:
586 #endif
587  case ZMBV_FMT_32BPP:
588  av_image_copy_plane(out, frame->linesize[0], src, c->stride,
589  c->stride, c->height);
590  break;
591  default:
592  av_log(avctx, AV_LOG_ERROR, "Cannot handle format %i\n", c->fmt);
593  }
594  FFSWAP(uint8_t *, c->cur, c->prev);
595  }
596  *got_frame = 1;
597 
598  /* always report that the buffer was completely consumed */
599  return buf_size;
600 }
601 
603 {
604  ZmbvContext * const c = avctx->priv_data;
605  int zret; // Zlib return code
606 
607  c->avctx = avctx;
608 
609  c->width = avctx->width;
610  c->height = avctx->height;
611 
612  c->bpp = avctx->bits_per_coded_sample;
613 
614  // Needed if zlib unused or init aborted before inflateInit
615  memset(&c->zstream, 0, sizeof(z_stream));
616 
617  if ((avctx->width + 255ULL) * (avctx->height + 64ULL) > FFMIN(avctx->max_pixels, INT_MAX / 4) ) {
618  av_log(avctx, AV_LOG_ERROR, "Internal buffer (decomp_size) larger than max_pixels or too large\n");
619  return AVERROR_INVALIDDATA;
620  }
621 
622  c->decomp_size = (avctx->width + 255) * 4 * (avctx->height + 64);
623 
624  /* Allocate decompression buffer */
625  c->decomp_buf = av_mallocz(c->decomp_size);
626  if (!c->decomp_buf) {
628  "Can't allocate decompression buffer.\n");
629  return AVERROR(ENOMEM);
630  }
631 
632  c->zstream.zalloc = Z_NULL;
633  c->zstream.zfree = Z_NULL;
634  c->zstream.opaque = Z_NULL;
635  zret = inflateInit(&c->zstream);
636  if (zret != Z_OK) {
637  av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
638  return AVERROR_UNKNOWN;
639  }
640 
641  return 0;
642 }
643 
645 {
646  ZmbvContext * const c = avctx->priv_data;
647 
648  av_freep(&c->decomp_buf);
649 
650  inflateEnd(&c->zstream);
651  av_freep(&c->cur);
652  av_freep(&c->prev);
653 
654  return 0;
655 }
656 
658  .name = "zmbv",
659  .long_name = NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"),
660  .type = AVMEDIA_TYPE_VIDEO,
661  .id = AV_CODEC_ID_ZMBV,
662  .priv_data_size = sizeof(ZmbvContext),
663  .init = decode_init,
664  .close = decode_end,
665  .decode = decode_frame,
666  .capabilities = AV_CODEC_CAP_DR1,
667  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
668 };
#define av_cold
Definition: attributes.h:88
uint8_t
Libavcodec external API header.
#define AV_RB24
Definition: intreadwrite.h:64
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
common internal and external API header
#define FFSWAP(type, a, b)
Definition: common.h:108
#define FFMIN(a, b)
Definition: common.h:105
#define NULL
Definition: coverity.c:32
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static AVFrame * frame
int
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
@ AV_CODEC_ID_ZMBV
Definition: codec_id.h:130
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:373
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
misc image utilities
int i
Definition: input.c:407
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define PTRDIFF_SPECIFIER
Definition: internal.h:192
int stride
Definition: mace.c:144
const char data[16]
Definition: mxf.c:142
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:108
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:2248
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1740
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
AVCodecContext * avctx
Definition: zmbv.c:57
int stride
Definition: zmbv.c:69
z_stream zstream
Definition: zmbv.c:73
unsigned int decomp_size
Definition: zmbv.c:61
int bw
Definition: zmbv.c:70
uint8_t * prev
Definition: zmbv.c:64
uint8_t * decomp_buf
Definition: zmbv.c:62
int by
Definition: zmbv.c:70
uint8_t * cur
Definition: zmbv.c:64
int(* decode_xor)(struct ZmbvContext *c)
Definition: zmbv.c:74
int bh
Definition: zmbv.c:70
int decomp_len
Definition: zmbv.c:71
int height
Definition: zmbv.c:65
int alloc_bpp
Definition: zmbv.c:60
uint8_t pal[768]
Definition: zmbv.c:63
int got_keyframe
Definition: zmbv.c:72
int flags
Definition: zmbv.c:68
int fmt
Definition: zmbv.c:66
int width
Definition: zmbv.c:65
int bpp
Definition: zmbv.c:59
int bx
Definition: zmbv.c:70
int comp
Definition: zmbv.c:67
#define av_realloc_f(p, o, n)
#define avpriv_request_sample(...)
#define av_freep(p)
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
static int16_t block[64]
Definition: dct.c:116
FILE * out
Definition: movenc.c:54
#define width
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:198
int len
static double c[64]
ZmbvFormat
Definition: zmbv.c:41
@ ZMBV_FMT_24BPP
Definition: zmbv.c:49
@ ZMBV_FMT_4BPP
Definition: zmbv.c:45
@ ZMBV_FMT_32BPP
Definition: zmbv.c:50
@ ZMBV_FMT_1BPP
Definition: zmbv.c:43
@ ZMBV_FMT_16BPP
Definition: zmbv.c:48
@ ZMBV_FMT_2BPP
Definition: zmbv.c:44
@ ZMBV_FMT_NONE
Definition: zmbv.c:42
@ ZMBV_FMT_8BPP
Definition: zmbv.c:46
@ ZMBV_FMT_15BPP
Definition: zmbv.c:47
#define ZMBV_KEYFRAME
Definition: zmbv.c:38
static int zmbv_decode_xor_16(ZmbvContext *c)
Decode XOR'ed frame - 15bpp and 16bpp version.
Definition: zmbv.c:160
#define ZMBV_DELTAPAL
Definition: zmbv.c:39
AVCodec ff_zmbv_decoder
Definition: zmbv.c:657
static av_cold int decode_init(AVCodecContext *avctx)
Definition: zmbv.c:602
static int zmbv_decode_xor_32(ZmbvContext *c)
Decode XOR'ed frame - 32bpp version.
Definition: zmbv.c:322
static av_cold int decode_end(AVCodecContext *avctx)
Definition: zmbv.c:644
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: zmbv.c:411
static int zmbv_decode_xor_8(ZmbvContext *c)
Decode XOR'ed frame - 8bpp version.
Definition: zmbv.c:81
static int zmbv_decode_intra(ZmbvContext *c)
Decode intraframe.
Definition: zmbv.c:397