FFmpeg: libavcodec/qdrw.c Source File

FFmpeg

[フレーム]

libavcodec

qdrw.c

Go to the documentation of this file.

1 /*

2 * QuickDraw (qdrw) codec

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 /**

24 * @file

25 * Apple QuickDraw codec.

26 * https://developer.apple.com/legacy/library/documentation/mac/QuickDraw/QuickDraw-461.html

27 */

29 #include "libavutil/common.h"

30 #include "libavutil/intreadwrite.h"

31 #include "avcodec.h"

32 #include "bytestream.h"

33 #include "codec_internal.h"

34 #include "decode.h"

36 enum QuickdrawOpcodes {

37 CLIP = 0x0001,

38 PACKBITSRECT = 0x0098,

39 PACKBITSRGN,

40 DIRECTBITSRECT,

41 DIRECTBITSRGN,

42 SHORTCOMMENT = 0x00A0,

43 LONGCOMMENT,

45 EOP = 0x00FF,

46 };

48 static int parse_palette(AVCodecContext *avctx, GetByteContext *gbc,

49 uint32_t *pal, int colors, int pixmap)

50 {

51 int i;

53 for (i = 0; i <= colors; i++) {

54 uint8_t r, g, b;

55 unsigned int idx = bytestream2_get_be16(gbc); /* color index */

56 if (idx > 255 && !pixmap) {

57 av_log(avctx, AV_LOG_WARNING,

58 "Palette index out of range: %u\n", idx);

59 bytestream2_skip(gbc, 6);

60 continue;

61 }

62 if (avctx->pix_fmt != AV_PIX_FMT_PAL8)

63 return AVERROR_INVALIDDATA;

64 r = bytestream2_get_byte(gbc);

65 bytestream2_skip(gbc, 1);

66 g = bytestream2_get_byte(gbc);

67 bytestream2_skip(gbc, 1);

68 b = bytestream2_get_byte(gbc);

69 bytestream2_skip(gbc, 1);

70 pal[pixmap ? i : idx] = (0xFFU << 24) | (r << 16) | (g << 8) | b;

71 }

72 return 0;

73 }

75 static int decode_rle_bpp2(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc)

76 {

77 int offset = avctx->width;

78 uint8_t *outdata = p->data[0];

79 int i, j;

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

82 int size, left, code, pix;

83 uint8_t *out = outdata;

84 int pos = 0;

86 /* size of packed line */

87 if (offset / 4 > 200)

88 size = left = bytestream2_get_be16(gbc);

89 else

90 size = left = bytestream2_get_byte(gbc);

91 if (bytestream2_get_bytes_left(gbc) < size)

92 return AVERROR_INVALIDDATA;

94 /* decode line */

95 while (left > 0) {

96 code = bytestream2_get_byte(gbc);

97 if (code & 0x80 ) { /* run */

98 pix = bytestream2_get_byte(gbc);

99 for (j = 0; j < 257 - code; j++) {

100 if (pos < offset)

101 out[pos++] = (pix & 0xC0) >> 6;

102 if (pos < offset)

103 out[pos++] = (pix & 0x30) >> 4;

104 if (pos < offset)

105 out[pos++] = (pix & 0x0C) >> 2;

106 if (pos < offset)

107 out[pos++] = (pix & 0x03);

108 }

109 left -= 2;

110 } else { /* copy */

111 for (j = 0; j < code + 1; j++) {

112 pix = bytestream2_get_byte(gbc);

113 if (pos < offset)

114 out[pos++] = (pix & 0xC0) >> 6;

115 if (pos < offset)

116 out[pos++] = (pix & 0x30) >> 4;

117 if (pos < offset)

118 out[pos++] = (pix & 0x0C) >> 2;

119 if (pos < offset)

120 out[pos++] = (pix & 0x03);

121 }

122 left -= 1 + (code + 1);

123 }

124 }

125 outdata += p->linesize[0];

126 }

127 return 0;

128 }

129

130 static int decode_rle_bpp4(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc)

