FFmpeg: libavcodec/proresenc_kostya.c Source File

FFmpeg

[フレーム]

libavcodec

proresenc_kostya.c

Go to the documentation of this file.

1 /*

2 * Apple ProRes encoder

3 *

5 *

6 * This encoder appears to be based on Anatoliy Wassermans considering

7 * similarities in the bugs.

8 *

9 * This file is part of FFmpeg.

10 *

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

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

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

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

15 *

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

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

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

19 * Lesser General Public License for more details.

20 *

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

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

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

24 */

26 #include "libavutil/opt.h"

27 #include "libavutil/pixdesc.h"

28 #include "avcodec.h"

29 #include "fdctdsp.h"

30 #include "put_bits.h"

31 #include "bytestream.h"

32 #include "internal.h"

33 #include "proresdata.h"

35 #define CFACTOR_Y422 2

36 #define CFACTOR_Y444 3

38 #define MAX_MBS_PER_SLICE 8

40 #define MAX_PLANES 4

42 enum {

43 PRORES_PROFILE_AUTO = -1,

44 PRORES_PROFILE_PROXY = 0,

45 PRORES_PROFILE_LT,

46 PRORES_PROFILE_STANDARD,

47 PRORES_PROFILE_HQ,

48 PRORES_PROFILE_4444,

49 };

51 enum {

52 QUANT_MAT_PROXY = 0,

53 QUANT_MAT_LT,

54 QUANT_MAT_STANDARD,

55 QUANT_MAT_HQ,

56 QUANT_MAT_DEFAULT,

57 };

59 static const uint8_t prores_quant_matrices[][64] = {

60 { // proxy

61 4, 7, 9, 11, 13, 14, 15, 63,

62 7, 7, 11, 12, 14, 15, 63, 63,

63 9, 11, 13, 14, 15, 63, 63, 63,

64 11, 11, 13, 14, 63, 63, 63, 63,

65 11, 13, 14, 63, 63, 63, 63, 63,

66 13, 14, 63, 63, 63, 63, 63, 63,

67 13, 63, 63, 63, 63, 63, 63, 63,

68 63, 63, 63, 63, 63, 63, 63, 63,

69 },

70 { // LT

71 4, 5, 6, 7, 9, 11, 13, 15,

72 5, 5, 7, 8, 11, 13, 15, 17,

73 6, 7, 9, 11, 13, 15, 15, 17,

74 7, 7, 9, 11, 13, 15, 17, 19,

75 7, 9, 11, 13, 14, 16, 19, 23,

76 9, 11, 13, 14, 16, 19, 23, 29,

77 9, 11, 13, 15, 17, 21, 28, 35,

78 11, 13, 16, 17, 21, 28, 35, 41,

79 },

80 { // standard

81 4, 4, 5, 5, 6, 7, 7, 9,

82 4, 4, 5, 6, 7, 7, 9, 9,

83 5, 5, 6, 7, 7, 9, 9, 10,

84 5, 5, 6, 7, 7, 9, 9, 10,

85 5, 6, 7, 7, 8, 9, 10, 12,

86 6, 7, 7, 8, 9, 10, 12, 15,

87 6, 7, 7, 9, 10, 11, 14, 17,

88 7, 7, 9, 10, 11, 14, 17, 21,

89 },

90 { // high quality

91 4, 4, 4, 4, 4, 4, 4, 4,

92 4, 4, 4, 4, 4, 4, 4, 4,

93 4, 4, 4, 4, 4, 4, 4, 4,

94 4, 4, 4, 4, 4, 4, 4, 5,

95 4, 4, 4, 4, 4, 4, 5, 5,

96 4, 4, 4, 4, 4, 5, 5, 6,

97 4, 4, 4, 4, 5, 5, 6, 7,

98 4, 4, 4, 4, 5, 6, 7, 7,

99 },

100 { // codec default

101 4, 4, 4, 4, 4, 4, 4, 4,

102 4, 4, 4, 4, 4, 4, 4, 4,

103 4, 4, 4, 4, 4, 4, 4, 4,

104 4, 4, 4, 4, 4, 4, 4, 4,

105 4, 4, 4, 4, 4, 4, 4, 4,

106 4, 4, 4, 4, 4, 4, 4, 4,

107 4, 4, 4, 4, 4, 4, 4, 4,

108 4, 4, 4, 4, 4, 4, 4, 4,

109 },

110 };

111

112 #define NUM_MB_LIMITS 4

113 static const int prores_mb_limits[NUM_MB_LIMITS] = {

114 1620, // up to 720x576

115 2700, // up to 960x720

116 6075, // up to 1440x1080

117 9216, // up to 2048x1152

118 };

119

120 static const struct prores_profile {

121 const char *full_name;

122 uint32_t tag;

123 int min_quant;

124 int max_quant;

125 int br_tab[NUM_MB_LIMITS];

126 int quant;

127 } prores_profile_info[5] = {

128 {

129 .full_name = "proxy",

130 .tag = MKTAG('a', 'p', 'c', 'o'),

131 .min_quant = 4,

132 .max_quant = 8,

133 .br_tab = { 300, 242, 220, 194 },

134 .quant = QUANT_MAT_PROXY,

135 },

136 {

137 .full_name = "LT",

138 .tag = MKTAG('a', 'p', 'c', 's'),

139 .min_quant = 1,

140 .max_quant = 9,

141 .br_tab = { 720, 560, 490, 440 },

142 .quant = QUANT_MAT_LT,

143 },

144 {

145 .full_name = "standard",

146 .tag = MKTAG('a', 'p', 'c', 'n'),

147 .min_quant = 1,

148 .max_quant = 6,

149 .br_tab = { 1050, 808, 710, 632 },

150 .quant = QUANT_MAT_STANDARD,

151 },

152 {

153 .full_name = "high quality",

154 .tag = MKTAG('a', 'p', 'c', 'h'),

155 .min_quant = 1,

156 .max_quant = 6,

157 .br_tab = { 1566, 1216, 1070, 950 },

158 .quant = QUANT_MAT_HQ,

159 },

160 {

161 .full_name = "4444",

162 .tag = MKTAG('a', 'p', '4', 'h'),

163 .min_quant = 1,

164 .max_quant = 6,

165 .br_tab = { 2350, 1828, 1600, 1425 },

166 .quant = QUANT_MAT_HQ,

167 }

168 };

