FFmpeg
vb.c
Go to the documentation of this file.
1 /*
2  * Beam Software VB decoder
3  * Copyright (c) 2007 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  * VB Video decoder
25  */
26 
27 #include <stdio.h>
28 #include <stdlib.h>
29 
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "internal.h"
33 
34 enum VBFlags {
35  VB_HAS_GMC = 0x01,
36  VB_HAS_AUDIO = 0x04,
37  VB_HAS_VIDEO = 0x08,
40 };
41 
42 typedef struct VBDecContext {
44 
46  uint32_t pal[AVPALETTE_COUNT];
48 } VBDecContext;
49 
50 static const uint16_t vb_patterns[64] = {
51  0x0660, 0xFF00, 0xCCCC, 0xF000, 0x8888, 0x000F, 0x1111, 0xFEC8,
52  0x8CEF, 0x137F, 0xF731, 0xC800, 0x008C, 0x0013, 0x3100, 0xCC00,
53  0x00CC, 0x0033, 0x3300, 0x0FF0, 0x6666, 0x00F0, 0x0F00, 0x2222,
54  0x4444, 0xF600, 0x8CC8, 0x006F, 0x1331, 0x318C, 0xC813, 0x33CC,
55  0x6600, 0x0CC0, 0x0066, 0x0330, 0xF900, 0xC88C, 0x009F, 0x3113,
56  0x6000, 0x0880, 0x0006, 0x0110, 0xCC88, 0xFC00, 0x00CF, 0x88CC,
57  0x003F, 0x1133, 0x3311, 0xF300, 0x6FF6, 0x0603, 0x08C6, 0x8C63,
58  0xC631, 0x6310, 0xC060, 0x0136, 0x136C, 0x36C8, 0x6C80, 0x324C
59 };
60 
61 static void vb_decode_palette(VBDecContext *c, int data_size)
62 {
63  int start, size, i;
64 
65  start = bytestream2_get_byte(&c->stream);
66  size = (bytestream2_get_byte(&c->stream) - 1) & 0xFF;
67  if (start + size > 255) {
68  av_log(c->avctx, AV_LOG_ERROR, "Palette change runs beyond entry 256\n");
69  return;
70  }
71  if (size*3+2 > data_size) {
72  av_log(c->avctx, AV_LOG_ERROR, "Palette data runs beyond chunk size\n");
73  return;
74  }
75  for (i = start; i <= start + size; i++)
76  c->pal[i] = 0xFFU << 24 | bytestream2_get_be24(&c->stream);
77 }
78 
79 static inline int check_pixel(uint8_t *buf, uint8_t *start, uint8_t *end)
80 {
81  return buf >= start && buf < end;
82 }
83 
84 static inline int check_line(uint8_t *buf, uint8_t *start, uint8_t *end)
85 {
86  return buf >= start && (buf + 4) <= end;
87 }
88 
90 {
92  uint8_t *prev, *cur;
93  int blk, blocks, t, blk2;
94  int blocktypes = 0;
95  int x, y, a, b;
96  int pattype, pattern;
97  const int width = c->avctx->width;
98  uint8_t *pstart = c->prev_frame;
99  uint8_t *pend = c->prev_frame + width*c->avctx->height;
100 
101  g = c->stream;
102 
103  prev = c->prev_frame + offset;
104  cur = c->frame;
105 
106  blocks = (c->avctx->width >> 2) * (c->avctx->height >> 2);
107  blk2 = 0;
108  for (blk = 0; blk < blocks; blk++) {
109  if (!(blk & 3)) {
110  if (bytestream2_get_bytes_left(&g) < 1) {
111  av_log(c->avctx, AV_LOG_ERROR, "Insufficient data\n");
112  return AVERROR_INVALIDDATA;
113  }
114  blocktypes = bytestream2_get_byte(&g);
115  }
116  switch (blocktypes & 0xC0) {
117  case 0x00: //skip
118  for (y = 0; y < 4; y++)
119  if (check_line(prev + y*width, pstart, pend))
120  memcpy(cur + y*width, prev + y*width, 4);
121  else
122  memset(cur + y*width, 0, 4);
123  break;
124  case 0x40:
125  t = bytestream2_get_byte(&g);
126  if (!t) { //raw block
127  if (bytestream2_get_bytes_left(&g) < 16) {
128  av_log(c->avctx, AV_LOG_ERROR, "Insufficient data\n");
129  return AVERROR_INVALIDDATA;
130  }
131  for (y = 0; y < 4; y++)
132  bytestream2_get_buffer(&g, cur + y * width, 4);
133  } else { // motion compensation
134  x = ((t & 0xF)^8) - 8;
135  y = ((t >> 4) ^8) - 8;
136  t = x + y*width;
137  for (y = 0; y < 4; y++)
138  if (check_line(prev + t + y*width, pstart, pend))
139  memcpy(cur + y*width, prev + t + y*width, 4);
140  else
141  memset(cur + y*width, 0, 4);
142  }
143  break;
144  case 0x80: // fill
145  t = bytestream2_get_byte(&g);
146  for (y = 0; y < 4; y++)
147  memset(cur + y*width, t, 4);
148  break;
149  case 0xC0: // pattern fill
150  t = bytestream2_get_byte(&g);
151  pattype = t >> 6;
152  pattern = vb_patterns[t & 0x3F];
153  switch (pattype) {
154  case 0:
155  a = bytestream2_get_byte(&g);
156  b = bytestream2_get_byte(&g);
157  for (y = 0; y < 4; y++)
158  for (x = 0; x < 4; x++, pattern >>= 1)
159  cur[x + y*width] = (pattern & 1) ? b : a;
160  break;
161  case 1:
162  pattern = ~pattern;
163  case 2:
164  a = bytestream2_get_byte(&g);
165  for (y = 0; y < 4; y++)
166  for (x = 0; x < 4; x++, pattern >>= 1)
167  if (pattern & 1 && check_pixel(prev + x + y*width, pstart, pend))
168  cur[x + y*width] = prev[x + y*width];
169  else
170  cur[x + y*width] = a;
171  break;
172  case 3:
173  av_log(c->avctx, AV_LOG_ERROR, "Invalid opcode seen @%d\n", blk);
174  return AVERROR_INVALIDDATA;
175  }
176  break;
177  }
178  blocktypes <<= 2;
179  cur += 4;
180  prev += 4;
181  blk2++;
182  if (blk2 == (width >> 2)) {
183  blk2 = 0;
184  cur += width * 3;
185  prev += width * 3;
186  }
187  }
188  return 0;
189 }
190 
191 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
192  AVPacket *avpkt)
193 {
194  VBDecContext * const c = avctx->priv_data;
195  AVFrame *frame = data;
196  uint8_t *outptr, *srcptr;
197  int i, j, ret;
198  int flags;
199  uint32_t size;
200  int offset = 0;
201 
202  if (avpkt->size < 2)
203  return AVERROR_INVALIDDATA;
204 
205  bytestream2_init(&c->stream, avpkt->data, avpkt->size);
206 
207  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
208  return ret;
209 
210  flags = bytestream2_get_le16(&c->stream);
211 
212  if (flags & VB_HAS_GMC) {
213  i = (int16_t)bytestream2_get_le16(&c->stream);
214  j = (int16_t)bytestream2_get_le16(&c->stream);
215  if (FFABS(j) > avctx->height) {
216  av_log(avctx, AV_LOG_ERROR, "GMV out of range\n");
217  return AVERROR_INVALIDDATA;
218  }
219  offset = i + j * avctx->width;
220  }
221  if (flags & VB_HAS_VIDEO) {
222  size = bytestream2_get_le32(&c->stream);
223  if(size > bytestream2_get_bytes_left(&c->stream)+4 || size<4){
224  av_log(avctx, AV_LOG_ERROR, "Frame size invalid\n");
225  return -1;
226  }
227  vb_decode_framedata(c, offset);
228  bytestream2_skip(&c->stream, size - 4);
229  }
230  if (flags & VB_HAS_PALETTE) {
231  size = bytestream2_get_le32(&c->stream);
232  vb_decode_palette(c, size);
233  }
234 
235  memcpy(frame->data[1], c->pal, AVPALETTE_SIZE);
236  frame->palette_has_changed = flags & VB_HAS_PALETTE;
237 
238  outptr = frame->data[0];
239  srcptr = c->frame;
240 
241  for (i = 0; i < avctx->height; i++) {
242  memcpy(outptr, srcptr, avctx->width);
243  srcptr += avctx->width;
244  outptr += frame->linesize[0];
245  }
246 
247  FFSWAP(uint8_t*, c->frame, c->prev_frame);
248 
249  *got_frame = 1;
250 
251  /* always report that the buffer was completely consumed */
252  return avpkt->size;
253 }
254 
256 {
257  VBDecContext * const c = avctx->priv_data;
258 
259  c->avctx = avctx;
260  avctx->pix_fmt = AV_PIX_FMT_PAL8;
261 
262  c->frame = av_mallocz(avctx->width * avctx->height);
263  c->prev_frame = av_mallocz(avctx->width * avctx->height);
264 
265  if (!c->frame || !c->prev_frame) {
266  av_freep(&c->frame);
267  av_freep(&c->prev_frame);
268  return AVERROR(ENOMEM);
269  }
270 
271  return 0;
272 }
273 
275 {
276  VBDecContext *c = avctx->priv_data;
277 
278  av_freep(&c->frame);
279  av_freep(&c->prev_frame);
280 
281  return 0;
282 }
283 
285  .name = "vb",
286  .long_name = NULL_IF_CONFIG_SMALL("Beam Software VB"),
287  .type = AVMEDIA_TYPE_VIDEO,
288  .id = AV_CODEC_ID_VB,
289  .priv_data_size = sizeof(VBDecContext),
290  .init = decode_init,
291  .close = decode_end,
292  .decode = decode_frame,
293  .capabilities = AV_CODEC_CAP_DR1,
294 };
static int check_line(uint8_t *buf, uint8_t *start, uint8_t *end)
Definition: vb.c:84
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
GetByteContext stream
Definition: vb.c:47
int size
Definition: avcodec.h:1480
static av_cold int decode_end(AVCodecContext *avctx)
Definition: vb.c:274
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1777
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
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
uint32_t pal[AVPALETTE_COUNT]
Definition: vb.c:46
#define blk(i)
Definition: sha.c:185
uint8_t * frame
Definition: vb.c:45
AVCodec.
Definition: avcodec.h:3483
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
uint8_t
#define av_cold
Definition: attributes.h:82
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
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 offset
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: vb.c:191
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
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
uint8_t * data
Definition: avcodec.h:1479
ptrdiff_t size
Definition: opengl_enc.c:100
#define av_log(a,...)
#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
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
uint8_t * prev_frame
Definition: vb.c:45
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:263
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
const char * name
Name of the codec implementation.
Definition: avcodec.h:3490
static const uint16_t vb_patterns[64]
Definition: vb.c:50
#define b
Definition: input.c:41
AVCodec ff_vb_decoder
Definition: vb.c:284
#define width
int width
picture width / height.
Definition: avcodec.h:1740
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
Definition: vb.c:35
Libavcodec external API header.
static int check_pixel(uint8_t *buf, uint8_t *start, uint8_t *end)
Definition: vb.c:79
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:1567
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1963
void * buf
Definition: avisynth_c.h:766
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:452
VBFlags
Definition: vb.c:34
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
#define flags(name, subs,...)
Definition: cbs_av1.c:561
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
common internal api header.
static void vb_decode_palette(VBDecContext *c, int data_size)
Definition: vb.c:61
void * priv_data
Definition: avcodec.h:1594
AVCodecContext * avctx
Definition: vb.c:43
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
#define FFSWAP(type, a, b)
Definition: common.h:99
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:1456
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:983
static int vb_decode_framedata(VBDecContext *c, int offset)
Definition: vb.c:89
static av_cold int decode_init(AVCodecContext *avctx)
Definition: vb.c:255