FFmpeg: libavcodec/mss4.c Source File

FFmpeg

[フレーム]

libavcodec

mss4.c

Go to the documentation of this file.

1 /*

2 * Microsoft Screen 4 (aka Microsoft Expression Encoder Screen) 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 * Microsoft Screen 4 (aka Microsoft Titanium Screen 2,

25 * aka Microsoft Expression Encoder Screen) decoder

26 */

28 #include "libavutil/thread.h"

29 #include "libavutil/imgutils.h"

31 #include "avcodec.h"

32 #include "bytestream.h"

33 #include "codec_internal.h"

34 #include "get_bits.h"

35 #include "internal.h"

36 #include "jpegtables.h"

37 #include "mss34dsp.h"

38 #include "unary.h"

40 #define HEADER_SIZE 8

42 enum FrameType {

43 INTRA_FRAME = 0,

44 INTER_FRAME,

45 SKIP_FRAME

46 };

48 enum BlockType {

49 SKIP_BLOCK = 0,

50 DCT_BLOCK,

51 IMAGE_BLOCK,

52 };

54 enum CachePos {

55 LEFT = 0,

56 TOP_LEFT,

57 TOP,

58 };

60 static const uint8_t mss4_dc_vlc_lens[2][16] = {

61 { 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },

62 { 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }

63 };

65 static const uint8_t vec_len_syms[2][4] = {

66 { 4, 2, 3, 1 },

67 { 4, 1, 2, 3 }

68 };

70 static const uint8_t mss4_vec_entry_vlc_lens[2][16] = {

71 { 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

72 { 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }

73 };

75 static const uint8_t mss4_vec_entry_vlc_syms[2][9] = {

76 { 0, 7, 6, 5, 8, 4, 3, 1, 2 },

77 { 0, 2, 3, 4, 5, 6, 7, 1, 8 }

78 };

80 #define MAX_ENTRIES 162

82 typedef struct MSS4Context {

83 AVFrame *pic;

85 int block[64];

86 uint8_t imgbuf[3][16 * 16];

88 int quality;

89 uint16_t quant_mat[2][64];

91 int *prev_dc[3];

92 ptrdiff_t dc_stride[3];

93 int dc_cache[4][4];

95 int prev_vec[3][4];

96 } MSS4Context;

98 static VLC dc_vlc[2], ac_vlc[2];

99 static VLC vec_entry_vlc[2];

100

101 static av_cold void mss4_init_vlc(VLC *vlc, unsigned *offset,

102 const uint8_t *lens, const uint8_t *syms)

103 {

104 static VLCElem vlc_buf[2146];

105 uint8_t bits[MAX_ENTRIES];

106 int i, j;

107 int idx = 0;

108

109 for (i = 0; i < 16; i++) {

110 for (j = 0; j < lens[i]; j++) {

111 bits[idx] = i + 1;

112 idx++;

113 }

114 }

115

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

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

118 ff_init_vlc_from_lengths(vlc, FFMIN(bits[idx - 1], 9), idx,

119 bits, 1, syms, 1, 1,

120 0, INIT_VLC_STATIC_OVERLONG, NULL);

121 *offset += vlc->table_size;

122 }

123

124 static av_cold void mss4_init_vlcs(void)

125 {

126 for (unsigned i = 0, offset = 0; i < 2; i++) {

127 mss4_init_vlc(&dc_vlc[i], &offset, mss4_dc_vlc_lens[i], NULL);

128 mss4_init_vlc(&ac_vlc[i], &offset,

129 i ? ff_mjpeg_bits_ac_chrominance + 1

130 : ff_mjpeg_bits_ac_luminance + 1,

131 i ? ff_mjpeg_val_ac_chrominance

132 : ff_mjpeg_val_ac_luminance);

133 mss4_init_vlc(&vec_entry_vlc[i], &offset, mss4_vec_entry_vlc_lens[i],

134 mss4_vec_entry_vlc_syms[i]);

135 }

136 }

137

138 /* This function returns values in the range

139 * (-range + 1; -range/2] U [range/2; range - 1)

140 * i.e.

141 * nbits = 0 -> 0

142 * nbits = 1 -> -1, 1

143 * nbits = 2 -> -3, -2, 2, 3

144 */

145 static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)