169

170 #define TRELLIS_WIDTH 16

171 #define SCORE_LIMIT INT_MAX / 2

172

173 struct TrellisNode {

174 int prev_node;

175 int quant;

176 int bits;

177 int score;

178 };

179

180 #define MAX_STORED_Q 16

181

182 typedef struct ProresThreadData {

183 DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];

184 DECLARE_ALIGNED(16, uint16_t, emu_buf)[16 * 16];

185 int16_t custom_q[64];

186 struct TrellisNode *nodes;

187 } ProresThreadData;

188

189 typedef struct ProresContext {

190 AVClass *class;

191 DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];

192 DECLARE_ALIGNED(16, uint16_t, emu_buf)[16*16];

193 int16_t quants[MAX_STORED_Q][64];

194 int16_t custom_q[64];

195 const uint8_t *quant_mat;

196 const uint8_t *scantable;

197

198 void (*fdct)(FDCTDSPContext *fdsp, const uint16_t *src,

199 int linesize, int16_t *block);

200 FDCTDSPContext fdsp;

201

202 int mb_width, mb_height;

203 int mbs_per_slice;

204 int num_chroma_blocks, chroma_factor;

205 int slices_width;

206 int slices_per_picture;

207 int pictures_per_frame; // 1 for progressive, 2 for interlaced

208 int cur_picture_idx;

209 int num_planes;

210 int bits_per_mb;

211 int force_quant;

212 int alpha_bits;

213 int warn;

214

215 char *vendor;

216 int quant_sel;

217

218 int frame_size_upper_bound;

219

220 int profile;

221 const struct prores_profile *profile_info;

222

223 int *slice_q;

224

225 ProresThreadData *tdata;

226 } ProresContext;

227

228 static void get_slice_data(ProresContext *ctx, const uint16_t *src,

229 int linesize, int x, int y, int w, int h,

230 int16_t *blocks, uint16_t *emu_buf,

231 int mbs_per_slice, int blocks_per_mb, int is_chroma)

232 {

233 const uint16_t *esrc;

234 const int mb_width = 4 * blocks_per_mb;

235 int elinesize;

236 int i, j, k;

237

238 for (i = 0; i < mbs_per_slice; i++, src += mb_width) {

239 if (x >= w) {

240 memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb

241 * sizeof(*blocks));

242 return;

243 }

244 if (x + mb_width <= w && y + 16 <= h) {

245 esrc = src;

246 elinesize = linesize;

247 } else {

248 int bw, bh, pix;

249

250 esrc = emu_buf;

251 elinesize = 16 * sizeof(*emu_buf);

252

253 bw = FFMIN(w - x, mb_width);

254 bh = FFMIN(h - y, 16);

255

256 for (j = 0; j < bh; j++) {

257 memcpy(emu_buf + j * 16,

258 (const uint8_t*)src + j * linesize,

259 bw * sizeof(*src));

260 pix = emu_buf[j * 16 + bw - 1];

261 for (k = bw; k < mb_width; k++)

262 emu_buf[j * 16 + k] = pix;

263 }

264 for (; j < 16; j++)

265 memcpy(emu_buf + j * 16,

266 emu_buf + (bh - 1) * 16,

267 mb_width * sizeof(*emu_buf));

268 }

269 if (!is_chroma) {

270 ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);

271 blocks += 64;

272 if (blocks_per_mb > 2) {

273 ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);

274 blocks += 64;

275 }

276 ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);

277 blocks += 64;

278 if (blocks_per_mb > 2) {

279 ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);

280 blocks += 64;

281 }

282 } else {

283 ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);

284 blocks += 64;

285 ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);

286 blocks += 64;

287 if (blocks_per_mb > 2) {

288 ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);

289 blocks += 64;

290 ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);

291 blocks += 64;

292 }

293 }

294

295 x += mb_width;

296 }

297 }

298

299 static void get_alpha_data(ProresContext *ctx, const uint16_t *src,

300 int linesize, int x, int y, int w, int h,

301 int16_t *blocks, int mbs_per_slice, int abits)

302 {

303 const int slice_width = 16 * mbs_per_slice;

304 int i, j, copy_w, copy_h;

305

306 copy_w = FFMIN(w - x, slice_width);

307 copy_h = FFMIN(h - y, 16);

308 for (i = 0; i < copy_h; i++) {

309 memcpy(blocks, src, copy_w * sizeof(*src));

310 if (abits == 8)

311 for (j = 0; j < copy_w; j++)

312 blocks[j] >>= 2;

313 else

314 for (j = 0; j < copy_w; j++)

315 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);

316 for (j = copy_w; j < slice_width; j++)

317 blocks[j] = blocks[copy_w - 1];

318 blocks += slice_width;

319 src += linesize >> 1;

320 }

321 for (; i < 16; i++) {

322 memcpy(blocks, blocks - slice_width, slice_width * sizeof(*blocks));

323 blocks += slice_width;

324 }

325 }

326

327 /**

328 * Write an unsigned rice/exp golomb codeword.

329 */

330 static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)

331 {

332 unsigned int rice_order, exp_order, switch_bits, switch_val;

333 int exponent;

334

335 /* number of prefix bits to switch between Rice and expGolomb */

336 switch_bits = (codebook & 3) + 1;

337 rice_order = codebook >> 5; /* rice code order */

338 exp_order = (codebook >> 2) & 7; /* exp golomb code order */

339

340 switch_val = switch_bits << rice_order;

341

342 if (val >= switch_val) {

343 val -= switch_val - (1 << exp_order);

344 exponent = av_log2(val);

345

346 put_bits(pb, exponent - exp_order + switch_bits, 0);

347 put_bits(pb, exponent + 1, val);

348 } else {

349 exponent = val >> rice_order;

350

351 if (exponent)

352 put_bits(pb, exponent, 0);

353 put_bits(pb, 1, 1);

354 if (rice_order)

355 put_sbits(pb, rice_order, val);

356 }

357 }

