FFmpeg: libavcodec/kmvc.c Source File

FFmpeg

[フレーム]

libavcodec

kmvc.c

Go to the documentation of this file.

1 /*

2 * KMVC 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 * Karl Morton's Video Codec decoder

25 */

27 #include <stdio.h>

29 #include "avcodec.h"

30 #include "bytestream.h"

31 #include "codec_internal.h"

32 #include "decode.h"

33 #include "libavutil/common.h"

35 #define KMVC_KEYFRAME 0x80

36 #define KMVC_PALETTE 0x40

37 #define KMVC_METHOD 0x0F

38 #define MAX_PALSIZE 256

40 /*

41 * Decoder context

42 */

43 typedef struct KmvcContext {

44 AVCodecContext *avctx;

46 GetByteContext g;

47 uint8_t *cur, *prev;

48 int setpal;

49 int palsize;

50 uint32_t pal[MAX_PALSIZE];

51 uint8_t frm0[320 * 200], frm1[320 * 200];

52 } KmvcContext;

54 typedef struct BitBuf {

55 int bits;

56 int bitbuf;

57 } BitBuf;

59 #define BLK(data, x, y) data[av_clip((x) + (y) * 320, 0, 320 * 200 -1)]

61 #define kmvc_init_getbits(bb, g) bb.bits = 7; bb.bitbuf = bytestream2_get_byte(g);

63 #define kmvc_getbit(bb, g, res) {\

64 res = 0; \

65 if (bb.bitbuf & (1 << bb.bits)) res = 1; \

66 bb.bits--; \

67 if(bb.bits == -1) { \

68 bb.bitbuf = bytestream2_get_byte(g); \

69 bb.bits = 7; \

70 } \

71 }

73 static int kmvc_decode_intra_8x8(KmvcContext * ctx, int w, int h)

74 {

75 BitBuf bb;

76 int res, val;

77 int i, j;

78 int bx, by;

79 int l0x, l1x, l0y, l1y;

80 int mx, my;

82 kmvc_init_getbits(bb, &ctx->g);

84 for (by = 0; by < h; by += 8)

85 for (bx = 0; bx < w; bx += 8) {

86 if (!bytestream2_get_bytes_left(&ctx->g)) {

87 av_log(ctx->avctx, AV_LOG_ERROR, "Data overrun\n");

88 return AVERROR_INVALIDDATA;

89 }

90 kmvc_getbit(bb, &ctx->g, res);

91 if (!res) { // fill whole 8x8 block

92 val = bytestream2_get_byte(&ctx->g);

93 for (i = 0; i < 64; i++)

94 BLK(ctx->cur, bx + (i & 0x7), by + (i >> 3)) = val;

95 } else { // handle four 4x4 subblocks

96 for (i = 0; i < 4; i++) {

97 l0x = bx + (i & 1) * 4;

98 l0y = by + (i & 2) * 2;

99 kmvc_getbit(bb, &ctx->g, res);

100 if (!res) {

101 kmvc_getbit(bb, &ctx->g, res);

102 if (!res) { // fill whole 4x4 block

103 val = bytestream2_get_byte(&ctx->g);

104 for (j = 0; j < 16; j++)

105 BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) = val;

106 } else { // copy block from already decoded place

107 val = bytestream2_get_byte(&ctx->g);

108 mx = val & 0xF;

109 my = val >> 4;

110 if ((l0x-mx) + 320*(l0y-my) < 0 || (l0x-mx) + 320*(l0y-my) > 320*197 - 4) {

111 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n");

112 return AVERROR_INVALIDDATA;

113 }

114 for (j = 0; j < 16; j++)

115 BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) =

116 BLK(ctx->cur, l0x + (j & 3) - mx, l0y + (j >> 2) - my);

117 }

118 } else { // descend to 2x2 sub-sub-blocks

119 for (j = 0; j < 4; j++) {

120 l1x = l0x + (j & 1) * 2;

121 l1y = l0y + (j & 2);

122 kmvc_getbit(bb, &ctx->g, res);

123 if (!res) {

124 kmvc_getbit(bb, &ctx->g, res);

125 if (!res) { // fill whole 2x2 block

126 val = bytestream2_get_byte(&ctx->g);

127 BLK(ctx->cur, l1x, l1y) = val;

128 BLK(ctx->cur, l1x + 1, l1y) = val;

129 BLK(ctx->cur, l1x, l1y + 1) = val;

130 BLK(ctx->cur, l1x + 1, l1y + 1) = val;

131 } else { // copy block from already decoded place

132 val = bytestream2_get_byte(&ctx->g);

133 mx = val & 0xF;

134 my = val >> 4;

135 if ((l1x-mx) + 320*(l1y-my) < 0 || (l1x-mx) + 320*(l1y-my) > 320*199 - 2) {

136 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n");

137 return AVERROR_INVALIDDATA;

138 }

139 BLK(ctx->cur, l1x, l1y) = BLK(ctx->cur, l1x - mx, l1y - my);

140 BLK(ctx->cur, l1x + 1, l1y) =

141 BLK(ctx->cur, l1x + 1 - mx, l1y - my);

142 BLK(ctx->cur, l1x, l1y + 1) =

143 BLK(ctx->cur, l1x - mx, l1y + 1 - my);

144 BLK(ctx->cur, l1x + 1, l1y + 1) =

145 BLK(ctx->cur, l1x + 1 - mx, l1y + 1 - my);

146 }

147 } else { // read values for block

148 BLK(ctx->cur, l1x, l1y) = bytestream2_get_byte(&ctx->g);

149 BLK(ctx->cur, l1x + 1, l1y) = bytestream2_get_byte(&ctx->g);

150 BLK(ctx->cur, l1x, l1y + 1) = bytestream2_get_byte(&ctx->g);

151 BLK(ctx->cur, l1x + 1, l1y + 1) = bytestream2_get_byte(&ctx->g);

152 }

153 }

154 }

155 }

156 }

