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 "avcodec.h"
28 #include "bytestream.h"
29 #include "codec_internal.h"
30 #include "decode.h"
31 
32 enum VBFlags {
33  VB_HAS_GMC = 0x01,
34  VB_HAS_AUDIO = 0x04,
35  VB_HAS_VIDEO = 0x08,
38 };
39 
40 typedef struct VBDecContext {
42 
43  uint8_t *frame, *prev_frame;
44  uint32_t pal[AVPALETTE_COUNT];
46 } VBDecContext;
47 
48 static const uint16_t vb_patterns[64] = {
49  0x0660, 0xFF00, 0xCCCC, 0xF000, 0x8888, 0x000F, 0x1111, 0xFEC8,
50  0x8CEF, 0x137F, 0xF731, 0xC800, 0x008C, 0x0013, 0x3100, 0xCC00,
51  0x00CC, 0x0033, 0x3300, 0x0FF0, 0x6666, 0x00F0, 0x0F00, 0x2222,
52  0x4444, 0xF600, 0x8CC8, 0x006F, 0x1331, 0x318C, 0xC813, 0x33CC,
53  0x6600, 0x0CC0, 0x0066, 0x0330, 0xF900, 0xC88C, 0x009F, 0x3113,
54  0x6000, 0x0880, 0x0006, 0x0110, 0xCC88, 0xFC00, 0x00CF, 0x88CC,
55  0x003F, 0x1133, 0x3311, 0xF300, 0x6FF6, 0x0603, 0x08C6, 0x8C63,
56  0xC631, 0x6310, 0xC060, 0x0136, 0x136C, 0x36C8, 0x6C80, 0x324C
57 };
58 
59 static void vb_decode_palette(VBDecContext *c, int data_size)
60 {
61  int start, size, i;
62 
63  start = bytestream2_get_byte(&c->stream);
64  size = (bytestream2_get_byte(&c->stream) - 1) & 0xFF;
65  if (start + size > 255) {
66  av_log(c->avctx, AV_LOG_ERROR, "Palette change runs beyond entry 256\n");
67  return;
68  }
69  if (size*3+2 > data_size) {
70  av_log(c->avctx, AV_LOG_ERROR, "Palette data runs beyond chunk size\n");
71  return;
72  }
73  for (i = start; i <= start + size; i++)
74  c->pal[i] = 0xFFU << 24 | bytestream2_get_be24(&c->stream);
75 }
76 
77 static inline int check_pixel(uint8_t *buf, uint8_t *start, uint8_t *end)
78 {
79  return buf >= start && buf < end;
80 }
81 
82 static inline int check_line(uint8_t *buf, uint8_t *start, uint8_t *end)
83 {
84  return buf >= start && (buf + 4) <= end;
85 }
86 
88 {
90  uint8_t *prev, *cur;
91  int blk, blocks, t, blk2;
92  int blocktypes = 0;
93  int x, y, a, b;
94  int pattype, pattern;
95  const int width = c->avctx->width;
96  uint8_t *pstart = c->prev_frame;
97  uint8_t *pend = c->prev_frame + width*c->avctx->height;
98 
99  g = c->stream;
100 
101  prev = c->prev_frame + offset;
102  cur = c->frame;
103 
104  blocks = (c->avctx->width >> 2) * (c->avctx->height >> 2);
105  blk2 = 0;
106  for (blk = 0; blk < blocks; blk++) {
107  if (!(blk & 3)) {
108  if (bytestream2_get_bytes_left(&g) < 1) {
109  av_log(c->avctx, AV_LOG_ERROR, "Insufficient data\n");
110  return AVERROR_INVALIDDATA;
111  }
112  blocktypes = bytestream2_get_byte(&g);
113  }
114  switch (blocktypes & 0xC0) {
115  case 0x00: //skip
116  for (y = 0; y < 4; y++)
117  if (check_line(prev + y*width, pstart, pend))
118  memcpy(cur + y*width, prev + y*width, 4);
119  else
120  memset(cur + y*width, 0, 4);
121  break;
122  case 0x40:
123  t = bytestream2_get_byte(&g);
124  if (!t) { //raw block
125  if (bytestream2_get_bytes_left(&g) < 16) {
126  av_log(c->avctx, AV_LOG_ERROR, "Insufficient data\n");
127  return AVERROR_INVALIDDATA;
128  }
129  for (y = 0; y < 4; y++)
130  bytestream2_get_buffer(&g, cur + y * width, 4);
131  } else { // motion compensation
132  x = ((t & 0xF)^8) - 8;
133  y = ((t >> 4) ^8) - 8;
134  t = x + y*width;
135  for (y = 0; y < 4; y++)
136  if (check_line(prev + t + y*width, pstart, pend))
137  memcpy(cur + y*width, prev + t + y*width, 4);
138  else
139  memset(cur + y*width, 0, 4);
140  }
141  break;
142  case 0x80: // fill
143  t = bytestream2_get_byte(&g);
144  for (y = 0; y < 4; y++)
145  memset(cur + y*width, t, 4);
146  break;
147  case 0xC0: // pattern fill
148  t = bytestream2_get_byte(&g);
149  pattype = t >> 6;
150  pattern = vb_patterns[t & 0x3F];
151  switch (pattype) {
152  case 0:
153  a = bytestream2_get_byte(&g);
154  b = bytestream2_get_byte(&g);
155  for (y = 0; y < 4; y++)
156  for (x = 0; x < 4; x++, pattern >>= 1)
157  cur[x + y*width] = (pattern & 1) ? b : a;
158  break;
159  case 1:
160  pattern = ~pattern;
161  case 2:
162  a = bytestream2_get_byte(&g);
163  for (y = 0; y < 4; y++)
164  for (x = 0; x < 4; x++, pattern >>= 1)
165  if (pattern & 1 && check_pixel(prev + x + y*width, pstart, pend))
166  cur[x + y*width] = prev[x + y*width];
167  else
168  cur[x + y*width] = a;
169  break;
170  case 3:
171  av_log(c->avctx, AV_LOG_ERROR, "Invalid opcode seen @%d\n", blk);
172  return AVERROR_INVALIDDATA;
173  }
174  break;
175  }
176  blocktypes <<= 2;
177  cur += 4;
178  prev += 4;
179  blk2++;
180  if (blk2 == (width >> 2)) {
181  blk2 = 0;
182  cur += width * 3;
183  prev += width * 3;
184  }
185  }
186  return 0;
187 }
188 
190  int *got_frame, AVPacket *avpkt)
191 {
192  VBDecContext * const c = avctx->priv_data;
193  uint8_t *outptr, *srcptr;
194  int i, j, ret;
195  int flags;
196  uint32_t size;
197  int offset = 0;
198 
199  if (avpkt->size < 2)
200  return AVERROR_INVALIDDATA;
201 
202  bytestream2_init(&c->stream, avpkt->data, avpkt->size);
203 
204  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
205  return ret;
206 
207  flags = bytestream2_get_le16(&c->stream);
208 
209  if (flags & VB_HAS_GMC) {
210  i = (int16_t)bytestream2_get_le16(&c->stream);
211  j = (int16_t)bytestream2_get_le16(&c->stream);
212  if (FFABS(j) > avctx->height) {
213  av_log(avctx, AV_LOG_ERROR, "GMV out of range\n");
214  return AVERROR_INVALIDDATA;
215  }
216  offset = i + j * avctx->width;
217  }
218  if (flags & VB_HAS_VIDEO) {
219  size = bytestream2_get_le32(&c->stream);
220  if(size > bytestream2_get_bytes_left(&c->stream)+4 || size<4){
221  av_log(avctx, AV_LOG_ERROR, "Frame size invalid\n");
222  return -1;
223  }
225  bytestream2_skip(&c->stream, size - 4);
226  }
227  if (flags & VB_HAS_PALETTE) {
228  size = bytestream2_get_le32(&c->stream);
230  }
231 
232  memcpy(frame->data[1], c->pal, AVPALETTE_SIZE);
233 #if FF_API_PALETTE_HAS_CHANGED
237 #endif
238 
239  outptr = frame->data[0];
240  srcptr = c->frame;
241 
242  for (i = 0; i < avctx->height; i++) {
243  memcpy(outptr, srcptr, avctx->width);
244  srcptr += avctx->width;
245  outptr += frame->linesize[0];
246  }
247 
248  FFSWAP(uint8_t*, c->frame, c->prev_frame);
249 
250  *got_frame = 1;
251 
252  /* always report that the buffer was completely consumed */
253  return avpkt->size;
254 }
255 
257 {
258  VBDecContext * const c = avctx->priv_data;
259 
260  c->avctx = avctx;
261  avctx->pix_fmt = AV_PIX_FMT_PAL8;
262 
263  c->frame = av_mallocz(avctx->width * avctx->height);
264  c->prev_frame = av_mallocz(avctx->width * avctx->height);
265 
266  if (!c->frame || !c->prev_frame)
267  return AVERROR(ENOMEM);
268 
269  return 0;
270 }
271 
273 {
274  VBDecContext *c = avctx->priv_data;
275 
276  av_freep(&c->frame);
277  av_freep(&c->prev_frame);
278 
279  return 0;
280 }
281 
283  .p.name = "vb",
284  CODEC_LONG_NAME("Beam Software VB"),
285  .p.type = AVMEDIA_TYPE_VIDEO,
286  .p.id = AV_CODEC_ID_VB,
287  .priv_data_size = sizeof(VBDecContext),
288  .init = decode_init,
289  .close = decode_end,
291  .p.capabilities = AV_CODEC_CAP_DR1,
292  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
293 };
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
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:42
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
GetByteContext
Definition: bytestream.h:33
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVPacket::data
uint8_t * data
Definition: packet.h:522
b
#define b
Definition: input.c:41
FFCodec
Definition: codec_internal.h:127
AV_CODEC_ID_VB
@ AV_CODEC_ID_VB
Definition: codec_id.h:160
vb_decode_palette
static void vb_decode_palette(VBDecContext *c, int data_size)
Definition: vb.c:59
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
VBFlags
VBFlags
Definition: vb.c:32
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
VBDecContext::avctx
AVCodecContext * avctx
Definition: vb.c:41
vb_patterns
static const uint16_t vb_patterns[64]
Definition: vb.c:48
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:189
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
g
const char * g
Definition: vf_curves.c:127
VB_HAS_PALETTE
@ VB_HAS_PALETTE
Definition: vb.c:36
decode.h
blk
#define blk(i)
Definition: sha.c:186
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
VBDecContext::stream
GetByteContext stream
Definition: vb.c:45
frame
static AVFrame * frame
Definition: demux_decode.c:54
check_line
static int check_line(uint8_t *buf, uint8_t *start, uint8_t *end)
Definition: vb.c:82
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
ff_vb_decoder
const FFCodec ff_vb_decoder
Definition: vb.c:282
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:256
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:37
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:77
VB_HAS_AUDIO
@ VB_HAS_AUDIO
Definition: vb.c:34
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1618
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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:523
codec_internal.h
size
int size
Definition: twinvq_data.h:10344
VBDecContext
Definition: vb.c:40
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:44
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:245
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:254
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
vb_decode_framedata
static int vb_decode_framedata(VBDecContext *c, int offset)
Definition: vb.c:87
AVCodecContext
main external API structure.
Definition: avcodec.h:445
VB_HAS_GMC
@ VB_HAS_GMC
Definition: vb.c:33
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: vb.c:272
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
VBDecContext::frame
uint8_t * frame
Definition: vb.c:43
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:499
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
VBDecContext::prev_frame
uint8_t * prev_frame
Definition: vb.c:43
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
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:474
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
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
VB_HAS_VIDEO
@ VB_HAS_VIDEO
Definition: vb.c:35