358

359 #define GET_SIGN(x) ((x) >> 31)

360 #define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))

361

362 static void encode_dcs(PutBitContext *pb, int16_t *blocks,

363 int blocks_per_slice, int scale)

364 {

365 int i;

366 int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;

367

368 prev_dc = (blocks[0] - 0x4000) / scale;

369 encode_vlc_codeword(pb, FIRST_DC_CB, MAKE_CODE(prev_dc));

370 sign = 0;

371 codebook = 3;

372 blocks += 64;

373

374 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {

375 dc = (blocks[0] - 0x4000) / scale;

376 delta = dc - prev_dc;

377 new_sign = GET_SIGN(delta);

378 delta = (delta ^ sign) - sign;

379 code = MAKE_CODE(delta);

380 encode_vlc_codeword(pb, ff_prores_dc_codebook[codebook], code);

381 codebook = (code + (code & 1)) >> 1;

382 codebook = FFMIN(codebook, 3);

383 sign = new_sign;

384 prev_dc = dc;

385 }

386 }

387

388 static void encode_acs(PutBitContext *pb, int16_t *blocks,

389 int blocks_per_slice,

390 int plane_size_factor,

391 const uint8_t *scan, const int16_t *qmat)

392 {

393 int idx, i;

394 int run, level, run_cb, lev_cb;

395 int max_coeffs, abs_level;

396

397 max_coeffs = blocks_per_slice << 6;

398 run_cb = ff_prores_run_to_cb_index[4];

399 lev_cb = ff_prores_lev_to_cb_index[2];

400 run = 0;

401

402 for (i = 1; i < 64; i++) {

403 for (idx = scan[i]; idx < max_coeffs; idx += 64) {

404 level = blocks[idx] / qmat[scan[i]];

405 if (level) {

406 abs_level = FFABS(level);

407 encode_vlc_codeword(pb, ff_prores_ac_codebook[run_cb], run);

408 encode_vlc_codeword(pb, ff_prores_ac_codebook[lev_cb],

409 abs_level - 1);

410 put_sbits(pb, 1, GET_SIGN(level));

411

412 run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];

413 lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];

414 run = 0;

415 } else {

416 run++;

417 }

418 }

419 }

420 }

421

422 static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb,

423 const uint16_t *src, int linesize,

424 int mbs_per_slice, int16_t *blocks,

425 int blocks_per_mb, int plane_size_factor,

426 const int16_t *qmat)

427 {

428 int blocks_per_slice, saved_pos;

429

430 saved_pos = put_bits_count(pb);

431 blocks_per_slice = mbs_per_slice * blocks_per_mb;

432

433 encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);

434 encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,

435 ctx->scantable, qmat);

436 flush_put_bits(pb);

437

438 return (put_bits_count(pb) - saved_pos) >> 3;

439 }

440

441 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)

442 {

443 const int mask = (1 << abits) - 1;

444 const int dbits = (abits == 8) ? 4 : 7;

445 const int dsize = 1 << dbits - 1;

446 int diff = cur - prev;

447

448 diff &= mask;

449 if (diff >= (1 << abits) - dsize)

450 diff -= 1 << abits;

451 if (diff < -dsize || diff > dsize || !diff) {

452 put_bits(pb, 1, 1);

453 put_bits(pb, abits, diff);

454 } else {

455 put_bits(pb, 1, 0);

456 put_bits(pb, dbits - 1, FFABS(diff) - 1);

457 put_bits(pb, 1, diff < 0);

458 }

459 }

460

461 static void put_alpha_run(PutBitContext *pb, int run)

462 {

463 if (run) {

464 put_bits(pb, 1, 0);

465 if (run < 0x10)

466 put_bits(pb, 4, run);

467 else

468 put_bits(pb, 15, run);

469 } else {

470 put_bits(pb, 1, 1);

471 }

472 }

473

474 // todo alpha quantisation for high quants

475 static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb,

476 int mbs_per_slice, uint16_t *blocks,

477 int quant)

478 {

479 const int abits = ctx->alpha_bits;

480 const int mask = (1 << abits) - 1;

481 const int num_coeffs = mbs_per_slice * 256;

482 int saved_pos = put_bits_count(pb);

483 int prev = mask, cur;

484 int idx = 0;

485 int run = 0;

486

487 cur = blocks[idx++];

488 put_alpha_diff(pb, cur, prev, abits);

489 prev = cur;

490 do {

491 cur = blocks[idx++];

492 if (cur != prev) {

493 put_alpha_run (pb, run);

494 put_alpha_diff(pb, cur, prev, abits);

495 prev = cur;

496 run = 0;

497 } else {

498 run++;

499 }

500 } while (idx < num_coeffs);

501 if (run)

502 put_alpha_run(pb, run);

503 flush_put_bits(pb);

504 return (put_bits_count(pb) - saved_pos) >> 3;

505 }

506

507 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,

508 PutBitContext *pb,

509 int sizes[4], int x, int y, int quant,

510 int mbs_per_slice)

