FFmpeg: libavcodec/clearvideo.c Source File

FFmpeg

[フレーム]

libavcodec

clearvideo.c

Go to the documentation of this file.

1 /*

2 * ClearVideo 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 * ClearVideo decoder

25 */

27 #include "libavutil/mem_internal.h"

28 #include "libavutil/thread.h"

30 #include "avcodec.h"

31 #include "bytestream.h"

32 #include "codec_internal.h"

33 #include "decode.h"

34 #include "get_bits.h"

35 #include "idctdsp.h"

36 #include "mathops.h"

37 #include "clearvideodata.h"

39 #define CLV_VLC_BITS 9

41 typedef struct LevelCodes {

42 VLC flags_cb;

43 VLC mv_cb;

44 VLC bias_cb;

45 } LevelCodes;

47 typedef struct MV {

48 int16_t x, y;

49 } MV;

51 static const MV zero_mv = { 0 };

53 typedef struct MVInfo {

54 int mb_w;

55 int mb_h;

56 int mb_size;

57 int mb_stride;

58 int top;

59 MV *mv;

60 } MVInfo;

62 typedef struct CLVContext {

63 AVCodecContext *avctx;

64 IDCTDSPContext idsp;

65 AVFrame *pic;

66 AVFrame *prev;

67 GetBitContext gb;

68 int mb_width, mb_height;

69 int pmb_width, pmb_height;

70 MVInfo mvi;

71 int tile_size;

72 int tile_shift;

73 int luma_dc_quant, chroma_dc_quant, ac_quant;

74 DECLARE_ALIGNED(16, int16_t, block)[64];

75 int top_dc[3], left_dc[4];

76 } CLVContext;

78 static VLC dc_vlc, ac_vlc;

79 static LevelCodes lev[4 + 3 + 3]; // 0..3: Y, 4..6: U, 7..9: V

80 static VLCElem vlc_buf[16716];

82 static inline int decode_block(CLVContext *ctx, int16_t *blk, int has_ac,

83 int ac_quant)

84 {

85 GetBitContext *gb = &ctx->gb;

86 int idx = 1, last = 0, val, skip;

88 memset(blk, 0, sizeof(*blk) * 64);

89 blk[0] = get_vlc2(gb, dc_vlc.table, CLV_VLC_BITS, 3);

91 if (!has_ac)

92 return 0;

94 while (idx < 64 && !last) {

95 val = get_vlc2(gb, ac_vlc.table, CLV_VLC_BITS, 2);

96 if (val < 0)

97 return AVERROR_INVALIDDATA;

98 if (val != 0x1BFF) {

99 last = val >> 12;

100 skip = (val >> 4) & 0xFF;

101 val &= 0xF;

102 if (get_bits1(gb))

103 val = -val;

104 } else {

105 last = get_bits1(gb);

106 skip = get_bits(gb, 6);

107 val = get_sbits(gb, 8);

108 }

109 if (val) {

110 int aval = FFABS(val), sign = val < 0;

111 val = ac_quant * (2 * aval + 1);

112 if (!(ac_quant & 1))

113 val--;

114 if (sign)

115 val = -val;

116 }

117 idx += skip;

118 if (idx >= 64)

119 return AVERROR_INVALIDDATA;

120 blk[ff_zigzag_direct[idx++]] = val;

121 }

122

123 return (idx <= 64 && last) ? 0 : -1;

124 }

125

126 #define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP) \

127 const int t0 = OP(2841 * blk[1 * step] + 565 * blk[7 * step]); \

128 const int t1 = OP( 565 * blk[1 * step] - 2841 * blk[7 * step]); \

129 const int t2 = OP(1609 * blk[5 * step] + 2408 * blk[3 * step]); \

130 const int t3 = OP(2408 * blk[5 * step] - 1609 * blk[3 * step]); \

131 const int t4 = OP(1108 * blk[2 * step] - 2676 * blk[6 * step]); \

132 const int t5 = OP(2676 * blk[2 * step] + 1108 * blk[6 * step]); \

133 const int t6 = ((blk[0 * step] + blk[4 * step]) * (1 << dshift)) + bias; \

134 const int t7 = ((blk[0 * step] - blk[4 * step]) * (1 << dshift)) + bias; \

135 const int t8 = t0 + t2; \

136 const int t9 = t0 - t2; \

137 const int tA = (int)(181U * (t9 + (t1 - t3)) + 0x80) >> 8; \

138 const int tB = (int)(181U * (t9 - (t1 - t3)) + 0x80) >> 8; \

139 const int tC = t1 + t3; \

140 \

141 blk[0 * step] = (t6 + t5 + t8) >> shift; \

142 blk[1 * step] = (t7 + t4 + tA) >> shift; \

143 blk[2 * step] = (t7 - t4 + tB) >> shift; \

144 blk[3 * step] = (t6 - t5 + tC) >> shift; \

145 blk[4 * step] = (t6 - t5 - tC) >> shift; \

146 blk[5 * step] = (t7 - t4 - tB) >> shift; \