157 }

158

159 return 0;

160 }

161

162 static int kmvc_decode_inter_8x8(KmvcContext * ctx, int w, int h)

163 {

164 BitBuf bb;

165 int res, val;

166 int i, j;

167 int bx, by;

168 int l0x, l1x, l0y, l1y;

169 int mx, my;

170

171 kmvc_init_getbits(bb, &ctx->g);

172

173 for (by = 0; by < h; by += 8)

174 for (bx = 0; bx < w; bx += 8) {

175 kmvc_getbit(bb, &ctx->g, res);

176 if (!res) {

177 kmvc_getbit(bb, &ctx->g, res);

178 if (!res) { // fill whole 8x8 block

179 if (!bytestream2_get_bytes_left(&ctx->g)) {

180 av_log(ctx->avctx, AV_LOG_ERROR, "Data overrun\n");

181 return AVERROR_INVALIDDATA;

182 }

183 val = bytestream2_get_byte(&ctx->g);

184 for (i = 0; i < 64; i++)

185 BLK(ctx->cur, bx + (i & 0x7), by + (i >> 3)) = val;

186 } else { // copy block from previous frame

187 for (i = 0; i < 64; i++)

188 BLK(ctx->cur, bx + (i & 0x7), by + (i >> 3)) =

189 BLK(ctx->prev, bx + (i & 0x7), by + (i >> 3));

190 }

191 } else { // handle four 4x4 subblocks

192 if (!bytestream2_get_bytes_left(&ctx->g)) {

193 av_log(ctx->avctx, AV_LOG_ERROR, "Data overrun\n");

194 return AVERROR_INVALIDDATA;

195 }

196 for (i = 0; i < 4; i++) {

197 l0x = bx + (i & 1) * 4;

198 l0y = by + (i & 2) * 2;

199 kmvc_getbit(bb, &ctx->g, res);

200 if (!res) {

201 kmvc_getbit(bb, &ctx->g, res);

202 if (!res) { // fill whole 4x4 block

203 val = bytestream2_get_byte(&ctx->g);

204 for (j = 0; j < 16; j++)

205 BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) = val;

206 } else { // copy block

207 val = bytestream2_get_byte(&ctx->g);

208 mx = (val & 0xF) - 8;

209 my = (val >> 4) - 8;

210 if ((l0x+mx) + 320*(l0y+my) < 0 || (l0x+mx) + 320*(l0y+my) > 320*197 - 4) {

211 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n");

212 return AVERROR_INVALIDDATA;

213 }

214 for (j = 0; j < 16; j++)

215 BLK(ctx->cur, l0x + (j & 3), l0y + (j >> 2)) =

216 BLK(ctx->prev, l0x + (j & 3) + mx, l0y + (j >> 2) + my);

217 }

218 } else { // descend to 2x2 sub-sub-blocks

219 for (j = 0; j < 4; j++) {

220 l1x = l0x + (j & 1) * 2;

221 l1y = l0y + (j & 2);

222 kmvc_getbit(bb, &ctx->g, res);

223 if (!res) {

224 kmvc_getbit(bb, &ctx->g, res);

225 if (!res) { // fill whole 2x2 block

226 val = bytestream2_get_byte(&ctx->g);

227 BLK(ctx->cur, l1x, l1y) = val;

228 BLK(ctx->cur, l1x + 1, l1y) = val;

229 BLK(ctx->cur, l1x, l1y + 1) = val;

230 BLK(ctx->cur, l1x + 1, l1y + 1) = val;

231 } else { // copy block

232 val = bytestream2_get_byte(&ctx->g);

233 mx = (val & 0xF) - 8;

234 my = (val >> 4) - 8;

235 if ((l1x+mx) + 320*(l1y+my) < 0 || (l1x+mx) + 320*(l1y+my) > 320*199 - 2) {

236 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid MV\n");

237 return AVERROR_INVALIDDATA;

238 }

239 BLK(ctx->cur, l1x, l1y) = BLK(ctx->prev, l1x + mx, l1y + my);

240 BLK(ctx->cur, l1x + 1, l1y) =

241 BLK(ctx->prev, l1x + 1 + mx, l1y + my);

242 BLK(ctx->cur, l1x, l1y + 1) =

243 BLK(ctx->prev, l1x + mx, l1y + 1 + my);

244 BLK(ctx->cur, l1x + 1, l1y + 1) =

245 BLK(ctx->prev, l1x + 1 + mx, l1y + 1 + my);

246 }

247 } else { // read values for block

248 BLK(ctx->cur, l1x, l1y) = bytestream2_get_byte(&ctx->g);

249 BLK(ctx->cur, l1x + 1, l1y) = bytestream2_get_byte(&ctx->g);

250 BLK(ctx->cur, l1x, l1y + 1) = bytestream2_get_byte(&ctx->g);

251 BLK(ctx->cur, l1x + 1, l1y + 1) = bytestream2_get_byte(&ctx->g);

252 }

253 }

254 }

255 }

256 }

257 }