146 {

147 int val;

148

149 if (!nbits)

150 return 0;

151

152 val = get_bits(gb, nbits);

153 if (val < (1 << (nbits - 1)))

154 val -= (1 << nbits) - 1;

155

156 return val;

157 }

158

159 static inline int get_coeff(GetBitContext *gb, VLC *vlc)

160 {

161 int val = get_vlc2(gb, vlc->table, vlc->bits, 2);

162

163 return get_coeff_bits(gb, val);

164 }

165

166 static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,

167 int *block, int *dc_cache,

168 int bx, int by, uint16_t *quant_mat)

169 {

170 int skip, val, pos = 1, zz_pos, dc;

171

172 memset(block, 0, sizeof(*block) * 64);

173

174 dc = get_coeff(gb, dc_vlc);

175 // DC prediction is the same as in MSS3

176 if (by) {

177 if (bx) {

178 int l, tl, t;

179

180 l = dc_cache[LEFT];

181 tl = dc_cache[TOP_LEFT];

182 t = dc_cache[TOP];

183

184 if (FFABS(t - tl) <= FFABS(l - tl))

185 dc += l;

186 else

187 dc += t;

188 } else {

189 dc += dc_cache[TOP];

190 }

191 } else if (bx) {

192 dc += dc_cache[LEFT];

193 }

194 dc_cache[LEFT] = dc;

195 block[0] = dc * quant_mat[0];

196

197 while (pos < 64) {

198 val = get_vlc2(gb, ac_vlc->table, 9, 2);

199 if (!val)

200 return 0;

201 if (val == -1)

202 return -1;

203 if (val == 0xF0) {

204 pos += 16;

205 continue;

206 }

207 skip = val >> 4;

208 val = get_coeff_bits(gb, val & 0xF);

209 pos += skip;

210 if (pos >= 64)

211 return -1;

212

213 zz_pos = ff_zigzag_direct[pos];

214 block[zz_pos] = val * quant_mat[zz_pos];

215 pos++;

216 }

217

218 return pos == 64 ? 0 : -1;

219 }

220

221 static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,

222 uint8_t *dst[3], int mb_x, int mb_y)

223 {

224 int i, j, k, ret;

225 uint8_t *out = dst[0];

226

227 for (j = 0; j < 2; j++) {

228 for (i = 0; i < 2; i++) {

229 int xpos = mb_x * 2 + i;

230 c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];

231 c->dc_cache[j][TOP] = c->prev_dc[0][mb_x * 2 + i];

232 ret = mss4_decode_dct(gb, &dc_vlc[0], &ac_vlc[0], c->block,

233 c->dc_cache[j],

234 xpos, mb_y * 2 + j, c->quant_mat[0]);

235 if (ret)

236 return ret;

237 c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];

238

239 ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],

240 c->block);

241 }

242 out += 8 * c->pic->linesize[0];

243 }

244

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

246 c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];

247 c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];

248 ret = mss4_decode_dct(gb, &dc_vlc[1], &ac_vlc[1],

249 c->block, c->dc_cache[i + 1], mb_x, mb_y,

250 c->quant_mat[1]);

251 if (ret)

252 return ret;

253 c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];

254

255 ff_mss34_dct_put(c->imgbuf[i], 8, c->block);

256 out = dst[i] + mb_x * 16;

257 // Since the DCT block is coded as YUV420 and the whole frame as YUV444,

258 // we need to scale chroma.

259 for (j = 0; j < 16; j++) {

260 for (k = 0; k < 8; k++)

261 AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);

262 out += c->pic->linesize[i];

263 }

264 }

265

266 return 0;

267 }

268

269 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,

270 int *sel_len, int *prev)

271 {

272 int i, y_flag = 0;

273

274 for (i = 2; i >= 0; i--) {

275 if (!sel_flag[i]) {

276 vec_pos[i] = 0;

277 continue;

278 }

279 if ((!i && !y_flag) || get_bits1(gb)) {

280 if (sel_len[i] > 0) {

281 int pval = prev[i];

282 vec_pos[i] = get_bits(gb, sel_len[i]);

283 if (vec_pos[i] >= pval)

284 vec_pos[i]++;

285 } else {

286 vec_pos[i] = !prev[i];

287 }

288 y_flag = 1;

289 } else {

290 vec_pos[i] = prev[i];

291 }

292 }

293 }