147 blk[6 * step] = (t7 + t4 - tA) >> shift; \

148 blk[7 * step] = (t6 + t5 - t8) >> shift; \

149

150 #define ROP(x) x

151 #define COP(x) (((x) + 4) >> 3)

152

153 static void clv_dct(int16_t *block)

154 {

155 int i;

156 int16_t *ptr;

157

158 ptr = block;

159 for (i = 0; i < 8; i++) {

160 DCT_TEMPLATE(ptr, 1, 0x80, 8, 11, ROP);

161 ptr += 8;

162 }

163

164 ptr = block;

165 for (i = 0; i < 8; i++) {

166 DCT_TEMPLATE(ptr, 8, 0x2000, 14, 8, COP);

167 ptr++;

168 }

169 }

170

171 static int decode_mb(CLVContext *c, int x, int y)

172 {

173 int i, has_ac[6], off;

174

175 for (i = 0; i < 6; i++)

176 has_ac[i] = get_bits1(&c->gb);

177

178 off = x * 16 + y * 16 * c->pic->linesize[0];

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

180 if (decode_block(c, c->block, has_ac[i], c->ac_quant) < 0)

181 return AVERROR_INVALIDDATA;

182 if (!x && !(i & 1)) {

183 c->block[0] += c->top_dc[0];

184 c->top_dc[0] = c->block[0];

185 } else {

186 c->block[0] += c->left_dc[(i & 2) >> 1];

187 }

188 c->left_dc[(i & 2) >> 1] = c->block[0];

189 c->block[0] *= c->luma_dc_quant;

190 clv_dct(c->block);

191 if (i == 2)

192 off += c->pic->linesize[0] * 8;

193 c->idsp.put_pixels_clamped(c->block,

194 c->pic->data[0] + off + (i & 1) * 8,

195 c->pic->linesize[0]);

196 }

197

198 off = x * 8 + y * 8 * c->pic->linesize[1];

199 for (i = 1; i < 3; i++) {

200 if (decode_block(c, c->block, has_ac[i + 3], c->ac_quant) < 0)

201 return AVERROR_INVALIDDATA;

202 if (!x) {

203 c->block[0] += c->top_dc[i];

204 c->top_dc[i] = c->block[0];

205 } else {

206 c->block[0] += c->left_dc[i + 1];

207 }

208 c->left_dc[i + 1] = c->block[0];

209 c->block[0] *= c->chroma_dc_quant;

210 clv_dct(c->block);

211 c->idsp.put_pixels_clamped(c->block, c->pic->data[i] + off,

212 c->pic->linesize[i]);

213 }

214

215 return 0;

216 }

217

218 static int copy_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src,

219 int plane, int x, int y, int dx, int dy, int size)

220 {

221 int shift = plane > 0;

222 int sx = x + dx;

223 int sy = y + dy;

224 int sstride, dstride, soff, doff;

225 uint8_t *dbuf;

226 const uint8_t *sbuf;

227 int i;

228

229 if (x < 0 || sx < 0 || y < 0 || sy < 0 ||

230 x + size > avctx->coded_width >> shift ||

231 y + size > avctx->coded_height >> shift ||

232 sx + size > avctx->coded_width >> shift ||

233 sy + size > avctx->coded_height >> shift)

234 return AVERROR_INVALIDDATA;

235

236 sstride = src->linesize[plane];

237 dstride = dst->linesize[plane];

238 soff = sx + sy * sstride;

239 sbuf = src->data[plane];

240 doff = x + y * dstride;

241 dbuf = dst->data[plane];

242

243 for (i = 0; i < size; i++) {

244 uint8_t *dptr = &dbuf[doff];

245 const uint8_t *sptr = &sbuf[soff];

246

247 memcpy(dptr, sptr, size);

248 doff += dstride;

249 soff += sstride;

250 }

251

252 return 0;

253 }

254

255 static int copyadd_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src,

256 int plane, int x, int y, int dx, int dy, int size, int bias)

257 {

258 int shift = plane > 0;

259 int sx = x + dx;

260 int sy = y + dy;

261 int sstride = src->linesize[plane];

262 int dstride = dst->linesize[plane];

263 int soff = sx + sy * sstride;

264 const uint8_t *sbuf = src->data[plane];

265 int doff = x + y * dstride;

266 uint8_t *dbuf = dst->data[plane];

267 int i, j;

268

269 if (x < 0 || sx < 0 || y < 0 || sy < 0 ||

270 x + size > avctx->coded_width >> shift ||

271 y + size > avctx->coded_height >> shift ||

272 sx + size > avctx->coded_width >> shift ||

273 sy + size > avctx->coded_height >> shift)

274 return AVERROR_INVALIDDATA;

275

276 for (j = 0; j < size; j++) {

277 uint8_t *dptr = &dbuf[doff];

278 const uint8_t *sptr = &sbuf[soff];

279

280 for (i = 0; i < size; i++) {

281 int val = sptr[i] + bias;

282

283 dptr[i] = av_clip_uint8(val);

284 }

285

286 doff += dstride;

287 soff += sstride;

288 }

289

290 return 0;

291 }