258

259 return 0;

260 }

261

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

263 int *got_frame, AVPacket *avpkt)

264 {

265 KmvcContext *const ctx = avctx->priv_data;

266 uint8_t *out, *src;

267 int i, ret;

268 int header;

269 int blocksize;

270

271 bytestream2_init(&ctx->g, avpkt->data, avpkt->size);

272

273 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

274 return ret;

275

276 frame->palette_has_changed = ff_copy_palette(ctx->pal, avpkt, avctx);

277

278 header = bytestream2_get_byte(&ctx->g);

279

280 /* blocksize 127 is really palette change event */

281 if (bytestream2_peek_byte(&ctx->g) == 127) {

282 bytestream2_skip(&ctx->g, 3);

283 for (i = 0; i < 127; i++) {

284 ctx->pal[i + (header & 0x81)] = 0xFFU << 24 | bytestream2_get_be24(&ctx->g);

285 bytestream2_skip(&ctx->g, 1);

286 }

287 bytestream2_seek(&ctx->g, -127 * 4 - 3, SEEK_CUR);

288 }

289

290 if (header & KMVC_KEYFRAME) {

291 frame->key_frame = 1;

292 frame->pict_type = AV_PICTURE_TYPE_I;

293 } else {

294 frame->key_frame = 0;

295 frame->pict_type = AV_PICTURE_TYPE_P;

296 }

297

298 if (header & KMVC_PALETTE) {

299 frame->palette_has_changed = 1;

300 // palette starts from index 1 and has 127 entries

301 for (i = 1; i <= ctx->palsize; i++) {

302 ctx->pal[i] = 0xFFU << 24 | bytestream2_get_be24(&ctx->g);

303 }

304 }

305

306 if (ctx->setpal) {

307 ctx->setpal = 0;

308 frame->palette_has_changed = 1;

309 }

310

311 /* make the palette available on the way out */

312 memcpy(frame->data[1], ctx->pal, 1024);

313

314 blocksize = bytestream2_get_byte(&ctx->g);

315

316 if (blocksize != 8 && blocksize != 127) {

317 av_log(avctx, AV_LOG_ERROR, "Block size = %i\n", blocksize);

318 return AVERROR_INVALIDDATA;

319 }

320 memset(ctx->cur, 0, 320 * 200);

321 switch (header & KMVC_METHOD) {

322 case 0:

323 case 1: // used in palette changed event

324 memcpy(ctx->cur, ctx->prev, 320 * 200);

325 break;

326 case 3:

327 kmvc_decode_intra_8x8(ctx, avctx->width, avctx->height);

328 break;

329 case 4:

330 kmvc_decode_inter_8x8(ctx, avctx->width, avctx->height);

331 break;

332 default:

333 av_log(avctx, AV_LOG_ERROR, "Unknown compression method %i\n", header & KMVC_METHOD);

334 return AVERROR_INVALIDDATA;

335 }

336

337 out = frame->data[0];

338 src = ctx->cur;

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

340 memcpy(out, src, avctx->width);

341 src += 320;

342 out += frame->linesize[0];

343 }

344

345 /* flip buffers */

346 FFSWAP(uint8_t *, ctx->cur, ctx->prev);

347

348 *got_frame = 1;

349

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

351 return avpkt->size;

352 }

353

354

355

356 /*

357 * Init kmvc decoder

358 */

