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  }
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  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 };
AVCodec
AVCodec.
Definition: avcodec.h:3481
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
GetByteContext
Definition: bytestream.h:33
ff_vb_decoder
AVCodec ff_vb_decoder
Definition: vb.c:284
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:91
AV_CODEC_ID_VB
@ AV_CODEC_ID_VB
Definition: avcodec.h:326
vb_decode_palette
static void vb_decode_palette(VBDecContext *c, int data_size)
Definition: vb.c:61
bytestream2_get_bytes_left
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
VBFlags
VBFlags
Definition: vb.c:34
start
void INT64 start
Definition: avisynth_c.h:767
VBDecContext::avctx
AVCodecContext * avctx
Definition: vb.c:43
vb_patterns
static const uint16_t vb_patterns[64]
Definition: vb.c:50
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
width
#define width
g
const char * g
Definition: vf_curves.c:115
VB_HAS_PALETTE
@ VB_HAS_PALETTE
Definition: vb.c:38
blk
#define blk(i)
Definition: sha.c:185
VBDecContext::stream
GetByteContext stream
Definition: vb.c:47
check_line
static int check_line(uint8_t *buf, uint8_t *start, uint8_t *end)
Definition: vb.c:84
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
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:263
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:39
check_pixel
static int check_pixel(uint8_t *buf, uint8_t *start, uint8_t *end)
Definition: vb.c:79
VB_HAS_AUDIO
@ VB_HAS_AUDIO
Definition: vb.c:36
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1965
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
AVPacket::size
int size
Definition: avcodec.h:1478
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:188
size
int size
Definition: twinvq_data.h:11134
VBDecContext
Definition: vb.c:42
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:46
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
uint8_t
uint8_t
Definition: audio_convert.c:194
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:236
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
AVCodecContext::height
int height
Definition: avcodec.h:1738
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
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
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:89
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
VB_HAS_GMC
@ VB_HAS_GMC
Definition: vb.c:35
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: vb.c:191
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: vb.c:274
VBDecContext::frame
uint8_t * frame
Definition: vb.c:45
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
VBDecContext::prev_frame
uint8_t * prev_frame
Definition: vb.c:45
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1738
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
VB_HAS_VIDEO
@ VB_HAS_VIDEO
Definition: vb.c:37