511 {

512 ProresContext *ctx = avctx->priv_data;

513 int i, xp, yp;

514 int total_size = 0;

515 const uint16_t *src;

516 int slice_width_factor = av_log2(mbs_per_slice);

517 int num_cblocks, pwidth, linesize, line_add;

518 int plane_factor, is_chroma;

519 uint16_t *qmat;

520

521 if (ctx->pictures_per_frame == 1)

522 line_add = 0;

523 else

524 line_add = ctx->cur_picture_idx ^ !pic->top_field_first;

525

526 if (ctx->force_quant) {

527 qmat = ctx->quants[0];

528 } else if (quant < MAX_STORED_Q) {

529 qmat = ctx->quants[quant];

530 } else {

531 qmat = ctx->custom_q;

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

533 qmat[i] = ctx->quant_mat[i] * quant;

534 }

535

536 for (i = 0; i < ctx->num_planes; i++) {

537 is_chroma = (i == 1 || i == 2);

538 plane_factor = slice_width_factor + 2;

539 if (is_chroma)

540 plane_factor += ctx->chroma_factor - 3;

541 if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {

542 xp = x << 4;

543 yp = y << 4;

544 num_cblocks = 4;

545 pwidth = avctx->width;

546 } else {

547 xp = x << 3;

548 yp = y << 4;

549 num_cblocks = 2;

550 pwidth = avctx->width >> 1;

551 }

552

553 linesize = pic->linesize[i] * ctx->pictures_per_frame;

554 src = (const uint16_t*)(pic->data[i] + yp * linesize +

555 line_add * pic->linesize[i]) + xp;

556

557 if (i < 3) {

558 get_slice_data(ctx, src, linesize, xp, yp,

559 pwidth, avctx->height / ctx->pictures_per_frame,

560 ctx->blocks[0], ctx->emu_buf,

561 mbs_per_slice, num_cblocks, is_chroma);

562 sizes[i] = encode_slice_plane(ctx, pb, src, linesize,

563 mbs_per_slice, ctx->blocks[0],

564 num_cblocks, plane_factor,

565 qmat);

566 } else {

567 get_alpha_data(ctx, src, linesize, xp, yp,

568 pwidth, avctx->height / ctx->pictures_per_frame,

569 ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);

570 sizes[i] = encode_alpha_plane(ctx, pb, mbs_per_slice,

571 ctx->blocks[0], quant);

572 }

573 total_size += sizes[i];

574 if (put_bits_left(pb) < 0) {

575 av_log(avctx, AV_LOG_ERROR,

576 "Underestimated required buffer size.\n");

577 return AVERROR_BUG;

578 }

579 }

580 return total_size;

581 }

582

583 static inline int estimate_vlc(unsigned codebook, int val)

584 {

585 unsigned int rice_order, exp_order, switch_bits, switch_val;

586 int exponent;

587

588 /* number of prefix bits to switch between Rice and expGolomb */

589 switch_bits = (codebook & 3) + 1;

590 rice_order = codebook >> 5; /* rice code order */

591 exp_order = (codebook >> 2) & 7; /* exp golomb code order */

592

593 switch_val = switch_bits << rice_order;

594

595 if (val >= switch_val) {

596 val -= switch_val - (1 << exp_order);

597 exponent = av_log2(val);

598

599 return exponent * 2 - exp_order + switch_bits + 1;

600 } else {

601 return (val >> rice_order) + rice_order + 1;

602 }

603 }

604

605 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,

606 int scale)

607 {

608 int i;

609 int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;

610 int bits;

611

612 prev_dc = (blocks[0] - 0x4000) / scale;

613 bits = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));

614 sign = 0;

615 codebook = 3;

616 blocks += 64;

617 *error += FFABS(blocks[0] - 0x4000) % scale;

618

619 for (i = 1; i < blocks_per_slice; i++, blocks += 64) {

620 dc = (blocks[0] - 0x4000) / scale;

621 *error += FFABS(blocks[0] - 0x4000) % scale;

622 delta = dc - prev_dc;

623 new_sign = GET_SIGN(delta);

624 delta = (delta ^ sign) - sign;

625 code = MAKE_CODE(delta);

626 bits += estimate_vlc(ff_prores_dc_codebook[codebook], code);

627 codebook = (code + (code & 1)) >> 1;

628 codebook = FFMIN(codebook, 3);

629 sign = new_sign;

630 prev_dc = dc;

631 }

632

633 return bits;

634 }

635

636 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,

637 int plane_size_factor,

638 const uint8_t *scan, const int16_t *qmat)

639 {

640 int idx, i;

641 int run, level, run_cb, lev_cb;

642 int max_coeffs, abs_level;

643 int bits = 0;

644

645 max_coeffs = blocks_per_slice << 6;

646 run_cb = ff_prores_run_to_cb_index[4];

647 lev_cb = ff_prores_lev_to_cb_index[2];

648 run = 0;

649

650 for (i = 1; i < 64; i++) {

651 for (idx = scan[i]; idx < max_coeffs; idx += 64) {

652 level = blocks[idx] / qmat[scan[i]];

653 *error += FFABS(blocks[idx]) % qmat[scan[i]];

654 if (level) {

655 abs_level = FFABS(level);

656 bits += estimate_vlc(ff_prores_ac_codebook[run_cb], run);

657 bits += estimate_vlc(ff_prores_ac_codebook[lev_cb],

658 abs_level - 1) + 1;

659

660 run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];

661 lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];

662 run = 0;

663 } else {

664 run++;

665 }

666 }

667 }

668

669 return bits;

670 }

671

672 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,

673 const uint16_t *src, int linesize,

674 int mbs_per_slice,

675 int blocks_per_mb, int plane_size_factor,

676 const int16_t *qmat, ProresThreadData *td)

677 {

678 int blocks_per_slice;

679 int bits;

680

681 blocks_per_slice = mbs_per_slice * blocks_per_mb;

682

683 bits = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);

684 bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,

685 plane_size_factor, ctx->scantable, qmat);

686

687 return FFALIGN(bits, 8);

688 }

689

690 static int est_alpha_diff(int cur, int prev, int abits)

691 {

692 const int mask = (1 << abits) - 1;

693 const int dbits = (abits == 8) ? 4 : 7;

694 const int dsize = 1 << dbits - 1;

695 int diff = cur - prev;

696

697 diff &= mask;

698 if (diff >= (1 << abits) - dsize)

699 diff -= 1 << abits;

700 if (diff < -dsize || diff > dsize || !diff)

701 return abits + 1;

702 else

703 return dbits + 1;

704 }

705

706 static int estimate_alpha_plane(ProresContext *ctx, int *error,

707 const uint16_t *src, int linesize,

708 int mbs_per_slice, int quant,

709 int16_t *blocks)