359 static av_cold int decode_init(AVCodecContext * avctx)

360 {

361 KmvcContext *const c = avctx->priv_data;

362 int i;

363

364 c->avctx = avctx;

365

366 if (avctx->width > 320 || avctx->height > 200) {

367 av_log(avctx, AV_LOG_ERROR, "KMVC supports frames <= 320x200\n");

368 return AVERROR(EINVAL);

369 }

370

371 c->cur = c->frm0;

372 c->prev = c->frm1;

373

374 for (i = 0; i < 256; i++) {

375 c->pal[i] = 0xFFU << 24 | i * 0x10101;

376 }

377

378 if (avctx->extradata_size < 12) {

379 av_log(avctx, AV_LOG_WARNING,

380 "Extradata missing, decoding may not work properly...\n");

381 c->palsize = 127;

382 } else {

383 c->palsize = AV_RL16(avctx->extradata + 10);

384 if (c->palsize >= (unsigned)MAX_PALSIZE) {

385 c->palsize = 127;

386 av_log(avctx, AV_LOG_ERROR, "KMVC palette too large\n");

387 return AVERROR_INVALIDDATA;

388 }

389 }

390

391 if (avctx->extradata_size == 1036) { // palette in extradata

392 uint8_t *src = avctx->extradata + 12;

393 for (i = 0; i < 256; i++) {

394 c->pal[i] = AV_RL32(src);

395 src += 4;

396 }

397 c->setpal = 1;

398 }

399

400 avctx->pix_fmt = AV_PIX_FMT_PAL8;

401

402 return 0;

403 }

404

405 const FFCodec ff_kmvc_decoder = {

406 .p.name = "kmvc",

407 CODEC_LONG_NAME("Karl Morton's video codec"),

408 .p.type = AVMEDIA_TYPE_VIDEO,

409 .p.id = AV_CODEC_ID_KMVC,

410 .priv_data_size = sizeof(KmvcContext),

411 .init = decode_init,

412 FF_CODEC_DECODE_CB(decode_frame),

413 .p.capabilities = AV_CODEC_CAP_DR1,

414 };

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

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

out

FILE * out

Definition: movenc.c:54

GetByteContext

Definition: bytestream.h:33

KmvcContext

Definition: kmvc.c:43

BitBuf

uint32_t BitBuf

Definition: put_bits.h:43

KmvcContext::prev

uint8_t * prev

Definition: kmvc.c:47

bytestream2_seek

static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)

Definition: bytestream.h:212

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:330

uint8_t w

Definition: llviddspenc.c:38

AVPacket::data

uint8_t * data

Definition: packet.h:374

kmvc_decode_intra_8x8

static int kmvc_decode_intra_8x8(KmvcContext *ctx, int w, int h)

Definition: kmvc.c:73

KmvcContext::palsize

int palsize

Definition: kmvc.c:49

FFCodec

Definition: codec_internal.h:127

KMVC_KEYFRAME

#define KMVC_KEYFRAME

Definition: kmvc.c:35

ff_kmvc_decoder

const FFCodec ff_kmvc_decoder

Definition: kmvc.c:405

KmvcContext::frm0

uint8_t frm0[320 *200]

Definition: kmvc.c:51

bytestream2_skip

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

Definition: bytestream.h:168

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

val

static double val(void *priv, double ch)

Definition: aeval.c:77

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

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:528

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:306

AV_CODEC_ID_KMVC

@ AV_CODEC_ID_KMVC

Definition: codec_id.h:137

kmvc_getbit

#define kmvc_getbit(bb, g, res)

Definition: kmvc.c:63

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:365

ctx

AVFormatContext * ctx

Definition: movenc.c:48

decode.h

AV_RL16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16

Definition: bytestream.h:94

KMVC_METHOD

#define KMVC_METHOD

Definition: kmvc.c:37

KmvcContext::cur

uint8_t * cur

Definition: kmvc.c:47

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

KmvcContext::avctx

AVCodecContext * avctx

Definition: kmvc.c:44

BitBuf

Definition: kmvc.c:54

BLK

#define BLK(data, x, y)

Definition: kmvc.c:59

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

bytestream2_get_bytes_left

static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)

Definition: bytestream.h:158

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

header

static const uint8_t header[24]

Definition: sdr2.c:67

MAX_PALSIZE

#define MAX_PALSIZE

Definition: kmvc.c:38

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

kmvc_init_getbits

#define kmvc_init_getbits(bb, g)

Definition: kmvc.c:61

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:527

common.h

decode_frame

static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)

Definition: kmvc.c:262

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

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

#define U(x)

Definition: vpx_arith.h:37

KmvcContext::pal

uint32_t pal[MAX_PALSIZE]

Definition: kmvc.c:50

AVCodecContext

main external API structure.

Definition: avcodec.h:426