131 {

132 int offset = avctx->width;

133 uint8_t *outdata = p->data[0];

134 int i, j;

135

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

137 int size, left, code, pix;

138 uint8_t *out = outdata;

139 int pos = 0;

140

141 /* size of packed line */

142 size = left = bytestream2_get_be16(gbc);

143 if (bytestream2_get_bytes_left(gbc) < size)

144 return AVERROR_INVALIDDATA;

145

146 /* decode line */

147 while (left > 0) {

148 code = bytestream2_get_byte(gbc);

149 if (code & 0x80 ) { /* run */

150 pix = bytestream2_get_byte(gbc);

151 for (j = 0; j < 257 - code; j++) {

152 if (pos < offset)

153 out[pos++] = (pix & 0xF0) >> 4;

154 if (pos < offset)

155 out[pos++] = pix & 0xF;

156 }

157 left -= 2;

158 } else { /* copy */

159 for (j = 0; j < code + 1; j++) {

160 pix = bytestream2_get_byte(gbc);

161 if (pos < offset)

162 out[pos++] = (pix & 0xF0) >> 4;

163 if (pos < offset)

164 out[pos++] = pix & 0xF;

165 }

166 left -= 1 + (code + 1);

167 }

168 }

169 outdata += p->linesize[0];

170 }

171 return 0;

172 }

173

174 static int decode_rle16(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc)

175 {

176 int offset = avctx->width;

177 uint8_t *outdata = p->data[0];

178 int i, j;

179

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

181 int size, left, code, pix;

182 uint16_t *out = (uint16_t *)outdata;

183 int pos = 0;

184

185 /* size of packed line */

186 size = left = bytestream2_get_be16(gbc);

187 if (bytestream2_get_bytes_left(gbc) < size)

188 return AVERROR_INVALIDDATA;

189

190 /* decode line */

191 while (left > 0) {

192 code = bytestream2_get_byte(gbc);

193 if (code & 0x80 ) { /* run */

194 pix = bytestream2_get_be16(gbc);

195 for (j = 0; j < 257 - code; j++) {

196 if (pos < offset) {

197 out[pos++] = pix;

198 }

199 }

200 left -= 3;

201 } else { /* copy */

202 for (j = 0; j < code + 1; j++) {

203 if (pos < offset) {

204 out[pos++] = bytestream2_get_be16(gbc);

205 } else {

206 bytestream2_skip(gbc, 2);

207 }

208 }

209 left -= 1 + (code + 1) * 2;

210 }

211 }

212 outdata += p->linesize[0];

213 }

214 return 0;

215 }

216

217 static int decode_rle(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc,

218 int step)

219 {

220 int i, j;

221 int offset = avctx->width * step;

222 uint8_t *outdata = p->data[0];

223

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

225 int size, left, code, pix;

226 uint8_t *out = outdata;

227 int pos = 0;

228

229 /* size of packed line */

230 size = left = bytestream2_get_be16(gbc);

231 if (bytestream2_get_bytes_left(gbc) < size)

232 return AVERROR_INVALIDDATA;

233

234 /* decode line */

235 while (left > 0) {

236 code = bytestream2_get_byte(gbc);

237 if (code & 0x80 ) { /* run */

238 pix = bytestream2_get_byte(gbc);

239 for (j = 0; j < 257 - code; j++) {

240 if (pos < offset)

241 out[pos] = pix;

242 pos += step;

243 if (pos >= offset && step > 1) {

244 pos -= offset;

245 pos++;

246 }

247 }

248 left -= 2;

249 } else { /* copy */

250 for (j = 0; j < code + 1; j++) {

251 pix = bytestream2_get_byte(gbc);

252 if (pos < offset)

253 out[pos] = pix;

254 pos += step;

255 if (pos >= offset && step > 1) {

256 pos -= offset;

257 pos++;

258 }

259 }

260 left -= 2 + code;

261 }

262 }

263 outdata += p->linesize[0];

264 }

265 return 0;

266 }

267

268 static int check_header(const char *buf, int buf_size)

269 {

270 unsigned w, h, v0, v1;

271

272 if (buf_size < 40)

273 return 0;

274

275 w = AV_RB16(buf+6);

276 h = AV_RB16(buf+8);

277 v0 = AV_RB16(buf+10);

278 v1 = AV_RB16(buf+12);

279

280 if (!w || !h)

281 return 0;

282

283 if (v0 == 0x1101)

284 return 1;

285 if (v0 == 0x0011 && v1 == 0x02FF)

286 return 2;

287 return 0;

288 }

289

290

291 static int decode_frame(AVCodecContext *avctx, AVFrame *p,

292 int *got_frame, AVPacket *avpkt)