710 {

711 const int abits = ctx->alpha_bits;

712 const int mask = (1 << abits) - 1;

713 const int num_coeffs = mbs_per_slice * 256;

714 int prev = mask, cur;

715 int idx = 0;

716 int run = 0;

717 int bits;

718

719 *error = 0;

720 cur = blocks[idx++];

721 bits = est_alpha_diff(cur, prev, abits);

722 prev = cur;

723 do {

724 cur = blocks[idx++];

725 if (cur != prev) {

726 if (!run)

727 bits++;

728 else if (run < 0x10)

729 bits += 4;

730 else

731 bits += 15;

732 bits += est_alpha_diff(cur, prev, abits);

733 prev = cur;

734 run = 0;

735 } else {

736 run++;

737 }

738 } while (idx < num_coeffs);

739

740 if (run) {

741 if (run < 0x10)

742 bits += 4;

743 else

744 bits += 15;

745 }

746

747 return bits;

748 }

749

750 static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic,

751 int trellis_node, int x, int y, int mbs_per_slice,

752 ProresThreadData *td)

753 {

754 ProresContext *ctx = avctx->priv_data;

755 int i, q, pq, xp, yp;

756 const uint16_t *src;

757 int slice_width_factor = av_log2(mbs_per_slice);

758 int num_cblocks[MAX_PLANES], pwidth;

759 int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];

760 const int min_quant = ctx->profile_info->min_quant;

761 const int max_quant = ctx->profile_info->max_quant;

762 int error, bits, bits_limit;

763 int mbs, prev, cur, new_score;

764 int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];

765 int overquant;

766 uint16_t *qmat;

767 int linesize[4], line_add;

768

769 if (ctx->pictures_per_frame == 1)

770 line_add = 0;

771 else

772 line_add = ctx->cur_picture_idx ^ !pic->top_field_first;

773 mbs = x + mbs_per_slice;

774

775 for (i = 0; i < ctx->num_planes; i++) {

776 is_chroma[i] = (i == 1 || i == 2);

777 plane_factor[i] = slice_width_factor + 2;

778 if (is_chroma[i])

779 plane_factor[i] += ctx->chroma_factor - 3;

780 if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {

781 xp = x << 4;

782 yp = y << 4;

783 num_cblocks[i] = 4;

784 pwidth = avctx->width;

785 } else {

786 xp = x << 3;

787 yp = y << 4;

788 num_cblocks[i] = 2;

789 pwidth = avctx->width >> 1;

790 }

791

792 linesize[i] = pic->linesize[i] * ctx->pictures_per_frame;

793 src = (const uint16_t*)(pic->data[i] + yp * linesize[i] +

794 line_add * pic->linesize[i]) + xp;

795

796 if (i < 3) {

797 get_slice_data(ctx, src, linesize[i], xp, yp,

798 pwidth, avctx->height / ctx->pictures_per_frame,

799 td->blocks[i], td->emu_buf,

800 mbs_per_slice, num_cblocks[i], is_chroma[i]);

801 } else {

802 get_alpha_data(ctx, src, linesize[i], xp, yp,

803 pwidth, avctx->height / ctx->pictures_per_frame,

804 td->blocks[i], mbs_per_slice, ctx->alpha_bits);

805 }

806 }

807

808 for (q = min_quant; q < max_quant + 2; q++) {

809 td->nodes[trellis_node + q].prev_node = -1;

810 td->nodes[trellis_node + q].quant = q;

811 }

812

813 // todo: maybe perform coarser quantising to fit into frame size when needed

814 for (q = min_quant; q <= max_quant; q++) {

815 bits = 0;

816 error = 0;

817 for (i = 0; i < ctx->num_planes - !!ctx->alpha_bits; i++) {

818 bits += estimate_slice_plane(ctx, &error, i,

819 src, linesize[i],

820 mbs_per_slice,

821 num_cblocks[i], plane_factor[i],

822 ctx->quants[q], td);

823 }

824 if (ctx->alpha_bits)

825 bits += estimate_alpha_plane(ctx, &error, src, linesize[3],

826 mbs_per_slice, q, td->blocks[3]);

827 if (bits > 65000 * 8)

828 error = SCORE_LIMIT;

829

830 slice_bits[q] = bits;

831 slice_score[q] = error;

832 }

833 if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {

834 slice_bits[max_quant + 1] = slice_bits[max_quant];

835 slice_score[max_quant + 1] = slice_score[max_quant] + 1;

836 overquant = max_quant;

837 } else {

838 for (q = max_quant + 1; q < 128; q++) {

839 bits = 0;

840 error = 0;

841 if (q < MAX_STORED_Q) {

842 qmat = ctx->quants[q];

843 } else {

844 qmat = td->custom_q;

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

846 qmat[i] = ctx->quant_mat[i] * q;

847 }

848 for (i = 0; i < ctx->num_planes - !!ctx->alpha_bits; i++) {

849 bits += estimate_slice_plane(ctx, &error, i,

850 src, linesize[i],

851 mbs_per_slice,

852 num_cblocks[i], plane_factor[i],

853 qmat, td);

854 }

855 if (ctx->alpha_bits)

856 bits += estimate_alpha_plane(ctx, &error, src, linesize[3],

857 mbs_per_slice, q, td->blocks[3]);

858 if (bits <= ctx->bits_per_mb * mbs_per_slice)

859 break;

860 }

861

862 slice_bits[max_quant + 1] = bits;

863 slice_score[max_quant + 1] = error;

864 overquant = q;

865 }

866 td->nodes[trellis_node + max_quant + 1].quant = overquant;

867

868 bits_limit = mbs * ctx->bits_per_mb;

869 for (pq = min_quant; pq < max_quant + 2; pq++) {

870 prev = trellis_node - TRELLIS_WIDTH + pq;

871

872 for (q = min_quant; q < max_quant + 2; q++) {

873 cur = trellis_node + q;

874

875 bits = td->nodes[prev].bits + slice_bits[q];

876 error = slice_score[q];

877 if (bits > bits_limit)

878 error = SCORE_LIMIT;

879

880 if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)

881 new_score = td->nodes[prev].score + error;

882 else

883 new_score = SCORE_LIMIT;

884 if (td->nodes[cur].prev_node == -1 ||

885 td->nodes[cur].score >= new_score) {

886

887 td->nodes[cur].bits = bits;

888 td->nodes[cur].score = new_score;

889 td->nodes[cur].prev_node = prev;

890 }

891 }