294

295 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,

296 int vec_size, int component, int shift, int *prev)

297 {

298 if (vec_pos < vec_size)

299 return vec[vec_pos];

300 if (!get_bits1(gb))

301 return prev[component];

302 prev[component] = get_bits(gb, 8 - shift) << shift;

303 return prev[component];

304 }

305

306 #define MKVAL(vals) ((vals)[0] | ((vals)[1] << 3) | ((vals)[2] << 6))

307

308 /* Image mode - the hardest to comprehend MSS4 coding mode.

309 *

310 * In this mode all three 16x16 blocks are coded together with a method

311 * remotely similar to the methods employed in MSS1-MSS3.

312 * The idea is that every component has a vector of 1-4 most common symbols

313 * and an escape mode for reading new value from the bitstream. Decoding

314 * consists of retrieving pixel values from the vector or reading new ones

315 * from the bitstream; depending on flags read from the bitstream, these vector

316 * positions can be updated or reused from the state of the previous line

317 * or previous pixel.

318 */

319 static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,

320 uint8_t *picdst[3], int mb_x, int mb_y)

321 {

322 uint8_t vec[3][4];

323 int vec_len[3];

324 int sel_len[3], sel_flag[3];

325 int i, j, k, mode, split;

326 int prev_vec1 = 0, prev_split = 0;

327 int vals[3] = { 0 };

328 int prev_pix[3] = { 0 };

329 int prev_mode[16] = { 0 };

330 uint8_t *dst[3];

331

332 const int val_shift = ctx->quality == 100 ? 0 : 2;

333

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

335 dst[i] = ctx->imgbuf[i];

336

337 for (i = 0; i < 3; i++) {

338 vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];

339 for (j = 0; j < vec_len[i]; j++) {

340 vec[i][j] = get_coeff(gb, &vec_entry_vlc[!!i]);

341 vec[i][j] += ctx->prev_vec[i][j];

342 ctx->prev_vec[i][j] = vec[i][j];

343 }

344 sel_flag[i] = vec_len[i] > 1;

345 sel_len[i] = vec_len[i] > 2 ? vec_len[i] - 2 : 0;

346 }

347

348 for (j = 0; j < 16; j++) {

349 if (get_bits1(gb)) {

350 split = 0;

351 if (get_bits1(gb)) {

352 prev_mode[0] = 0;

353 vals[0] = vals[1] = vals[2] = 0;

354 mode = 2;

355 } else {

356 mode = get_bits1(gb);

357 if (mode)

358 split = get_bits(gb, 4);

359 }

360 for (i = 0; i < 16; i++) {

361 if (mode <= 1) {

362 vals[0] = prev_mode[i] & 7;

363 vals[1] = (prev_mode[i] >> 3) & 7;

364 vals[2] = prev_mode[i] >> 6;

365 if (mode == 1 && i == split) {

366 read_vec_pos(gb, vals, sel_flag, sel_len, vals);

367 }

368 } else if (mode == 2) {

369 if (get_bits1(gb))

370 read_vec_pos(gb, vals, sel_flag, sel_len, vals);

371 }

372 for (k = 0; k < 3; k++)

373 *dst[k]++ = get_value_cached(gb, vals[k], vec[k],

374 vec_len[k], k,

375 val_shift, prev_pix);

376 prev_mode[i] = MKVAL(vals);

377 }

378 } else {

379 if (get_bits1(gb)) {

380 split = get_bits(gb, 4);

381 if (split >= prev_split)

382 split++;

383 prev_split = split;

384 } else {

385 split = prev_split;

386 }

387 if (split) {

388 vals[0] = prev_mode[0] & 7;

389 vals[1] = (prev_mode[0] >> 3) & 7;

390 vals[2] = prev_mode[0] >> 6;

391 for (i = 0; i < 3; i++) {

392 for (k = 0; k < split; k++) {

393 *dst[i]++ = get_value_cached(gb, vals[i], vec[i],

394 vec_len[i], i, val_shift,

395 prev_pix);

396 prev_mode[k] = MKVAL(vals);

397 }

398 }

399 }

400

401 if (split != 16) {

402 vals[0] = prev_vec1 & 7;

403 vals[1] = (prev_vec1 >> 3) & 7;

404 vals[2] = prev_vec1 >> 6;

405 if (get_bits1(gb)) {

406 read_vec_pos(gb, vals, sel_flag, sel_len, vals);

407 prev_vec1 = MKVAL(vals);

408 }

409 for (i = 0; i < 3; i++) {

410 for (k = 0; k < 16 - split; k++) {

411 *dst[i]++ = get_value_cached(gb, vals[i], vec[i],

412 vec_len[i], i, val_shift,

413 prev_pix);

414 prev_mode[split + k] = MKVAL(vals);

415 }

416 }

417 }

418 }

419 }