293 {

294 GetByteContext gbc;

295 int colors;

296 int w, h, ret;

297 int ver;

298

299 bytestream2_init(&gbc, avpkt->data, avpkt->size);

300 if ( bytestream2_get_bytes_left(&gbc) >= 552

301 && check_header(gbc.buffer + 512, bytestream2_get_bytes_left(&gbc) - 512)

302 )

303 bytestream2_skip(&gbc, 512);

304

305 ver = check_header(gbc.buffer, bytestream2_get_bytes_left(&gbc));

306

307 /* smallest PICT header */

308 if (bytestream2_get_bytes_left(&gbc) < 40) {

309 av_log(avctx, AV_LOG_ERROR, "Frame is too small %d\n",

310 bytestream2_get_bytes_left(&gbc));

311 return AVERROR_INVALIDDATA;

312 }

313

314 bytestream2_skip(&gbc, 6);

315 h = bytestream2_get_be16(&gbc);

316 w = bytestream2_get_be16(&gbc);

317

318 ret = ff_set_dimensions(avctx, w, h);

319 if (ret < 0)

320 return ret;

321

322 /* version 1 is identified by 0x1101

323 * it uses byte-aligned opcodes rather than word-aligned */

324 if (ver == 1) {

325 avpriv_request_sample(avctx, "QuickDraw version 1");

326 return AVERROR_PATCHWELCOME;

327 } else if (ver != 2) {

328 avpriv_request_sample(avctx, "QuickDraw version unknown (%X)", bytestream2_get_be32(&gbc));

329 return AVERROR_PATCHWELCOME;

330 }

331

332 bytestream2_skip(&gbc, 4+26);

333

334 while (bytestream2_get_bytes_left(&gbc) >= 4) {

335 int bppcnt, bpp;

336 int rowbytes, pack_type;

337 int flags;

338 int opcode = bytestream2_get_be16(&gbc);

339

340 switch(opcode) {

341 case CLIP:

342 bytestream2_skip(&gbc, 10);

343 break;

344 case PACKBITSRECT:

345 case PACKBITSRGN:

346 av_log(avctx, AV_LOG_DEBUG, "Parsing Packbit opcode\n");

347

348 flags = bytestream2_get_be16(&gbc) & 0xC000;

349 bytestream2_skip(&gbc, 28);

350 bppcnt = bytestream2_get_be16(&gbc); /* cmpCount */

351 bpp = bytestream2_get_be16(&gbc); /* cmpSize */

352

353 av_log(avctx, AV_LOG_DEBUG, "bppcount %d bpp %d\n", bppcnt, bpp);

354 if (bppcnt == 1 && bpp == 8) {

355 avctx->pix_fmt = AV_PIX_FMT_PAL8;

356 } else if (bppcnt == 1 && (bpp == 4 || bpp == 2)) {

357 avctx->pix_fmt = AV_PIX_FMT_PAL8;

358 } else if (bppcnt == 3 && bpp == 5) {

359 avctx->pix_fmt = AV_PIX_FMT_RGB555;

360 } else {

361 av_log(avctx, AV_LOG_ERROR,

362 "Invalid pixel format (bppcnt %d bpp %d) in Packbit\n",

363 bppcnt, bpp);

364 return AVERROR_INVALIDDATA;

365 }

366

367 /* jump to palette */

368 bytestream2_skip(&gbc, 18);

369 colors = bytestream2_get_be16(&gbc);

370

371 if (colors < 0 || colors > 255) {

372 av_log(avctx, AV_LOG_ERROR,

373 "Error color count - %i(0x%X)\n", colors, colors);

374 return AVERROR_INVALIDDATA;

375 }

376 if (bytestream2_get_bytes_left(&gbc) < (colors + 1) * 8) {

377 av_log(avctx, AV_LOG_ERROR, "Palette is too small %d\n",

378 bytestream2_get_bytes_left(&gbc));

379 return AVERROR_INVALIDDATA;

380 }

381 if ((ret = ff_get_buffer(avctx, p, 0)) < 0)

382 return ret;

383

384 ret = parse_palette(avctx, &gbc, (uint32_t *)p->data[1], colors, flags & 0x8000);

385 if (ret < 0)

386 return ret;

387 p->palette_has_changed = 1;

388

389 /* jump to image data */

390 bytestream2_skip(&gbc, 18);

391

392 if (opcode == PACKBITSRGN) {

393 bytestream2_skip(&gbc, 2 + 8); /* size + rect */

394 avpriv_report_missing_feature(avctx, "Packbit mask region");

395 }

396

397 if (avctx->pix_fmt == AV_PIX_FMT_RGB555)

398 ret = decode_rle16(avctx, p, &gbc);

399 else if (bpp == 2)

400 ret = decode_rle_bpp2(avctx, p, &gbc);

401 else if (bpp == 4)

402 ret = decode_rle_bpp4(avctx, p, &gbc);

403 else

404 ret = decode_rle(avctx, p, &gbc, bppcnt);

405 if (ret < 0)

406 return ret;

407 *got_frame = 1;

408 break;

409 case DIRECTBITSRECT:

410 case DIRECTBITSRGN:

411 av_log(avctx, AV_LOG_DEBUG, "Parsing Directbit opcode\n");

412

413 bytestream2_skip(&gbc, 4);

414 rowbytes = bytestream2_get_be16(&gbc) & 0x3FFF;

415 if (rowbytes <= 250) {

416 avpriv_report_missing_feature(avctx, "Short rowbytes");

417 return AVERROR_PATCHWELCOME;

418 }

419

420 bytestream2_skip(&gbc, 4);

421 h = bytestream2_get_be16(&gbc);

422 w = bytestream2_get_be16(&gbc);

423 bytestream2_skip(&gbc, 2);

424

425 ret = ff_set_dimensions(avctx, w, h);

426 if (ret < 0)

427 return ret;

428

429 pack_type = bytestream2_get_be16(&gbc);

430

431 bytestream2_skip(&gbc, 16);

432 bppcnt = bytestream2_get_be16(&gbc); /* cmpCount */

433 bpp = bytestream2_get_be16(&gbc); /* cmpSize */

434

435 av_log(avctx, AV_LOG_DEBUG, "bppcount %d bpp %d\n", bppcnt, bpp);

436 if (bppcnt == 3 && bpp == 8) {

437 avctx->pix_fmt = AV_PIX_FMT_RGB24;

438 } else if (bppcnt == 3 && bpp == 5 || bppcnt == 2 && bpp == 8) {

439 avctx->pix_fmt = AV_PIX_FMT_RGB555;

440 } else if (bppcnt == 4 && bpp == 8) {

441 avctx->pix_fmt = AV_PIX_FMT_ARGB;

442 } else {

443 av_log(avctx, AV_LOG_ERROR,

444 "Invalid pixel format (bppcnt %d bpp %d) in Directbit\n",

445 bppcnt, bpp);

446 return AVERROR_INVALIDDATA;

447 }

448

449 /* set packing when default is selected */

450 if (pack_type == 0)

451 pack_type = bppcnt;

452

453 if (pack_type != 3 && pack_type != 4) {

454 avpriv_request_sample(avctx, "Pack type %d", pack_type);

455 return AVERROR_PATCHWELCOME;

456 }

457 if (bytestream2_get_bytes_left(&gbc) < 30)

458 return AVERROR_INVALIDDATA;

459 if ((ret = ff_get_buffer(avctx, p, 0)) < 0)

460 return ret;

461

462 /* jump to data */

463 bytestream2_skip(&gbc, 30);

464

465 if (opcode == DIRECTBITSRGN) {

466 bytestream2_skip(&gbc, 2 + 8); /* size + rect */

467 avpriv_report_missing_feature(avctx, "DirectBit mask region");

468 }

469

470 if (avctx->pix_fmt == AV_PIX_FMT_RGB555)

471 ret = decode_rle16(avctx, p, &gbc);

472 else

473 ret = decode_rle(avctx, p, &gbc, bppcnt);

474 if (ret < 0)

475 return ret;

476 *got_frame = 1;

477 break;

478 case LONGCOMMENT:

479 bytestream2_get_be16(&gbc);

480 bytestream2_skip(&gbc, bytestream2_get_be16(&gbc));

481 break;

482 default:

483 av_log(avctx, AV_LOG_TRACE, "Unknown 0x%04X opcode\n", opcode);

484 break;

485 }

486 /* exit the loop when a known pixel block has been found */

487 if (*got_frame) {

488 int eop, trail;

489

490 /* re-align to a word */

491 bytestream2_skip(&gbc, bytestream2_get_bytes_left(&gbc) % 2);

492

493 eop = bytestream2_get_be16(&gbc);

494 trail = bytestream2_get_bytes_left(&gbc);

495 if (eop != EOP)

496 av_log(avctx, AV_LOG_WARNING,

497 "Missing end of picture opcode (found 0x%04X)\n", eop);

498 if (trail)

499 av_log(avctx, AV_LOG_WARNING, "Got %d trailing bytes\n", trail);

500 break;

501 }

502 }

503

504 if (*got_frame) {

505 p->pict_type = AV_PICTURE_TYPE_I;

506 p->key_frame = 1;

507

508 return avpkt->size;

509 } else {

510 av_log(avctx, AV_LOG_ERROR, "Frame contained no usable data\n");

511

512 return AVERROR_INVALIDDATA;

513 }

514 }