892 }

893

894 error = td->nodes[trellis_node + min_quant].score;

895 pq = trellis_node + min_quant;

896 for (q = min_quant + 1; q < max_quant + 2; q++) {

897 if (td->nodes[trellis_node + q].score <= error) {

898 error = td->nodes[trellis_node + q].score;

899 pq = trellis_node + q;

900 }

901 }

902

903 return pq;

904 }

905

906 static int find_quant_thread(AVCodecContext *avctx, void *arg,

907 int jobnr, int threadnr)

908 {

909 ProresContext *ctx = avctx->priv_data;

910 ProresThreadData *td = ctx->tdata + threadnr;

911 int mbs_per_slice = ctx->mbs_per_slice;

912 int x, y = jobnr, mb, q = 0;

913

914 for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {

915 while (ctx->mb_width - x < mbs_per_slice)

916 mbs_per_slice >>= 1;

917 q = find_slice_quant(avctx, arg,

918 (mb + 1) * TRELLIS_WIDTH, x, y,

919 mbs_per_slice, td);

920 }

921

922 for (x = ctx->slices_width - 1; x >= 0; x--) {

923 ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;

924 q = td->nodes[q].prev_node;

925 }

926

927 return 0;

928 }

929

930 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

931 const AVFrame *pic, int *got_packet)

932 {

933 ProresContext *ctx = avctx->priv_data;

934 uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;

935 uint8_t *picture_size_pos;

936 PutBitContext pb;

937 int x, y, i, mb, q = 0;

938 int sizes[4] = { 0 };

939 int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);

940 int frame_size, picture_size, slice_size;

941 int pkt_size, ret;

942 int max_slice_size = (ctx->frame_size_upper_bound - 200) / (ctx->pictures_per_frame * ctx->slices_per_picture + 1);

943 uint8_t frame_flags;

944

945 pkt_size = ctx->frame_size_upper_bound;

946

947 if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size + FF_MIN_BUFFER_SIZE)) < 0)

948 return ret;

949

950 orig_buf = pkt->data;

951

952 // frame atom

953 orig_buf += 4; // frame size

954 bytestream_put_be32 (&orig_buf, FRAME_ID); // frame container ID

955 buf = orig_buf;

956

957 // frame header

958 tmp = buf;

959 buf += 2; // frame header size will be stored here

960 bytestream_put_be16 (&buf, 0); // version 1

961 bytestream_put_buffer(&buf, ctx->vendor, 4);

962 bytestream_put_be16 (&buf, avctx->width);

963 bytestream_put_be16 (&buf, avctx->height);

964

965 frame_flags = ctx->chroma_factor << 6;

966 if (avctx->flags & CODEC_FLAG_INTERLACED_DCT)

967 frame_flags |= pic->top_field_first ? 0x04 : 0x08;

968 bytestream_put_byte (&buf, frame_flags);

969

970 bytestream_put_byte (&buf, 0); // reserved

971 bytestream_put_byte (&buf, avctx->color_primaries);

972 bytestream_put_byte (&buf, avctx->color_trc);

973 bytestream_put_byte (&buf, avctx->colorspace);

974 bytestream_put_byte (&buf, 0x40 | (ctx->alpha_bits >> 3));

975 bytestream_put_byte (&buf, 0); // reserved

976 if (ctx->quant_sel != QUANT_MAT_DEFAULT) {

977 bytestream_put_byte (&buf, 0x03); // matrix flags - both matrices are present

978 // luma quantisation matrix

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

980 bytestream_put_byte(&buf, ctx->quant_mat[i]);

981 // chroma quantisation matrix

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

983 bytestream_put_byte(&buf, ctx->quant_mat[i]);

984 } else {

985 bytestream_put_byte (&buf, 0x00); // matrix flags - default matrices are used

986 }

987 bytestream_put_be16 (&tmp, buf - orig_buf); // write back frame header size

988

989 for (ctx->cur_picture_idx = 0;

990 ctx->cur_picture_idx < ctx->pictures_per_frame;

991 ctx->cur_picture_idx++) {

992 // picture header

993 picture_size_pos = buf + 1;

994 bytestream_put_byte (&buf, 0x40); // picture header size (in bits)

995 buf += 4; // picture data size will be stored here

996 bytestream_put_be16 (&buf, ctx->slices_per_picture);

997 bytestream_put_byte (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs

998

999 // seek table - will be filled during slice encoding

1000 slice_sizes = buf;

1001 buf += ctx->slices_per_picture * 2;

1002

1003 // slices

1004 if (!ctx->force_quant) {

1005 ret = avctx->execute2(avctx, find_quant_thread, (void*)pic, NULL,

1006 ctx->mb_height);

1007 if (ret)

1008 return ret;

1009 }

1010

1011 for (y = 0; y < ctx->mb_height; y++) {

1012 int mbs_per_slice = ctx->mbs_per_slice;

1013 for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {

1014 q = ctx->force_quant ? ctx->force_quant

1015 : ctx->slice_q[mb + y * ctx->slices_width];

1016

1017 while (ctx->mb_width - x < mbs_per_slice)

1018 mbs_per_slice >>= 1;

1019

1020 bytestream_put_byte(&buf, slice_hdr_size << 3);

1021 slice_hdr = buf;

1022 buf += slice_hdr_size - 1;

1023 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {

1024 uint8_t *start = pkt->data;

1025 // Recompute new size according to max_slice_size

1026 // and deduce delta

1027 int delta = 200 + (ctx->pictures_per_frame *

1028 ctx->slices_per_picture + 1) *

1029 max_slice_size - pkt_size;

1030

1031 delta = FFMAX(delta, 2 * max_slice_size);

1032 ctx->frame_size_upper_bound += delta;

1033

1034 if (!ctx->warn) {

1035 avpriv_request_sample(avctx,

1036 "Packet too small: is %i,"

1037 " needs %i (slice: %i). "

1038 "Correct allocation",

1039 pkt_size, delta, max_slice_size);

1040 ctx->warn = 1;

1041 }

1042

1043 ret = av_grow_packet(pkt, delta);

1044 if (ret < 0)

1045 return ret;

1046

1047 pkt_size += delta;

1048 // restore pointers

1049 orig_buf = pkt->data + (orig_buf - start);

1050 buf = pkt->data + (buf - start);

1051 picture_size_pos = pkt->data + (picture_size_pos - start);

1052 slice_sizes = pkt->data + (slice_sizes - start);

1053 slice_hdr = pkt->data + (slice_hdr - start);

1054 tmp = pkt->data + (tmp - start);

1055 }

1056 init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)));

1057 ret = encode_slice(avctx, pic, &pb, sizes, x, y, q,

1058 mbs_per_slice);

1059 if (ret < 0)

1060 return ret;

1061

1062 bytestream_put_byte(&slice_hdr, q);

1063 slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];