292

293 static MV *mvi_predict(MVInfo *mvi, int mb_x, int mb_y)

294 {

295 MV res, pred_mv;

296 int left_mv, right_mv, top_mv, bot_mv;

297

298 if (mvi->top) {

299 if (mb_x > 0) {

300 pred_mv = mvi->mv[mvi->mb_stride + mb_x - 1];

301 } else {

302 pred_mv = zero_mv;

303 }

304 } else if ((mb_x == 0) || (mb_x == mvi->mb_w - 1)) {

305 pred_mv = mvi->mv[mb_x];

306 } else {

307 MV A = mvi->mv[mvi->mb_stride + mb_x - 1];

308 MV B = mvi->mv[ mb_x ];

309 MV C = mvi->mv[ mb_x + 1];

310 pred_mv.x = mid_pred(A.x, B.x, C.x);

311 pred_mv.y = mid_pred(A.y, B.y, C.y);

312 }

313

314 res = pred_mv;

315

316 left_mv = -((mb_x * mvi->mb_size));

317 right_mv = ((mvi->mb_w - mb_x - 1) * mvi->mb_size);

318 if (res.x < left_mv) {

319 res.x = left_mv;

320 }

321 if (res.x > right_mv) {

322 res.x = right_mv;

323 }

324 top_mv = -((mb_y * mvi->mb_size));

325 bot_mv = ((mvi->mb_h - mb_y - 1) * mvi->mb_size);

326 if (res.y < top_mv) {

327 res.y = top_mv;

328 }

329 if (res.y > bot_mv) {

330 res.y = bot_mv;

331 }

332

333 mvi->mv[mvi->mb_stride + mb_x].x = res.x;

334 mvi->mv[mvi->mb_stride + mb_x].y = res.y;

335

336 return &mvi->mv[mvi->mb_stride + mb_x];

337 }

338

339 static void mvi_update_prediction(MV *mv, MV diff)

340 {

341 mv->x += diff.x;

342 mv->y += diff.y;

343 }

344

345 static void mvi_reset(MVInfo *mvi, int mb_w, int mb_h, int mb_size)

346 {

347 mvi->top = 1;

348 mvi->mb_w = mb_w;

349 mvi->mb_h = mb_h;

350 mvi->mb_size = mb_size;

351 mvi->mb_stride = mb_w;

352 memset(mvi->mv, 0, sizeof(MV) * mvi->mb_stride * 2);

353 }

354

355 static void mvi_update_row(MVInfo *mvi)

356 {

357 int i;

358

359 mvi->top = 0;

360 for (i = 0 ; i < mvi->mb_stride; i++) {

361 mvi->mv[i] = mvi->mv[mvi->mb_stride + i];

362 }

363 }

364

365 static int tile_do_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src,

366 int plane, int x, int y, int dx, int dy, int size, int bias)

367 {

368 int ret;

369

370 if (!bias) {

371 ret = copy_block(avctx, dst, src, plane, x, y, dx, dy, size);

372 } else {

373 ret = copyadd_block(avctx, dst, src, plane, x, y, dx, dy, size, bias);

374 }

375

376 return ret;

377 }

378

379 static int decode_tile(AVCodecContext *avctx, GetBitContext *gb,

380 const LevelCodes *lc,

381 AVFrame *dst, const AVFrame *src,

382 int plane, int x, int y, int size,

383 MV root_mv, MV *pred)

384 {

385 int i, flags = 0;

386 int16_t bias = 0;

387 MV mv = { 0 };

388 int err;

389

390 if (lc->flags_cb.table)

391 flags = get_vlc2(gb, lc->flags_cb.table, CLV_VLC_BITS, 2);

392

393 if (lc->mv_cb.table) {

394 uint16_t mv_code = get_vlc2(gb, lc->mv_cb.table, CLV_VLC_BITS, 2);

395

396 if (mv_code != MV_ESC) {

397 mv.x = (int8_t)(mv_code & 0xff);

398 mv.y = (int8_t)(mv_code >> 8);

399 } else {

400 mv.x = get_sbits(gb, 8);

401 mv.y = get_sbits(gb, 8);

402 }

403 if (pred)

404 mvi_update_prediction(pred, mv);

405 }

406 mv.x += root_mv.x;

407 mv.y += root_mv.y;

408

409 if (lc->bias_cb.table) {

410 uint16_t bias_val = get_vlc2(gb, lc->bias_cb.table, CLV_VLC_BITS, 2);

411

412 if (bias_val != BIAS_ESC) {

413 bias = (int16_t)(bias_val);

414 } else {

415 bias = get_sbits(gb, 16);

416 }

417 }

418

419 if (flags) {

420 int hsize = size >> 1;

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

422 int xoff = (i & 2) == 0 ? 0 : hsize;

423 int yoff = (i & 1) == 0 ? 0 : hsize;

424

425 if (flags & (1 << i)) {

426 err = decode_tile(avctx, gb, lc + 1, dst, src, plane,

427 x + xoff, y + yoff, hsize, root_mv, NULL);

428 } else {

429 err = tile_do_block(avctx, dst, src, plane, x + xoff, y + yoff,

430 mv.x, mv.y, hsize, bias);

431 }

432 if (err < 0)

433 return err;

434 }

435 } else {

436 err = tile_do_block(avctx, dst, src, plane, x, y, mv.x, mv.y, size, bias);

437 if (err < 0)

438 return err;

439 }