420

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

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

423 memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],

424 ctx->imgbuf[i] + j * 16, 16);

425

426 return 0;

427 }

428

429 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)

430 {

431 int i;

432

433 c->dc_cache[0][TOP] = c->prev_dc[0][mb_x * 2 + 1];

434 c->dc_cache[0][LEFT] = 0;

435 c->dc_cache[1][TOP] = 0;

436 c->dc_cache[1][LEFT] = 0;

437

438 for (i = 0; i < 2; i++)

439 c->prev_dc[0][mb_x * 2 + i] = 0;

440

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

442 c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];

443 c->dc_cache[i + 1][LEFT] = 0;

444 c->prev_dc[i][mb_x] = 0;

445 }

446 }

447

448 static int mss4_decode_frame(AVCodecContext *avctx, AVFrame *rframe,

449 int *got_frame, AVPacket *avpkt)

450 {

451 const uint8_t *buf = avpkt->data;

452 int buf_size = avpkt->size;

453 MSS4Context *c = avctx->priv_data;

454 GetBitContext gb;

455 GetByteContext bc;

456 uint8_t *dst[3];

457 int width, height, quality, frame_type;

458 int x, y, i, mb_width, mb_height, blk_type;

459 int ret;

460

461 if (buf_size < HEADER_SIZE) {

462 av_log(avctx, AV_LOG_ERROR,

463 "Frame should have at least %d bytes, got %d instead\n",

464 HEADER_SIZE, buf_size);

465 return AVERROR_INVALIDDATA;

466 }

467

468 bytestream2_init(&bc, buf, buf_size);

469 width = bytestream2_get_be16(&bc);

470 height = bytestream2_get_be16(&bc);

471 bytestream2_skip(&bc, 2);

472 quality = bytestream2_get_byte(&bc);

473 frame_type = bytestream2_get_byte(&bc);

474

475 if (width > avctx->width ||

476 height != avctx->height) {

477 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",

478 width, height);

479 return AVERROR_INVALIDDATA;

480 }

481 if (av_image_check_size2(width, height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)

482 return AVERROR_INVALIDDATA;

483

484 if (quality < 1 || quality > 100) {

485 av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);

486 return AVERROR_INVALIDDATA;

487 }

488 if ((frame_type & ~3) || frame_type == 3) {

489 av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);

490 return AVERROR_INVALIDDATA;

491 }

492

493 if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {

494 av_log(avctx, AV_LOG_ERROR,

495 "Empty frame found but it is not a skip frame.\n");

496 return AVERROR_INVALIDDATA;

497 }

498 mb_width = FFALIGN(width, 16) >> 4;

499 mb_height = FFALIGN(height, 16) >> 4;

500

501 if (frame_type != SKIP_FRAME && 8*buf_size < 8*HEADER_SIZE + mb_width*mb_height)

502 return AVERROR_INVALIDDATA;

503

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

505 return ret;

506 c->pic->key_frame = (frame_type == INTRA_FRAME);

507 c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I

508 : AV_PICTURE_TYPE_P;

509 if (frame_type == SKIP_FRAME) {

510 *got_frame = 1;

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

512 return ret;

513

514 return buf_size;

515 }

516

517 if (c->quality != quality) {

518 c->quality = quality;

519 for (i = 0; i < 2; i++)

520 ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);

