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 "codec_internal.h"
33 #include "internal.h"
34 
35 enum VBFlags {
36  VB_HAS_GMC = 0x01,
37  VB_HAS_AUDIO = 0x04,
38  VB_HAS_VIDEO = 0x08,
41 };
42 
43 typedef struct VBDecContext {
45 
46  uint8_t *frame, *prev_frame;
47  uint32_t pal[AVPALETTE_COUNT];
49 } VBDecContext;
50 
51 static const uint16_t vb_patterns[64] = {
52  0x0660, 0xFF00, 0xCCCC, 0xF000, 0x8888, 0x000F, 0x1111, 0xFEC8,
53  0x8CEF, 0x137F, 0xF731, 0xC800, 0x008C, 0x0013, 0x3100, 0xCC00,
54  0x00CC, 0x0033, 0x3300, 0x0FF0, 0x6666, 0x00F0, 0x0F00, 0x2222,
55  0x4444, 0xF600, 0x8CC8, 0x006F, 0x1331, 0x318C, 0xC813, 0x33CC,
56  0x6600, 0x0CC0, 0x0066, 0x0330, 0xF900, 0xC88C, 0x009F, 0x3113,
57  0x6000, 0x0880, 0x0006, 0x0110, 0xCC88, 0xFC00, 0x00CF, 0x88CC,
58  0x003F, 0x1133, 0x3311, 0xF300, 0x6FF6, 0x0603, 0x08C6, 0x8C63,
59  0xC631, 0x6310, 0xC060, 0x0136, 0x136C, 0x36C8, 0x6C80, 0x324C
60 };
61 
62 static void vb_decode_palette(VBDecContext *c, int data_size)
63 {
64  int start, size, i;
65 
66  start = bytestream2_get_byte(&c->stream);
67  size = (bytestream2_get_byte(&c->stream) - 1) & 0xFF;
68  if (start + size > 255) {
69  av_log(c->avctx, AV_LOG_ERROR, "Palette change runs beyond entry 256\n");
70  return;
71  }
72  if (size*3+2 > data_size) {
73  av_log(c->avctx, AV_LOG_ERROR, "Palette data runs beyond chunk size\n");
74  return;
75  }
76  for (i = start; i <= start + size; i++)
77  c->pal[i] = 0xFFU << 24 | bytestream2_get_be24(&c->stream);
78 }
79 
80 static inline int check_pixel(uint8_t *buf, uint8_t *start, uint8_t *end)
81 {
82  return buf >= start && buf < end;
83 }
84 
85 static inline int check_line(uint8_t *buf, uint8_t *start, uint8_t *end)
86 {
87  return buf >= start && (buf + 4) <= end;
88 }
89 
91 {
93  uint8_t *prev, *cur;
94  int blk, blocks, t, blk2;
95  int blocktypes = 0;
96  int x, y, a, b;
97  int pattype, pattern;
98  const int width = c->avctx->width;
99  uint8_t *pstart = c->prev_frame;
100  uint8_t *pend = c->prev_frame + width*c->avctx->height;
101 
102  g = c->stream;
103 
104  prev = c->prev_frame + offset;
105  cur = c->frame;
106 
107  blocks = (c->avctx->width >> 2) * (c->avctx->height >> 2);
108  blk2 = 0;
109  for (blk = 0; blk < blocks; blk++) {
110  if (!(blk & 3)) {
111  if (bytestream2_get_bytes_left(&g) < 1) {
112  av_log(c->avctx, AV_LOG_ERROR, "Insufficient data\n");
113  return AVERROR_INVALIDDATA;
114  }
115  blocktypes = bytestream2_get_byte(&g);
116  }
117  switch (blocktypes & 0xC0) {
118  case 0x00: //skip
119  for (y = 0; y < 4; y++)
120  if (check_line(prev + y*width, pstart, pend))
121  memcpy(cur + y*width, prev + y*width, 4);
122  else
123  memset(cur + y*width, 0, 4);
124  break;
125  case 0x40:
126  t = bytestream2_get_byte(&g);
127  if (!t) { //raw block
128  if (bytestream2_get_bytes_left(&g) < 16) {
129  av_log(c->avctx, AV_LOG_ERROR, "Insufficient data\n");
130  return AVERROR_INVALIDDATA;
131  }
132  for (y = 0; y < 4; y++)
133  bytestream2_get_buffer(&g, cur + y * width, 4);
134  } else { // motion compensation
135  x = ((t & 0xF)^8) - 8;
136  y = ((t >> 4) ^8) - 8;
137  t = x + y*width;
138  for (y = 0; y < 4; y++)
139  if (check_line(prev + t + y*width, pstart, pend))
140  memcpy(cur + y*width, prev + t + y*width, 4);
141  else
142  memset(cur + y*width, 0, 4);
143  }
144  break;
145  case 0x80: // fill
146  t = bytestream2_get_byte(&g);
147  for (y = 0; y < 4; y++)
148  memset(cur + y*width, t, 4);
149  break;
150  case 0xC0: // pattern fill
151  t = bytestream2_get_byte(&g);
152  pattype = t >> 6;
153  pattern = vb_patterns[t & 0x3F];
154  switch (pattype) {
155  case 0:
156  a = bytestream2_get_byte(&g);
157  b = bytestream2_get_byte(&g);
158  for (y = 0; y < 4; y++)
159  for (x = 0; x < 4; x++, pattern >>= 1)
160  cur[x + y*width] = (pattern & 1) ? b : a;
161  break;
162  case 1:
163  pattern = ~pattern;
164  case 2:
165  a = bytestream2_get_byte(&g);
166  for (y = 0; y < 4; y++)
167  for (x = 0; x < 4; x++, pattern >>= 1)
168  if (pattern & 1 && check_pixel(prev + x + y*width, pstart, pend))
169  cur[x + y*width] = prev[x + y*width];
170  else
171  cur[x + y*width] = a;
172  break;
173  case 3:
174  av_log(c->avctx, AV_LOG_ERROR, "Invalid opcode seen @%d\n", blk);
175  return AVERROR_INVALIDDATA;
176  }
177  break;
178  }
179  blocktypes <<= 2;
180  cur += 4;
181  prev += 4;
182  blk2++;
183  if (blk2 == (width >> 2)) {
184  blk2 = 0;
185  cur += width * 3;
186  prev += width * 3;
187  }
188  }
189  return 0;
190 }
191 
193  int *got_frame, AVPacket *avpkt)
194 {
195  VBDecContext * const c = avctx->priv_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  }
228  bytestream2_skip(&c->stream, size - 4);
229  }
230  if (flags & VB_HAS_PALETTE) {
231  size = bytestream2_get_le32(&c->stream);
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  return AVERROR(ENOMEM);
267 
268  return 0;
269 }
270 
272 {
273  VBDecContext *c = avctx->priv_data;
274 
275  av_freep(&c->frame);
276  av_freep(&c->prev_frame);
277 
278  return 0;
279 }
280 
282  .p.name = "vb",
283  .p.long_name = NULL_IF_CONFIG_SMALL("Beam Software VB"),
284  .p.type = AVMEDIA_TYPE_VIDEO,
285  .p.id = AV_CODEC_ID_VB,
286  .priv_data_size = sizeof(VBDecContext),
287  .init = decode_init,
288  .close = decode_end,
290  .p.capabilities = AV_CODEC_CAP_DR1,
291  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
292 };
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:41
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
GetByteContext
Definition: bytestream.h:33
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
b
#define b
Definition: input.c:34
FFCodec
Definition: codec_internal.h:118
AV_CODEC_ID_VB
@ AV_CODEC_ID_VB
Definition: codec_id.h:158
vb_decode_palette
static void vb_decode_palette(VBDecContext *c, int data_size)
Definition: vb.c:62
init
static int init
Definition: av_tx.c:47
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
VBFlags
VBFlags
Definition: vb.c:35
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
VBDecContext::avctx
AVCodecContext * avctx
Definition: vb.c:44
vb_patterns
static const uint16_t vb_patterns[64]
Definition: vb.c:51
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
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: vb.c:192
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
g
const char * g
Definition: vf_curves.c:117
VB_HAS_PALETTE
@ VB_HAS_PALETTE
Definition: vb.c:39
blk
#define blk(i)
Definition: sha.c:186
VBDecContext::stream
GetByteContext stream
Definition: vb.c:48
check_line
static int check_line(uint8_t *buf, uint8_t *start, uint8_t *end)
Definition: vb.c:85
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
ff_vb_decoder
const FFCodec ff_vb_decoder
Definition: vb.c:281
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
bytestream2_get_buffer
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: vb.c:255
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
AVPALETTE_COUNT
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
VB_HAS_LENGTH
@ VB_HAS_LENGTH
Definition: vb.c:40
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
check_pixel
static int check_pixel(uint8_t *buf, uint8_t *start, uint8_t *end)
Definition: vb.c:80
VB_HAS_AUDIO
@ VB_HAS_AUDIO
Definition: vb.c:37
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1462
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:375
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
codec_internal.h
size
int size
Definition: twinvq_data.h:10344
VBDecContext
Definition: vb.c:43
a
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:41
offset
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
Definition: writing_filters.txt:86
VBDecContext::pal
uint32_t pal[AVPALETTE_COUNT]
Definition: vb.c:47
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
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
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
vb_decode_framedata
static int vb_decode_framedata(VBDecContext *c, int offset)
Definition: vb.c:90
AVCodecContext
main external API structure.
Definition: avcodec.h:398
VB_HAS_GMC
@ VB_HAS_GMC
Definition: vb.c:36
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: vb.c:271
VBDecContext::frame
uint8_t * frame
Definition: vb.c:46
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
VBDecContext::prev_frame
uint8_t * prev_frame
Definition: vb.c:46
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
VB_HAS_VIDEO
@ VB_HAS_VIDEO
Definition: vb.c:38