440

441 return 0;

442 }

443

444 static void extend_edges(AVFrame *buf, int tile_size)

445 {

446 int comp, i, j;

447

448 for (comp = 0; comp < 3; comp++) {

449 int shift = comp > 0;

450 int w = buf->width >> shift;

451 int h = buf->height >> shift;

452 int size = comp == 0 ? tile_size : tile_size >> 1;

453 int stride = buf->linesize[comp];

454 uint8_t *framebuf = buf->data[comp];

455

456 int right = size - (w & (size - 1));

457 int bottom = size - (h & (size - 1));

458

459 if ((right == size) && (bottom == size)) {

460 return;

461 }

462 if (right != size) {

463 int off = w;

464 for (j = 0; j < h; j++) {

465 for (i = 0; i < right; i++) {

466 framebuf[off + i] = 0x80;

467 }

468 off += stride;

469 }

470 }

471 if (bottom != size) {

472 int off = h * stride;

473 for (j = 0; j < bottom; j++) {

474 for (i = 0; i < stride; i++) {

475 framebuf[off + i] = 0x80;

476 }

477 off += stride;

478 }

479 }

480 }

481 }

482

483 static int clv_decode_frame(AVCodecContext *avctx, AVFrame *rframe,

484 int *got_frame, AVPacket *avpkt)

485 {

486 const uint8_t *buf = avpkt->data;

487 int buf_size = avpkt->size;

488 CLVContext *c = avctx->priv_data;

489 GetByteContext gb;

490 uint32_t frame_type;

491 int i, j, ret;

492 int mb_ret = 0;

493

494 bytestream2_init(&gb, buf, buf_size);

495 if (avctx->codec_tag == MKTAG('C', 'L', 'V', '1')) {

496 int skip = bytestream2_get_byte(&gb);

497 bytestream2_skip(&gb, (skip + 1) * 8);

498 }

499

500 frame_type = bytestream2_get_byte(&gb);

501

502 if ((frame_type & 0x7f) == 0x30) {

503 *got_frame = 0;

504 return buf_size;

505 } else if (frame_type & 0x2) {

506 if (buf_size < c->mb_width * c->mb_height) {

507 av_log(avctx, AV_LOG_ERROR, "Packet too small\n");

508 return AVERROR_INVALIDDATA;

509 }

510

511 if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)

512 return ret;

513

514 c->pic->key_frame = 1;

515 c->pic->pict_type = AV_PICTURE_TYPE_I;

516

517 bytestream2_get_be32(&gb); // frame size;

518 c->ac_quant = bytestream2_get_byte(&gb);

519 c->luma_dc_quant = 32;

520 c->chroma_dc_quant = 32;

521

522 if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),

523 buf_size - bytestream2_tell(&gb))) < 0)

524 return ret;

525

526 for (i = 0; i < 3; i++)

527 c->top_dc[i] = 32;

528 for (i = 0; i < 4; i++)

529 c->left_dc[i] = 32;

530

531 for (j = 0; j < c->mb_height; j++) {

532 for (i = 0; i < c->mb_width; i++) {

533 ret = decode_mb(c, i, j);

534 if (ret < 0)

535 mb_ret = ret;

536 }

537 }

538 extend_edges(c->pic, c->tile_size);

539 } else {

540 int plane;

541

542 if (c->pmb_width * c->pmb_height > 8LL*(buf_size - bytestream2_tell(&gb)))

543 return AVERROR_INVALIDDATA;

544

545 if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)

546 return ret;

547

548 ret = av_frame_copy(c->pic, c->prev);

549 if (ret < 0)

550 return ret;

551

552 if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),

553 buf_size - bytestream2_tell(&gb))) < 0)

554 return ret;

555

556 mvi_reset(&c->mvi, c->pmb_width, c->pmb_height, 1 << c->tile_shift);

557