521 }

522

523 if ((ret = init_get_bits8(&gb, buf + HEADER_SIZE, buf_size - HEADER_SIZE)) < 0)

524 return ret;

525 dst[0] = c->pic->data[0];

526 dst[1] = c->pic->data[1];

527 dst[2] = c->pic->data[2];

528

529 memset(c->prev_vec, 0, sizeof(c->prev_vec));

530 for (y = 0; y < mb_height; y++) {

531 memset(c->dc_cache, 0, sizeof(c->dc_cache));

532 for (x = 0; x < mb_width; x++) {

533 blk_type = decode012(&gb);

534 switch (blk_type) {

535 case DCT_BLOCK:

536 if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {

537 av_log(avctx, AV_LOG_ERROR,

538 "Error decoding DCT block %d,%d\n",

539 x, y);

540 return AVERROR_INVALIDDATA;

541 }

542 break;

543 case IMAGE_BLOCK:

544 if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {

545 av_log(avctx, AV_LOG_ERROR,

546 "Error decoding VQ block %d,%d\n",

547 x, y);

548 return AVERROR_INVALIDDATA;

549 }

550 break;

551 case SKIP_BLOCK:

552 if (frame_type == INTRA_FRAME) {

553 av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");

554 return AVERROR_INVALIDDATA;

555 }

556 break;

557 }

558 if (blk_type != DCT_BLOCK)

559 mss4_update_dc_cache(c, x);

560 }

561 dst[0] += c->pic->linesize[0] * 16;

562 dst[1] += c->pic->linesize[1] * 16;

563 dst[2] += c->pic->linesize[2] * 16;

564 }

565

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

567 return ret;

568

569 *got_frame = 1;

570

571 return buf_size;

572 }

573

574 static av_cold int mss4_decode_end(AVCodecContext *avctx)

575 {

576 MSS4Context * const c = avctx->priv_data;

577 int i;

578

579 av_frame_free(&c->pic);

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

581 av_freep(&c->prev_dc[i]);

582

583 return 0;

584 }

585

586 static av_cold int mss4_decode_init(AVCodecContext *avctx)

587 {

588 static AVOnce init_static_once = AV_ONCE_INIT;

589 MSS4Context * const c = avctx->priv_data;

590 int i;

591

592 for (i = 0; i < 3; i++) {

593 c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);

594 c->prev_dc[i] = av_malloc_array(c->dc_stride[i], sizeof(**c->prev_dc));

595 if (!c->prev_dc[i]) {

596 av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");

597 return AVERROR(ENOMEM);

598 }

599 }

600

601 c->pic = av_frame_alloc();

602 if (!c->pic)

603 return AVERROR(ENOMEM);

604

605 avctx->pix_fmt = AV_PIX_FMT_YUV444P;

606

607 ff_thread_once(&init_static_once, mss4_init_vlcs);

608

609 return 0;

610 }

611

612 const FFCodec ff_mts2_decoder = {

613 .p.name = "mts2",

614 .p.long_name = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),

615 .p.type = AVMEDIA_TYPE_VIDEO,

616 .p.id = AV_CODEC_ID_MTS2,

617 .priv_data_size = sizeof(MSS4Context),

618 .init = mss4_decode_init,

619 .close = mss4_decode_end,

620 FF_CODEC_DECODE_CB(mss4_decode_frame),

621 .p.capabilities = AV_CODEC_CAP_DR1,

622 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE,

623 };

ff_mss34_gen_quant_mat

void ff_mss34_gen_quant_mat(uint16_t *qmat, int quality, int luma)

Generate quantisation matrix for given quality.

Definition: mss34dsp.c:48

ff_mts2_decoder

const FFCodec ff_mts2_decoder

Definition: mss4.c:612

jpegtables.h

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

ac_vlc

static VLC ac_vlc[2]

Definition: mss4.c:98

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

MSS4Context

Definition: mss4.c:82

MSS4Context::prev_dc

int * prev_dc[3]

Definition: mss4.c:91

out

FILE * out

Definition: movenc.c:54

GetByteContext

Definition: bytestream.h:33

thread.h

MKVAL

#define MKVAL(vals)

Definition: mss4.c:306

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:111

