FFmpeg: libavcodec/vb.c Source File

FFmpeg

[フレーム]

libavcodec

vb.c

Go to the documentation of this file.

1 /*

2 * Beam Software VB decoder

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 */

22 /**

23 * @file

24 * VB Video decoder

25 */

27 #include "avcodec.h"

28 #include "bytestream.h"

29 #include "codec_internal.h"

30 #include "decode.h"

32 enum VBFlags {

33 VB_HAS_GMC = 0x01,

34 VB_HAS_AUDIO = 0x04,

35 VB_HAS_VIDEO = 0x08,

36 VB_HAS_PALETTE = 0x10,

37 VB_HAS_LENGTH = 0x20

38 };

40 typedef struct VBDecContext {

41 AVCodecContext *avctx;

43 uint8_t *frame, *prev_frame;

44 uint32_t pal[AVPALETTE_COUNT];

45 GetByteContext stream;

46 } VBDecContext;

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 };

59 static void vb_decode_palette(VBDecContext *c, int data_size)

60 {

61 int start, size, i;

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 }

77 static inline int check_pixel(uint8_t *buf, uint8_t *start, uint8_t *end)

78 {

79 return buf >= start && buf < end;

80 }

82 static inline int check_line(uint8_t *buf, uint8_t *start, uint8_t *end)

83 {

84 return buf >= start && (buf + 4) <= end;

85 }

87 static int vb_decode_framedata(VBDecContext *c, int offset)

88 {

89 GetByteContext g;

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;

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

189 static int decode_frame(AVCodecContext *avctx, AVFrame *frame,

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 }

224 vb_decode_framedata(c, offset);

225 bytestream2_skip(&c->stream, size - 4);

226 }

227 if (flags & VB_HAS_PALETTE) {

228 size = bytestream2_get_le32(&c->stream);

229 vb_decode_palette(c, size);

230 }

231

232 memcpy(frame->data[1], c->pal, AVPALETTE_SIZE);

233 frame->palette_has_changed = flags & VB_HAS_PALETTE;

234

235 outptr = frame->data[0];

236 srcptr = c->frame;

237

238 for (i = 0; i < avctx->height; i++) {

239 memcpy(outptr, srcptr, avctx->width);

240 srcptr += avctx->width;

241 outptr += frame->linesize[0];

242 }

243

244 FFSWAP(uint8_t*, c->frame, c->prev_frame);

245

246 *got_frame = 1;

247

248 /* always report that the buffer was completely consumed */

249 return avpkt->size;

250 }

251

252 static av_cold int decode_init(AVCodecContext *avctx)

253 {

254 VBDecContext * const c = avctx->priv_data;

255

256 c->avctx = avctx;

257 avctx->pix_fmt = AV_PIX_FMT_PAL8;

258

259 c->frame = av_mallocz(avctx->width * avctx->height);

260 c->prev_frame = av_mallocz(avctx->width * avctx->height);

261

262 if (!c->frame || !c->prev_frame)

263 return AVERROR(ENOMEM);

264

265 return 0;

266 }

267

268 static av_cold int decode_end(AVCodecContext *avctx)

269 {

270 VBDecContext *c = avctx->priv_data;

271

272 av_freep(&c->frame);

273 av_freep(&c->prev_frame);

274

275 return 0;

276 }

277

278 const FFCodec ff_vb_decoder = {

279 .p.name = "vb",

280 CODEC_LONG_NAME("Beam Software VB"),

281 .p.type = AVMEDIA_TYPE_VIDEO,

282 .p.id = AV_CODEC_ID_VB,

283 .priv_data_size = sizeof(VBDecContext),

284 .init = decode_init,

285 .close = decode_end,

286 FF_CODEC_DECODE_CB(decode_frame),

287 .p.capabilities = AV_CODEC_CAP_DR1,

288 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

289 };

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

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:330

AVPacket::data

uint8_t * data

Definition: packet.h:374

#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

bytestream2_skip

static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)

Definition: bytestream.h:168

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

const char * g

Definition: vf_curves.c:127

VB_HAS_PALETTE

@ VB_HAS_PALETTE

Definition: vb.c:36

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:365

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

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:64

ff_vb_decoder

const FFCodec ff_vb_decoder

Definition: vb.c:278

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:252

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:1473

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

codec_internal.h

size

int size

Definition: twinvq_data.h:10344

VBDecContext

Definition: vb.c:40

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

#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:254

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:191

AVCodecContext::height

int height

Definition: avcodec.h:598

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:635

avcodec.h

AV_PIX_FMT_PAL8

@ AV_PIX_FMT_PAL8

8 bits with AV_PIX_FMT_RGB32 palette

Definition: pixfmt.h:77

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:87

AVCodecContext

main external API structure.

Definition: avcodec.h:426

VB_HAS_GMC

@ VB_HAS_GMC

Definition: vb.c:33

decode_end

static av_cold int decode_end(AVCodecContext *avctx)