558 for (j = 0; j < c->pmb_height; j++) {

559 for (i = 0; i < c->pmb_width; i++) {

560 MV *mvp, mv;

561 if (get_bits_left(&c->gb) <= 0)

562 return AVERROR_INVALIDDATA;

563

564 mvp = mvi_predict(&c->mvi, i, j);

565 mv = *mvp;

566 if (get_bits1(&c->gb)) {

567 for (plane = 0; plane < 3; plane++) {

568 int16_t x = plane == 0 ? i << c->tile_shift : i << (c->tile_shift - 1);

569 int16_t y = plane == 0 ? j << c->tile_shift : j << (c->tile_shift - 1);

570 int16_t size = plane == 0 ? 1 << c->tile_shift : 1 << (c->tile_shift - 1);

571 int16_t mx = plane == 0 ? mv.x : mv.x / 2;

572 int16_t my = plane == 0 ? mv.y : mv.y / 2;

573

574 ret = copy_block(avctx, c->pic, c->prev, plane, x, y, mx, my, size);

575 if (ret < 0)

576 mb_ret = ret;

577 }

578 } else {

579 int x = i << c->tile_shift;

580 int y = j << c->tile_shift;

581 int size = 1 << c->tile_shift;

582 MV cmv;

583

584 ret = decode_tile(avctx, &c->gb, &lev[0], c->pic, c->prev, // Y

585 0, x, y, size, mv, mvp);

586 if (ret < 0)

587 mb_ret = ret;

588 x = i << (c->tile_shift - 1);

589 y = j << (c->tile_shift - 1);

590 size = 1 << (c->tile_shift - 1);

591 cmv = *mvp;

592 cmv.x /= 2;

593 cmv.y /= 2;

594 ret = decode_tile(avctx, &c->gb, &lev[4], c->pic, c->prev, // U

595 1, x, y, size, cmv, NULL);

596 if (ret < 0)

597 mb_ret = ret;

598 ret = decode_tile(avctx, &c->gb, &lev[7], c->pic, c->prev, // U

599 2, x, y, size, cmv, NULL);

600 if (ret < 0)

601 mb_ret = ret;

602 }

603 }

604 mvi_update_row(&c->mvi);

605 }

606 extend_edges(c->pic, c->tile_size);

607

608 c->pic->key_frame = 0;

609 c->pic->pict_type = AV_PICTURE_TYPE_P;

610 }

611

612 if ((ret = av_frame_ref(rframe, c->pic)) < 0)

613 return ret;

614

615 FFSWAP(AVFrame *, c->pic, c->prev);

616

617 *got_frame = 1;

618

619 if (get_bits_left(&c->gb) < 0)

620 av_log(c->avctx, AV_LOG_WARNING, "overread %d\n", -get_bits_left(&c->gb));

621

622 return mb_ret < 0 ? mb_ret : buf_size;

623 }

624

625 static av_cold void build_vlc(VLC *vlc, const uint8_t counts[16],

626 const uint16_t **syms, unsigned *offset)

627 {

628 uint8_t lens[MAX_VLC_ENTRIES];

629 unsigned num = 0;

630

631 for (int i = 0; i < 16; i++) {

632 unsigned count = counts[i];

633 if (count == 255) /* Special case for Y_3 table */

634 count = 303;

635 for (count += num; num < count; num++)

636 lens[num] = i + 1;

637 }

638 vlc->table = &vlc_buf[*offset];

639 vlc->table_allocated = FF_ARRAY_ELEMS(vlc_buf) - *offset;

640 ff_init_vlc_from_lengths(vlc, CLV_VLC_BITS, num, lens, 1,

641 *syms, 2, 2, 0, INIT_VLC_STATIC_OVERLONG, NULL);

642 *syms += num;

643 *offset += vlc->table_size;

644 }

645

646 static av_cold void clv_init_static(void)

647 {

648 const uint16_t *mv_syms = clv_mv_syms, *bias_syms = clv_bias_syms;

649

650 INIT_VLC_STATIC_FROM_LENGTHS(&dc_vlc, CLV_VLC_BITS, NUM_DC_CODES,

651 clv_dc_lens, 1,

652 clv_dc_syms, 1, 1, -63, 0, 1104);

653 INIT_VLC_STATIC_FROM_LENGTHS(&ac_vlc, CLV_VLC_BITS, NUM_AC_CODES,

654 clv_ac_bits, 1,

655 clv_ac_syms, 2, 2, 0, 0, 554);

656 for (unsigned i = 0, j = 0, k = 0, offset = 0;; i++) {

657 if (0x36F & (1 << i)) {

658 build_vlc(&lev[i].mv_cb, clv_mv_len_counts[k], &mv_syms, &offset);

659 k++;

660 }

661 if (i == FF_ARRAY_ELEMS(lev) - 1)

662 break;

663 if (0x1B7 & (1 << i)) {

664 lev[i].flags_cb.table = &vlc_buf[offset];

665 lev[i].flags_cb.table_allocated = FF_ARRAY_ELEMS(vlc_buf) - offset;

666 ff_init_vlc_from_lengths(&lev[i].flags_cb, CLV_VLC_BITS, 16,

667 clv_flags_bits[j], 1,

668 clv_flags_syms[j], 1, 1,

669 0, INIT_VLC_STATIC_OVERLONG, NULL);

670 offset += lev[i].flags_cb.table_size;

671

672 build_vlc(&lev[i + 1].bias_cb, clv_bias_len_counts[j],

673 &bias_syms, &offset);

674 j++;

675 }

676 }

677 }

678

679 static av_cold int clv_decode_init(AVCodecContext *avctx)