515

516 const FFCodec ff_qdraw_decoder = {

517 .p.name = "qdraw",

518 CODEC_LONG_NAME("Apple QuickDraw"),

519 .p.type = AVMEDIA_TYPE_VIDEO,

520 .p.id = AV_CODEC_ID_QDRAW,

521 .p.capabilities = AV_CODEC_CAP_DR1,

522 FF_CODEC_DECODE_CB(decode_frame),

523 };

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

check_header

static int check_header(const char *buf, int buf_size)

Definition: qdrw.c:268

decode_frame

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

Definition: qdrw.c:291

const char * r

Definition: vf_curves.c:126

out

FILE * out

Definition: movenc.c:54

GetByteContext

Definition: bytestream.h:33

QuickdrawOpcodes

Definition: qdrw.c:36

SHORTCOMMENT

@ SHORTCOMMENT

Definition: qdrw.c:42

AVFrame

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

Definition: frame.h:330

step

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step

Definition: rate_distortion.txt:58

uint8_t w

Definition: llviddspenc.c:38

decode_rle_bpp4

static int decode_rle_bpp4(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc)

Definition: qdrw.c:130

AVPacket::data

uint8_t * data

Definition: packet.h:374

#define b

Definition: input.c:41

FFCodec

Definition: codec_internal.h:127

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:91

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:351