AVFrame

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

Definition: frame.h:325

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:374

mss4_dc_vlc_lens

static const uint8_t mss4_dc_vlc_lens[2][16]

Definition: mss4.c:60

BlockType

Definition: mss3.c:69

FFCodec

Definition: codec_internal.h:112

get_coeff_bits

static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)

Definition: mss4.c:145

mss4_decode_frame

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

Definition: mss4.c:448

ff_mjpeg_bits_ac_chrominance

const uint8_t ff_mjpeg_bits_ac_chrominance[]

Definition: jpegtabs.h:66

DCT_BLOCK

@ DCT_BLOCK

Definition: mss4.c:50

quality

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality

Definition: rate_distortion.txt:12

SKIP_FRAME

@ SKIP_FRAME

Definition: mss4.c:45

init

static int init

Definition: av_tx.c:47

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

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:116

GetBitContext

Definition: get_bits.h:61

mss4_decode_end

static av_cold int mss4_decode_end(AVCodecContext *avctx)

Definition: mss4.c:574

val

static double val(void *priv, double ch)

Definition: aeval.c:77

av_image_check_size2

int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)

Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...

Definition: imgutils.c:289

mss4_decode_dct_block

static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb, uint8_t *dst[3], int mb_x, int mb_y)

Definition: mss4.c:221

INTRA_FRAME

@ INTRA_FRAME

Definition: mss4.c:43

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:99

ff_thread_once

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

Definition: thread.h:179

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

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

mss4_decode_dct

static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc, int *block, int *dc_cache, int bx, int by, uint16_t *quant_mat)

Definition: mss4.c:166

mss4_init_vlcs

static av_cold void mss4_init_vlcs(void)

Definition: mss4.c:124

width

#define width

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:254

read_vec_pos

static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag, int *sel_len, int *prev)

Definition: mss4.c:269

SKIP_BLOCK

@ SKIP_BLOCK

Definition: mss4.c:49

vlc_buf

static VLCElem vlc_buf[16716]

Definition: clearvideo.c:87

bits

uint8_t bits

Definition: vp3data.h:141

LEFT

@ LEFT

Definition: mss4.c:55

mss4_vec_entry_vlc_syms

static const uint8_t mss4_vec_entry_vlc_syms[2][9]

Definition: mss4.c:75

ctx

AVFormatContext * ctx

Definition: movenc.c:48

get_bits.h

AV_WN16A

#define AV_WN16A(p, v)

Definition: intreadwrite.h:534

AVCodecContext::max_pixels

int64_t max_pixels

The number of pixels per image to maximally accept.

Definition: avcodec.h:1908

decode012

static int decode012(GetBitContext *gb)

Definition: get_bits.h:821

mss4_decode_image_block

static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb, uint8_t *picdst[3], int mb_x, int mb_y)

Definition: mss4.c:319

FrameType

G723.1 frame types.

Definition: g723_1.h:63

FFABS

#define FFABS(a)

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

Definition: common.h:64

IMAGE_BLOCK

@ IMAGE_BLOCK

Definition: mss4.c:51

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:177

NULL

#define NULL

Definition: coverity.c:32

MSS4Context::pic

AVFrame * pic

Definition: mss4.c:83

INTER_FRAME

@ INTER_FRAME

Definition: mss4.c:44

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

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

vec_entry_vlc

static VLC vec_entry_vlc[2]

Definition: mss4.c:99

mss4_vec_entry_vlc_lens

static const uint8_t mss4_vec_entry_vlc_lens[2][16]

Definition: mss4.c:70

ff_mjpeg_val_ac_chrominance

const uint8_t ff_mjpeg_val_ac_chrominance[]

Definition: jpegtabs.h:69

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

AVOnce

#define AVOnce

Definition: thread.h:176

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

get_unary

static int get_unary(GetBitContext *gb, int stop, int len)

Get unary code of limited length.

Definition: unary.h:46

bytestream2_get_bytes_left

static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)

Definition: bytestream.h:158

mss34dsp.h

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

ff_mjpeg_val_ac_luminance

const uint8_t ff_mjpeg_val_ac_luminance[]

Definition: jpegtabs.h:42