680 {

681 static AVOnce init_static_once = AV_ONCE_INIT;

682 CLVContext *const c = avctx->priv_data;

683 int ret, w, h;

684

685 if (avctx->extradata_size == 110) {

686 c->tile_size = AV_RL32(&avctx->extradata[94]);

687 } else if (avctx->extradata_size == 150) {

688 c->tile_size = AV_RB32(&avctx->extradata[134]);

689 } else if (!avctx->extradata_size) {

690 c->tile_size = 16;

691 } else {

692 av_log(avctx, AV_LOG_ERROR, "Unsupported extradata size: %d\n", avctx->extradata_size);

693 return AVERROR_INVALIDDATA;

694 }

695

696 c->tile_shift = av_log2(c->tile_size);

697 if (1U << c->tile_shift != c->tile_size || c->tile_shift < 1 || c->tile_shift > 30) {

698 av_log(avctx, AV_LOG_ERROR, "Tile size: %d, is not power of 2 > 1 and < 2^31\n", c->tile_size);

699 return AVERROR_INVALIDDATA;

700 }

701

702 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

703 w = avctx->width;

704 h = avctx->height;

705 ret = ff_set_dimensions(avctx, FFALIGN(w, 1 << c->tile_shift), FFALIGN(h, 1 << c->tile_shift));

706 if (ret < 0)

707 return ret;

708 avctx->width = w;

709 avctx->height = h;

710

711 c->avctx = avctx;

712 c->mb_width = FFALIGN(avctx->width, 16) >> 4;

713 c->mb_height = FFALIGN(avctx->height, 16) >> 4;

714 c->pmb_width = (w + c->tile_size - 1) >> c->tile_shift;

715 c->pmb_height = (h + c->tile_size - 1) >> c->tile_shift;

716 c->pic = av_frame_alloc();

717 c->prev = av_frame_alloc();

718 c->mvi.mv = av_calloc(c->pmb_width * 2, sizeof(*c->mvi.mv));

719 if (!c->pic || !c->prev || !c->mvi.mv)

720 return AVERROR(ENOMEM);

721

722 ff_idctdsp_init(&c->idsp, avctx);

723

724 ff_thread_once(&init_static_once, clv_init_static);

725

726 return 0;

727 }

728

729 static av_cold int clv_decode_end(AVCodecContext *avctx)

730 {

731 CLVContext *const c = avctx->priv_data;

732

733 av_frame_free(&c->prev);

734 av_frame_free(&c->pic);

735

736 av_freep(&c->mvi.mv);

737

738 return 0;

739 }

740

741 const FFCodec ff_clearvideo_decoder = {

742 .p.name = "clearvideo",

743 CODEC_LONG_NAME("Iterated Systems ClearVideo"),

744 .p.type = AVMEDIA_TYPE_VIDEO,

745 .p.id = AV_CODEC_ID_CLEARVIDEO,

746 .priv_data_size = sizeof(CLVContext),

747 .init = clv_decode_init,

748 .close = clv_decode_end,

749 FF_CODEC_DECODE_CB(clv_decode_frame),

750 .p.capabilities = AV_CODEC_CAP_DR1,

751 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

752 };

#define A(x)

Definition: vpx_arith.h:28

MAX_VLC_ENTRIES

#define MAX_VLC_ENTRIES

Definition: clearvideodata.h:27

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

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

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:664

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

mem_internal.h

comp

static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)

Definition: eamad.c:80

GetByteContext

Definition: bytestream.h:33

clv_dc_syms

static const uint8_t clv_dc_syms[NUM_DC_CODES]

Definition: clearvideodata.h:41

thread.h

CLVContext::pmb_width

int pmb_width

Definition: clearvideo.c:69

LevelCodes::mv_cb

VLC mv_cb

Definition: clearvideo.c:43

static const int8_t mv[256][2]

Definition: 4xm.c:80

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:99

MVInfo::mv

MV * mv

Definition: clearvideo.c:59

AVFrame

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

Definition: frame.h:330

clv_mv_syms

static const uint16_t clv_mv_syms[]

Definition: clearvideodata.h:112

MV::y

int16_t y

Definition: clearvideo.c:48

AVFrame::width

int width

Definition: frame.h:402

uint8_t w

Definition: llviddspenc.c:38

AVPacket::data

uint8_t * data

Definition: packet.h:374

MVInfo::mb_w

int mb_w

Definition: clearvideo.c:54

clv_decode_frame

static int clv_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)

Definition: clearvideo.c:483

mvi_update_prediction

static void mvi_update_prediction(MV *mv, MV diff)

Definition: clearvideo.c:339

FFCodec

Definition: codec_internal.h:127

clearvideodata.h

CLVContext::top_dc

int top_dc[3]

Definition: clearvideo.c:75

CLVContext::mvi

MVInfo mvi

Definition: clearvideo.c:70

clv_flags_syms

static const uint8_t clv_flags_syms[][16]

Definition: clearvideodata.h:90

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

CLVContext::pic

AVFrame * pic

Definition: clearvideo.c:65

ff_idctdsp_init

av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)

Definition: idctdsp.c:228