decode_rle

static int decode_rle(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc, int step)

Definition: qdrw.c:217

PACKBITSRECT

@ PACKBITSRECT

Definition: qdrw.c:38

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

PACKBITSRGN

@ PACKBITSRGN

Definition: qdrw.c:39

#define v0

Definition: regdef.h:26

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:422

LONGCOMMENT

@ LONGCOMMENT

Definition: qdrw.c:43

AV_LOG_TRACE

#define AV_LOG_TRACE

Extremely verbose debugging, useful for libav* development.

Definition: log.h:206

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:306

intreadwrite.h

DIRECTBITSRECT

@ DIRECTBITSRECT

Definition: qdrw.c:40

const char * g

Definition: vf_curves.c:127

GetByteContext::buffer

const uint8_t * buffer

Definition: bytestream.h:34

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

decode.h

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

EOP

@ EOP

Definition: qdrw.c:45

decode_rle16

static int decode_rle16(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc)

Definition: qdrw.c:174

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

bytestream2_get_bytes_left

static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)

Definition: bytestream.h:158

DIRECTBITSRGN

@ DIRECTBITSRGN

Definition: qdrw.c:41

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:427

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1473

AV_PIX_FMT_RGB24

@ AV_PIX_FMT_RGB24

packed RGB 8:8:8, 24bpp, RGBRGB...

Definition: pixfmt.h:68

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

parse_palette

static int parse_palette(AVCodecContext *avctx, GetByteContext *gbc, uint32_t *pal, int colors, int pixmap)

Definition: qdrw.c:48

avpriv_report_missing_feature

void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

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

AV_CODEC_ID_QDRAW

@ AV_CODEC_ID_QDRAW

Definition: codec_id.h:110

AV_PIX_FMT_ARGB

@ AV_PIX_FMT_ARGB

packed ARGB 8:8:8:8, 32bpp, ARGBARGB...

Definition: pixfmt.h:92

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

Definition: cbs_h2645.c:269

code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition: filter_design.txt:178

decode_rle_bpp2

static int decode_rle_bpp2(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc)

Definition: qdrw.c:75

common.h

AV_PIX_FMT_RGB555

#define AV_PIX_FMT_RGB555

Definition: pixfmt.h:447

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

pos

unsigned int pos

Definition: spdifenc.c:413

left

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left

Definition: snow.txt:386

#define U(x)

Definition: vpx_arith.h:37

AVCodecContext

main external API structure.

Definition: avcodec.h:426

AVFrame::palette_has_changed

int palette_has_changed

Tell user application that palette has changed from previous frame.

Definition: frame.h:496

ff_qdraw_decoder

const FFCodec ff_qdraw_decoder

Definition: qdrw.c:516

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

CLIP

@ CLIP

Definition: qdrw.c:37

avpriv_request_sample

#define avpriv_request_sample(...)

Definition: tableprint_vlc.h:36

AVPacket

This structure stores compressed data.

Definition: packet.h:351

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:598

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

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

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

Definition: vp9dsp_template.c:2038

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:98

Generated on Tue Feb 28 2023 21:33:35 for FFmpeg by doxygen 1.8.17