AVPacket::size

int size

Definition: packet.h:375

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 top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]

Definition: snow.txt:400

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

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

MSS4Context::prev_vec

int prev_vec[3][4]

Definition: mss4.c:95

codec_internal.h

get_value_cached

static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec, int vec_size, int component, int shift, int *prev)

Definition: mss4.c:295

for

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

Definition: h264pred_template.c:425

ff_mjpeg_bits_ac_luminance

const uint8_t ff_mjpeg_bits_ac_luminance[]

Definition: jpegtabs.h:40

VLCElem

Definition: vlc.h:27

MAX_ENTRIES

#define MAX_ENTRIES

Definition: mss4.c:80

split

static char * split(char *message, char delim)

Definition: af_channelmap.c:81

height

#define height

mss4_init_vlc

static av_cold void mss4_init_vlc(VLC *vlc, unsigned *offset, const uint8_t *lens, const uint8_t *syms)

Definition: mss4.c:101

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

MSS4Context::quality

int quality

Definition: mss4.c:88

unary.h

HEADER_SIZE

#define HEADER_SIZE

Definition: mss4.c:40

MSS4Context::dc_cache

int dc_cache[4][4]

Definition: mss4.c:93

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

Definition: cbs_h2645.c:269

frame_type

Definition: jpeg2000_parser.c:31

AV_CODEC_ID_MTS2

@ AV_CODEC_ID_MTS2

Definition: codec_id.h:215

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:31

get_coeff

static int get_coeff(GetBitContext *gb, VLC *vlc)

Definition: mss4.c:159

av_always_inline

#define av_always_inline

Definition: attributes.h:49

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: codec_internal.h:31

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:203

MSS4Context::dc_stride

ptrdiff_t dc_stride[3]

Definition: mss4.c:92

dc_vlc

static VLC dc_vlc[2]

Definition: mss4.c:98

AVCodecContext::height

int height

Definition: avcodec.h:562

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:599

MSS4Context::quant_mat

uint16_t quant_mat[2][64]

Definition: mss4.c:89

avcodec.h

ff_zigzag_direct

const uint8_t ff_zigzag_direct[64]

Definition: mathtables.c:98

VLC::bits

int bits

Definition: vlc.h:32

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

ret

Definition: filter_design.txt:187

INIT_VLC_STATIC_OVERLONG

#define INIT_VLC_STATIC_OVERLONG

Definition: vlc.h:101

pos

unsigned int pos

Definition: spdifenc.c:412

vec_len_syms

static const uint8_t vec_len_syms[2][4]

Definition: mss4.c:65

AVCodecContext

main external API structure.

Definition: avcodec.h:389

mode

Definition: ebur128.h:83

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:65

TOP_LEFT

@ TOP_LEFT

Definition: mss4.c:56

VLC

Definition: vlc.h:31

MSS4Context::imgbuf

uint8_t imgbuf[3][16 *16]

Definition: mss4.c:86

mss4_update_dc_cache

static void mss4_update_dc_cache(MSS4Context *c, int mb_x)

Definition: mss4.c:429

VLC::table

VLCElem * table

Definition: vlc.h:33

AV_PIX_FMT_YUV444P

@ AV_PIX_FMT_YUV444P

planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)

Definition: pixfmt.h:71

shift

static int shift(int a, int b)

Definition: sonic.c:88

VLC::table_size

int table_size

Definition: vlc.h:34

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:275

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

TOP

@ TOP

Definition: mss4.c:57

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:416

AVPacket

This structure stores compressed data.

Definition: packet.h:351

MSS4Context::block

int block[64]

Definition: mss4.c:85

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:562

bytestream.h

imgutils.h

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:137

block

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

Definition: filter_design.txt:207

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

ff_mss34_dct_put

void ff_mss34_dct_put(uint8_t *dst, ptrdiff_t stride, int *block)

Transform and output DCT block.

Definition: mss34dsp.c:90

mss4_decode_init

static av_cold int mss4_decode_init(AVCodecContext *avctx)

Definition: mss4.c:586

CachePos

Definition: mss4.c:54

Generated on Wed Aug 24 2022 21:41:42 for FFmpeg by doxygen 1.8.17