FFmpeg
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 {
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;
442  av_log(avctx, AV_LOG_DEBUG,
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;
462  avctx->pix_fmt = AV_PIX_FMT_PAL8;
463  c->stride = c->width;
464  break;
465  case ZMBV_FMT_15BPP:
466  case ZMBV_FMT_16BPP:
467  c->bpp = 16;
469  if (c->fmt == ZMBV_FMT_15BPP)
470  avctx->pix_fmt = AV_PIX_FMT_RGB555LE;
471  else
472  avctx->pix_fmt = AV_PIX_FMT_RGB565LE;
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;
479  avctx->pix_fmt = AV_PIX_FMT_BGR24;
480  c->stride = c->width * 3;
481  break;
482 #endif //ZMBV_ENABLE_24BPP
483  case ZMBV_FMT_32BPP:
484  c->bpp = 32;
486  avctx->pix_fmt = AV_PIX_FMT_BGR0;
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 = (uint8_t*)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;
560  frame->pict_type = AV_PICTURE_TYPE_I;
562  } else {
563  frame->key_frame = 0;
564  frame->pict_type = AV_PICTURE_TYPE_P;
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 */
626  if (!c->decomp_buf) {
627  av_log(avctx, AV_LOG_ERROR,
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 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:48
#define NULL
Definition: coverity.c:32
uint8_t pal[768]
Definition: zmbv.c:63
int stride
Definition: zmbv.c:69
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define av_realloc_f(p, o, n)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int decomp_len
Definition: zmbv.c:71
misc image utilities
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define avpriv_request_sample(...)
static int zmbv_decode_xor_32(ZmbvContext *c)
Decode XOR&#39;ed frame - 32bpp version.
Definition: zmbv.c:322
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: zmbv.c:411
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:108
int size
Definition: avcodec.h:1481
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
AVCodecContext * avctx
Definition: zmbv.c:57
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3492
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodec ff_zmbv_decoder
Definition: zmbv.c:657
int flags
Definition: zmbv.c:68
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
int(* decode_xor)(struct ZmbvContext *c)
Definition: zmbv.c:74
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:82
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
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
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
int comp
Definition: zmbv.c:67
uint8_t * data
Definition: avcodec.h:1480
static av_cold int decode_init(AVCodecContext *avctx)
Definition: zmbv.c:602
#define ZMBV_KEYFRAME
Definition: zmbv.c:38
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2792
#define av_log(a,...)
static int zmbv_decode_xor_8(ZmbvContext *c)
Decode XOR&#39;ed frame - 8bpp version.
Definition: zmbv.c:81
int by
Definition: zmbv.c:70
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define PTRDIFF_SPECIFIER
Definition: internal.h:261
int bx
Definition: zmbv.c:70
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ZmbvFormat
Definition: zmbv.c:41
int bw
Definition: zmbv.c:70
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
static av_cold int decode_end(AVCodecContext *avctx)
Definition: zmbv.c:644
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:3295
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define FFMIN(a, b)
Definition: common.h:96
int width
picture width / height.
Definition: avcodec.h:1741
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
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
uint8_t * decomp_buf
Definition: zmbv.c:62
int bh
Definition: zmbv.c:70
unsigned int decomp_size
Definition: zmbv.c:61
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int alloc_bpp
Definition: zmbv.c:60
Libavcodec external API header.
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_RB24
Definition: bytestream.h:87
static int zmbv_decode_xor_16(ZmbvContext *c)
Decode XOR&#39;ed frame - 15bpp and 16bpp version.
Definition: zmbv.c:160
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
main external API structure.
Definition: avcodec.h:1568
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
void * buf
Definition: avisynth_c.h:766
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:197
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
int height
Definition: zmbv.c:65
z_stream zstream
Definition: zmbv.c:73
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int bpp
Definition: zmbv.c:59
int width
Definition: zmbv.c:65
int
common internal api header.
common internal and external API header
#define AV_WN32(p, v)
Definition: intreadwrite.h:376
uint8_t * prev
Definition: zmbv.c:64
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
void * priv_data
Definition: avcodec.h:1595
int len
int fmt
Definition: zmbv.c:66
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
static int zmbv_decode_intra(ZmbvContext *c)
Decode intraframe.
Definition: zmbv.c:397
int got_keyframe
Definition: zmbv.c:72
FILE * out
Definition: movenc.c:54
#define av_freep(p)
#define ZMBV_DELTAPAL
Definition: zmbv.c:39
uint8_t * cur
Definition: zmbv.c:64
#define FFSWAP(type, a, b)
Definition: common.h:99
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:338
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
This structure stores compressed data.
Definition: avcodec.h:1457
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
Predicted.
Definition: avutil.h:275