clv_decode_init

static av_cold int clv_decode_init(AVCodecContext *avctx)

Definition: clearvideo.c:679

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:351

MVInfo::top

int top

Definition: clearvideo.c:58

LevelCodes::flags_cb

VLC flags_cb

Definition: clearvideo.c:42

ROP

#define ROP(x)

Definition: clearvideo.c:150

bytestream2_skip

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

Definition: bytestream.h:168

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:325

extend_edges

static void extend_edges(AVFrame *buf, int tile_size)

Definition: clearvideo.c:444

BIAS_ESC

#define BIAS_ESC

Definition: clearvideodata.h:619

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

decode_mb

static int decode_mb(CLVContext *c, int x, int y)

Definition: clearvideo.c:171

GetBitContext

Definition: get_bits.h:107

clv_dc_lens

static const uint8_t clv_dc_lens[NUM_DC_CODES]

Definition: clearvideodata.h:31

CLVContext::mb_width

int mb_width

Definition: clearvideo.c:68

val

static double val(void *priv, double ch)

Definition: aeval.c:77

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:613

dc_vlc

static VLC dc_vlc

Definition: clearvideo.c:78

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:87

clv_init_static

static av_cold void clv_init_static(void)

Definition: clearvideo.c:646

s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C

Definition: writing_filters.txt:58

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:184

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

clv_bias_syms

static const uint16_t clv_bias_syms[]

Definition: clearvideodata.h:620

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:524

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

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:365

CLVContext::avctx

AVCodecContext * avctx

Definition: clearvideo.c:63

clv_dct

static void clv_dct(int16_t *block)

Definition: clearvideo.c:153

CLVContext::gb

GetBitContext gb

Definition: clearvideo.c:67

vlc_buf

static VLCElem vlc_buf[16716]

Definition: clearvideo.c:80

#define B

Definition: huffyuv.h:42

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:310

ctx

AVFormatContext * ctx

Definition: movenc.c:48

decode.h

get_bits.h

MV::x

int16_t x

Definition: clearvideo.c:48

CLVContext::left_dc

int left_dc[4]

Definition: clearvideo.c:75

LevelCodes

Definition: clearvideo.c:41

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:66

blk

#define blk(i)

Definition: sha.c:186

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

mvi_predict

static MV * mvi_predict(MVInfo *mvi, int mb_x, int mb_y)

Definition: clearvideo.c:293

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:64

CLVContext::tile_shift

int tile_shift

Definition: clearvideo.c:72

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:182

NULL

#define NULL

Definition: coverity.c:32

bias

static int bias(int x, int c)

Definition: vqcdec.c:113

INIT_VLC_STATIC_FROM_LENGTHS

#define INIT_VLC_STATIC_FROM_LENGTHS(vlc, bits, nb_codes, lens, len_wrap, symbols, symbols_wrap, symbols_size, offset, flags, static_size)

Definition: vlc.h:131

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:378

ff_init_vlc_from_lengths

int ff_init_vlc_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)

Build VLC decoding tables suitable for use with get_vlc2()

Definition: vlc.c:328

mathops.h

clv_decode_end

static av_cold int clv_decode_end(AVCodecContext *avctx)

Definition: clearvideo.c:729

copyadd_block

static int copyadd_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src, int plane, int x, int y, int dx, int dy, int size, int bias)

Definition: clearvideo.c:255

MVInfo

Definition: clearvideo.c:53

MVInfo::mb_stride

int mb_stride

Definition: clearvideo.c:57

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:631

mvi_update_row

static void mvi_update_row(MVInfo *mvi)

Definition: clearvideo.c:355

AVOnce

#define AVOnce

Definition: thread.h:181

ac_vlc

static VLC ac_vlc

Definition: clearvideo.c:78

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_tell

static av_always_inline int bytestream2_tell(GetByteContext *g)

Definition: bytestream.h:192

VLC::table_allocated

int table_allocated

Definition: vlc.h:34

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

av_frame_ref

int av_frame_ref(AVFrame *dst, const AVFrame *src)

Set up a new reference to the data described by the source frame.

Definition: frame.c:344

MVInfo::mb_h

int mb_h

Definition: clearvideo.c:55

codec_internal.h

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:87

shift

static int shift(int a, int b)

Definition: bonk.c:257

av_frame_copy

int av_frame_copy(AVFrame *dst, const AVFrame *src)

Copy the frame data from src to dst.

Definition: frame.c:762

Definition: clearvideo.c:47

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:425

size

int size

Definition: twinvq_data.h:10344

VLCElem

Definition: vlc.h:27

AV_RB32

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_RB32

Definition: bytestream.h:96

ff_clearvideo_decoder

const FFCodec ff_clearvideo_decoder

Definition: clearvideo.c:741

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:162

CLVContext::pmb_height

int pmb_height

Definition: clearvideo.c:69

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

NUM_AC_CODES

#define NUM_AC_CODES

Definition: clearvideodata.h:29

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

Definition: cbs_h2645.c:269

frame_type