1064 for (i = 0; i < ctx->num_planes - 1; i++) {

1065 bytestream_put_be16(&slice_hdr, sizes[i]);

1066 slice_size += sizes[i];

1067 }

1068 bytestream_put_be16(&slice_sizes, slice_size);

1069 buf += slice_size - slice_hdr_size;

1070 if (max_slice_size < slice_size)

1071 max_slice_size = slice_size;

1072 }

1073 }

1074

1075 picture_size = buf - (picture_size_pos - 1);

1076 bytestream_put_be32(&picture_size_pos, picture_size);

1077 }

1078

1079 orig_buf -= 8;

1080 frame_size = buf - orig_buf;

1081 bytestream_put_be32(&orig_buf, frame_size);

1082

1083 pkt->size = frame_size;

1084 pkt->flags |= AV_PKT_FLAG_KEY;

1085 *got_packet = 1;

1086

1087 return 0;

1088 }

1089

1090 static av_cold int encode_close(AVCodecContext *avctx)

1091 {

1092 ProresContext *ctx = avctx->priv_data;

1093 int i;

1094

1095 av_frame_free(&avctx->coded_frame);

1096

1097 if (ctx->tdata) {

1098 for (i = 0; i < avctx->thread_count; i++)

1099 av_freep(&ctx->tdata[i].nodes);

1100 }

1101 av_freep(&ctx->tdata);

1102 av_freep(&ctx->slice_q);

1103

1104 return 0;

1105 }

1106

1107 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,

1108 int linesize, int16_t *block)

1109 {

1110 int x, y;

1111 const uint16_t *tsrc = src;

1112

1113 for (y = 0; y < 8; y++) {

1114 for (x = 0; x < 8; x++)

1115 block[y * 8 + x] = tsrc[x];

1116 tsrc += linesize >> 1;

1117 }

1118 fdsp->fdct(block);

1119 }

1120

1121 static av_cold int encode_init(AVCodecContext *avctx)

1122 {

1123 ProresContext *ctx = avctx->priv_data;

1124 int mps;

1125 int i, j;

1126 int min_quant, max_quant;

1127 int interlaced = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);

1128

1129 avctx->bits_per_raw_sample = 10;

1130 avctx->coded_frame = av_frame_alloc();

1131 if (!avctx->coded_frame)

1132 return AVERROR(ENOMEM);

1133 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

1134 avctx->coded_frame->key_frame = 1;

1135

1136 ctx->fdct = prores_fdct;

1137 ctx->scantable = interlaced ? ff_prores_interlaced_scan

1138 : ff_prores_progressive_scan;

1139 ff_fdctdsp_init(&ctx->fdsp, avctx);

1140

1141 mps = ctx->mbs_per_slice;

1142 if (mps & (mps - 1)) {

1143 av_log(avctx, AV_LOG_ERROR,

1144 "there should be an integer power of two MBs per slice\n");

1145 return AVERROR(EINVAL);

1146 }

1147 if (ctx->profile == PRORES_PROFILE_AUTO) {

1148 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);

1149 ctx->profile = (desc->flags & AV_PIX_FMT_FLAG_ALPHA ||

1150 !(desc->log2_chroma_w + desc->log2_chroma_h))

1151 ? PRORES_PROFILE_4444 : PRORES_PROFILE_HQ;

1152 av_log(avctx, AV_LOG_INFO, "Autoselected %s. It can be overridden "

1153 "through -profile option.\n", ctx->profile == PRORES_PROFILE_4444

1154 ? "4:4:4:4 profile because of the used input colorspace"

1155 : "HQ profile to keep best quality");

1156 }

1157 if (av_pix_fmt_desc_get(avctx->pix_fmt)->flags & AV_PIX_FMT_FLAG_ALPHA) {

1158 if (ctx->profile != PRORES_PROFILE_4444) {

1159 // force alpha and warn

1160 av_log(avctx, AV_LOG_WARNING, "Profile selected will not "

1161 "encode alpha. Override with -profile if needed.\n");

1162 ctx->alpha_bits = 0;

1163 }

1164 if (ctx->alpha_bits & 7) {

1165 av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");

1166 return AVERROR(EINVAL);

1167 }

1168 } else {

1169 ctx->alpha_bits = 0;

1170 }

1171

1172 ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10

1173 ? CFACTOR_Y422

1174 : CFACTOR_Y444;

1175 ctx->profile_info = prores_profile_info + ctx->profile;

1176 ctx->num_planes = 3 + !!ctx->alpha_bits;

1177

1178 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;

1179

1180 if (interlaced)

1181 ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;

1182 else

1183 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;

1184

1185 ctx->slices_width = ctx->mb_width / mps;

1186 ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);

1187 ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;

1188 ctx->pictures_per_frame = 1 + interlaced;

1189

1190 if (ctx->quant_sel == -1)

1191 ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];

1192 else

1193 ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];

1194

1195 if (strlen(ctx->vendor) != 4) {

1196 av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");

1197 return AVERROR_INVALIDDATA;

1198 }

1199

1200 ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;