Definition: jpeg2000_parser.c:31

pred_mv

static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)

Definition: diracdec.c:1391

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:527

clv_ac_bits

static const uint8_t clv_ac_bits[NUM_AC_CODES]

Definition: clearvideodata.h:71

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:191

lev

static LevelCodes lev[4+3+3]

Definition: clearvideo.c:79

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

CLVContext::tile_size

int tile_size

Definition: clearvideo.c:71

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:262

clv_flags_bits

static const uint8_t clv_flags_bits[][16]

Definition: clearvideodata.h:80

idctdsp.h

avcodec.h

CLV_VLC_BITS

#define CLV_VLC_BITS

Definition: clearvideo.c:39

stride

#define stride

Definition: h264pred_template.c:537

ff_zigzag_direct

const uint8_t ff_zigzag_direct[64]

Definition: mathtables.c:98

mid_pred

#define mid_pred

Definition: mathops.h:98

ff_reget_buffer

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

Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.

Definition: decode.c:1591

ret

Definition: filter_design.txt:187

INIT_VLC_STATIC_OVERLONG

#define INIT_VLC_STATIC_OVERLONG

Definition: vlc.h:101

pred

static const float pred[4]

Definition: siprdata.h:259

FFSWAP

#define FFSWAP(type, a, b)

Definition: macros.h:52

copy_block

static int copy_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src, int plane, int x, int y, int dx, int dy, int size)

Definition: clearvideo.c:218

IDCTDSPContext

Definition: idctdsp.h:44

COP

#define COP(x)

Definition: clearvideo.c:151

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

#define U(x)

Definition: vpx_arith.h:37

CLVContext::luma_dc_quant

int luma_dc_quant

Definition: clearvideo.c:73

LevelCodes::bias_cb

VLC bias_cb

Definition: clearvideo.c:44

AVCodecContext

main external API structure.

Definition: avcodec.h:426

AVFrame::height

int height

Definition: frame.h:402

decode_block

static int decode_block(CLVContext *ctx, int16_t *blk, int has_ac, int ac_quant)

Definition: clearvideo.c:82

CLVContext::mb_height

int mb_height

Definition: clearvideo.c:68

VLC

Definition: vlc.h:31

MV_ESC

#define MV_ESC

Definition: clearvideodata.h:111

DCT_TEMPLATE

#define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP)

Definition: clearvideo.c:126

VLC::table

VLCElem * table

Definition: vlc.h:33

av_clip_uint8

#define av_clip_uint8

Definition: common.h:101

VLC::table_size

int table_size

Definition: vlc.h:34

AVCodecContext::coded_width

int coded_width

Bitstream width / height, may be different from width/height e.g.

Definition: avcodec.h:613

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:275

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

CLVContext::prev

AVFrame * prev

Definition: clearvideo.c:66

mvi_reset

static void mvi_reset(MVInfo *mvi, int mb_w, int mb_h, int mb_size)

Definition: clearvideo.c:345

AVCodecContext::codec_tag

unsigned int codec_tag

fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').

Definition: avcodec.h:451

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

CLVContext::idsp

IDCTDSPContext idsp

Definition: clearvideo.c:64

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:453

AVPacket

This structure stores compressed data.

Definition: packet.h:351

clv_mv_len_counts

static const uint8_t clv_mv_len_counts[][16]

Definition: clearvideodata.h:100

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

src

INIT_CLIP pixel * src

Definition: h264pred_template.c:418

CLVContext::chroma_dc_quant

int chroma_dc_quant

Definition: clearvideo.c:73

NUM_DC_CODES

#define NUM_DC_CODES

Definition: clearvideodata.h:28

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

block

The exact code depends on how similar the blocks are and how related they are to the block

Definition: filter_design.txt:207

CLVContext

Definition: clearvideo.c:62

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

CLVContext::block

int16_t block[64]

Definition: clearvideo.c:74

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

MKTAG

#define MKTAG(a, b, c, d)

Definition: macros.h:55

Definition: vp9dsp_template.c:2038

AV_CODEC_ID_CLEARVIDEO

@ AV_CODEC_ID_CLEARVIDEO

Definition: codec_id.h:281

zero_mv

static const MV zero_mv

Definition: clearvideo.c:51

tile_do_block

static int tile_do_block(AVCodecContext *avctx, AVFrame *dst, const AVFrame *src, int plane, int x, int y, int dx, int dy, int size, int bias)

Definition: clearvideo.c:365

CLVContext::ac_quant

int ac_quant

Definition: clearvideo.c:73

decode_tile

static int decode_tile(AVCodecContext *avctx, GetBitContext *gb, const LevelCodes *lc, AVFrame *dst, const AVFrame *src, int plane, int x, int y, int size, MV root_mv, MV *pred)

Definition: clearvideo.c:379

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

MVInfo::mb_size

int mb_size

Definition: clearvideo.c:56

skip

static void BS_FUNC() skip(BSCTX *bc, unsigned int n)

Skip n bits in the buffer.

Definition: bitstream_template.h:375

clv_ac_syms