1201 if (!ctx->force_quant) {

1202 if (!ctx->bits_per_mb) {

1203 for (i = 0; i < NUM_MB_LIMITS - 1; i++)

1204 if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *

1205 ctx->pictures_per_frame)

1206 break;

1207 ctx->bits_per_mb = ctx->profile_info->br_tab[i];

1208 } else if (ctx->bits_per_mb < 128) {

1209 av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");

1210 return AVERROR_INVALIDDATA;

1211 }

1212

1213 min_quant = ctx->profile_info->min_quant;

1214 max_quant = ctx->profile_info->max_quant;

1215 for (i = min_quant; i < MAX_STORED_Q; i++) {

1216 for (j = 0; j < 64; j++)

1217 ctx->quants[i][j] = ctx->quant_mat[j] * i;

1218 }

1219

1220 ctx->slice_q = av_malloc(ctx->slices_per_picture * sizeof(*ctx->slice_q));

1221 if (!ctx->slice_q) {

1222 encode_close(avctx);

1223 return AVERROR(ENOMEM);

1224 }

1225

1226 ctx->tdata = av_mallocz(avctx->thread_count * sizeof(*ctx->tdata));

1227 if (!ctx->tdata) {

1228 encode_close(avctx);

1229 return AVERROR(ENOMEM);

1230 }

1231

1232 for (j = 0; j < avctx->thread_count; j++) {

1233 ctx->tdata[j].nodes = av_malloc((ctx->slices_width + 1)

1234 * TRELLIS_WIDTH

1235 * sizeof(*ctx->tdata->nodes));

1236 if (!ctx->tdata[j].nodes) {

1237 encode_close(avctx);

1238 return AVERROR(ENOMEM);

1239 }

1240 for (i = min_quant; i < max_quant + 2; i++) {

1241 ctx->tdata[j].nodes[i].prev_node = -1;

1242 ctx->tdata[j].nodes[i].bits = 0;

1243 ctx->tdata[j].nodes[i].score = 0;

1244 }

1245 }

1246 } else {

1247 int ls = 0;

1248

1249 if (ctx->force_quant > 64) {

1250 av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");

1251 return AVERROR_INVALIDDATA;

1252 }

1253

1254 for (j = 0; j < 64; j++) {

1255 ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;

1256 ls += av_log2((1 << 11) / ctx->quants[0][j]) * 2 + 1;

1257 }

1258

1259 ctx->bits_per_mb = ls * 8;

1260 if (ctx->chroma_factor == CFACTOR_Y444)

1261 ctx->bits_per_mb += ls * 4;

1262 }

1263

1264 ctx->frame_size_upper_bound = (ctx->pictures_per_frame *

1265 ctx->slices_per_picture + 1) *

1266 (2 + 2 * ctx->num_planes +

1267 (mps * ctx->bits_per_mb) / 8)

1268 + 200;

1269

1270 if (ctx->alpha_bits) {

1271 // The alpha plane is run-coded and might exceed the bit budget.

1272 ctx->frame_size_upper_bound += (ctx->pictures_per_frame *

1273 ctx->slices_per_picture + 1) *

1274 /* num pixels per slice */ (ctx->mbs_per_slice * 256 *

1275 /* bits per pixel */ (1 + ctx->alpha_bits + 1) + 7 >> 3);

1276 }

1277

1278 avctx->codec_tag = ctx->profile_info->tag;

1279

1280 av_log(avctx, AV_LOG_DEBUG,

1281 "profile %d, %d slices, interlacing: %s, %d bits per MB\n",

1282 ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,

1283 interlaced ? "yes" : "no", ctx->bits_per_mb);

1284 av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",

1285 ctx->frame_size_upper_bound);

1286

1287 return 0;

1288 }

1289

1290 #define OFFSET(x) offsetof(ProresContext, x)

1291 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

1292

1293 static const AVOption options[] = {

1294 { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),

1295 AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },

1296 { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT,

1297 { .i64 = PRORES_PROFILE_AUTO },

1298 PRORES_PROFILE_AUTO, PRORES_PROFILE_4444, VE, "profile" },

1299 { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_AUTO },

1300 0, 0, VE, "profile" },

1301 { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },

1302 0, 0, VE, "profile" },

1303 { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },

1304 0, 0, VE, "profile" },

1305 { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },

1306 0, 0, VE, "profile" },

1307 { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },

1308 0, 0, VE, "profile" },

1309 { "4444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },

1310 0, 0, VE, "profile" },

1311 { "vendor", "vendor ID", OFFSET(vendor),

1312 AV_OPT_TYPE_STRING, { .str = "Lavc" }, CHAR_MIN, CHAR_MAX, VE },

1313 { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),

1314 AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },

1315 { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,

1316 { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, "quant_mat" },

1317 { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },

1318 0, 0, VE, "quant_mat" },

1319 { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },

1320 0, 0, VE, "quant_mat" },

1321 { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },

1322 0, 0, VE, "quant_mat" },

1323 { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },

1324 0, 0, VE, "quant_mat" },

1325 { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },

1326 0, 0, VE, "quant_mat" },

1327 { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },

1328 0, 0, VE, "quant_mat" },

1329 { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,

1330 { .i64 = 16 }, 0, 16, VE },

1331 { NULL }

1332 };

1333

1334 static const AVClass proresenc_class = {

1335 .class_name = "ProRes encoder",

1336 .item_name = av_default_item_name,

1337 .option = options,

1338 .version = LIBAVUTIL_VERSION_INT,

1339 };

1340

1341 AVCodec ff_prores_ks_encoder = {

1342 .name = "prores_ks",

1343 .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),

1344 .type = AVMEDIA_TYPE_VIDEO,

1345 .id = AV_CODEC_ID_PRORES,

1346 .priv_data_size = sizeof(ProresContext),

1347 .init = encode_init,

1348 .close = encode_close,

1349 .encode2 = encode_frame,

1350 .capabilities = CODEC_CAP_SLICE_THREADS,

1351 .pix_fmts = (const enum AVPixelFormat[]) {

1352 AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,

1353 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE

1354 },

1355 .priv_class = &proresenc_class,

1356 };

Generated on Sun Mar 8 2015 02:34:58 for FFmpeg by doxygen 1.8.2