FFmpeg: libavcodec/ratecontrol.c Source File

FFmpeg

[フレーム]

libavcodec

ratecontrol.c

Go to the documentation of this file.

1 /*

2 * Rate control for video encoders

3 *

5 *

6 * This file is part of FFmpeg.

7 *

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

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

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

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

12 *

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

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

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

16 * Lesser General Public License for more details.

17 *

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

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

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

21 */

23 /**

24 * @file

25 * Rate control for video encoders.

26 */

28 #include "libavutil/attributes.h"

29 #include "libavutil/emms.h"

30 #include "libavutil/internal.h"

31 #include "libavutil/mem.h"

33 #include "avcodec.h"

34 #include "ratecontrol.h"

35 #include "mpegvideoenc.h"

36 #include "libavutil/eval.h"

38 void ff_write_pass1_stats(MpegEncContext *s)

39 {

40 snprintf(s->avctx->stats_out, 256,

41 "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "

42 "fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d hbits:%d;\n",

43 s->cur_pic.ptr->display_picture_number,

44 s->cur_pic.ptr->coded_picture_number,

45 s->pict_type,

46 s->cur_pic.ptr->f->quality,

47 s->i_tex_bits,

48 s->p_tex_bits,

49 s->mv_bits,

50 s->misc_bits,

51 s->f_code,

52 s->b_code,

53 s->mc_mb_var_sum,

54 s->mb_var_sum,

55 s->i_count,

56 s->header_bits);

57 }

59 static AVRational get_fpsQ(AVCodecContext *avctx)

60 {

61 if (avctx->framerate.num > 0 && avctx->framerate.den > 0)

62 return avctx->framerate;

64 FF_DISABLE_DEPRECATION_WARNINGS

65 #if FF_API_TICKS_PER_FRAME

66 return av_div_q((AVRational){1, FFMAX(avctx->ticks_per_frame, 1)}, avctx->time_base);

67 #else

68 return av_inv_q(avctx->time_base);

69 #endif

70 FF_ENABLE_DEPRECATION_WARNINGS

71 }

73 static double get_fps(AVCodecContext *avctx)

74 {

75 return av_q2d(get_fpsQ(avctx));

76 }

78 static inline double qp2bits(const RateControlEntry *rce, double qp)

79 {

80 if (qp <= 0.0) {

81 av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");

82 }

83 return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / qp;

84 }

86 static double qp2bits_cb(void *rce, double qp)

87 {

88 return qp2bits(rce, qp);

89 }

91 static inline double bits2qp(const RateControlEntry *rce, double bits)

92 {

93 if (bits < 0.9) {

94 av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");

95 }

96 return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;

97 }

99 static double bits2qp_cb(void *rce, double qp)

100 {

101 return bits2qp(rce, qp);

102 }

103

104 static double get_diff_limited_q(MpegEncContext *s, const RateControlEntry *rce, double q)

105 {

106 RateControlContext *rcc = &s->rc_context;

107 AVCodecContext *a = s->avctx;

108 const int pict_type = rce->new_pict_type;

109 const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P];

110 const double last_non_b_q = rcc->last_qscale_for[rcc->last_non_b_pict_type];

111

112 if (pict_type == AV_PICTURE_TYPE_I &&

113 (a->i_quant_factor > 0.0 || rcc->last_non_b_pict_type == AV_PICTURE_TYPE_P))

114 q = last_p_q * FFABS(a->i_quant_factor) + a->i_quant_offset;

115 else if (pict_type == AV_PICTURE_TYPE_B &&

116 a->b_quant_factor > 0.0)

117 q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;

118 if (q < 1)

119 q = 1;

120

121 /* last qscale / qdiff stuff */

122 if (rcc->last_non_b_pict_type == pict_type || pict_type != AV_PICTURE_TYPE_I) {

123 double last_q = rcc->last_qscale_for[pict_type];

124 const int maxdiff = FF_QP2LAMBDA * a->max_qdiff;

125

126 if (q > last_q + maxdiff)

127 q = last_q + maxdiff;

128 else if (q < last_q - maxdiff)

129 q = last_q - maxdiff;

130 }

131

132 rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring

133

134 if (pict_type != AV_PICTURE_TYPE_B)

135 rcc->last_non_b_pict_type = pict_type;

136

137 return q;

138 }

139

140 /**

141 * Get the qmin & qmax for pict_type.

142 */

143 static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)

144 {

145 int qmin = s->lmin;

146 int qmax = s->lmax;

147

148 av_assert0(qmin <= qmax);

149

150 switch (pict_type) {

151 case AV_PICTURE_TYPE_B:

152 qmin = (int)(qmin * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);

153 qmax = (int)(qmax * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);

154 break;

155 case AV_PICTURE_TYPE_I:

156 qmin = (int)(qmin * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);

157 qmax = (int)(qmax * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);

158 break;

159 }

160

161 qmin = av_clip(qmin, 1, FF_LAMBDA_MAX);

162 qmax = av_clip(qmax, 1, FF_LAMBDA_MAX);

163

164 if (qmax < qmin)

165 qmax = qmin;

166

167 *qmin_ret = qmin;

168 *qmax_ret = qmax;

169 }

170

171 static double modify_qscale(MpegEncContext *s, const RateControlEntry *rce,

172 double q, int frame_num)

173 {

174 RateControlContext *rcc = &s->rc_context;

175 const double buffer_size = s->avctx->rc_buffer_size;

176 const double fps = get_fps(s->avctx);

177 const double min_rate = s->avctx->rc_min_rate / fps;

178 const double max_rate = s->avctx->rc_max_rate / fps;

179 const int pict_type = rce->new_pict_type;

180 int qmin, qmax;

181

182 get_qminmax(&qmin, &qmax, s, pict_type);

183

184 /* modulation */

185 if (s->rc_qmod_freq &&

186 frame_num % s->rc_qmod_freq == 0 &&

187 pict_type == AV_PICTURE_TYPE_P)

188 q *= s->rc_qmod_amp;

189

190 /* buffer overflow/underflow protection */

191 if (buffer_size) {

192 double expected_size = rcc->buffer_index;

193 double q_limit;

194

195 if (min_rate) {

196 double d = 2 * (buffer_size - expected_size) / buffer_size;

197 if (d > 1.0)

198 d = 1.0;

199 else if (d < 0.0001)

200 d = 0.0001;

201 q *= pow(d, 1.0 / s->rc_buffer_aggressivity);

202

203 q_limit = bits2qp(rce,

204 FFMAX((min_rate - buffer_size + rcc->buffer_index) *

205 s->avctx->rc_min_vbv_overflow_use, 1));

206

207 if (q > q_limit) {

208 if (s->avctx->debug & FF_DEBUG_RC)

209 av_log(s->avctx, AV_LOG_DEBUG,

210 "limiting QP %f -> %f\n", q, q_limit);

211 q = q_limit;

212 }

213 }

214

215 if (max_rate) {

216 double d = 2 * expected_size / buffer_size;

217 if (d > 1.0)

218 d = 1.0;

219 else if (d < 0.0001)

220 d = 0.0001;

221 q /= pow(d, 1.0 / s->rc_buffer_aggressivity);

222

223 q_limit = bits2qp(rce,

224 FFMAX(rcc->buffer_index *

225 s->avctx->rc_max_available_vbv_use,

226 1));

227 if (q < q_limit) {

228 if (s->avctx->debug & FF_DEBUG_RC)

229 av_log(s->avctx, AV_LOG_DEBUG,

230 "limiting QP %f -> %f\n", q, q_limit);

231 q = q_limit;

232 }

233 }

234 }

235 ff_dlog(s, "q:%f max:%f min:%f size:%f index:%f agr:%f\n",

236 q, max_rate, min_rate, buffer_size, rcc->buffer_index,

237 s->rc_buffer_aggressivity);

238 if (s->rc_qsquish == 0.0 || qmin == qmax) {

239 if (q < qmin)

240 q = qmin;

241 else if (q > qmax)

242 q = qmax;

243 } else {

244 double min2 = log(qmin);

245 double max2 = log(qmax);

246

247 q = log(q);

248 q = (q - min2) / (max2 - min2) - 0.5;

249 q *= -4.0;

250 q = 1.0 / (1.0 + exp(q));

251 q = q * (max2 - min2) + min2;

252

253 q = exp(q);

254 }

255

256 return q;

257 }

258

259 /**

260 * Modify the bitrate curve from pass1 for one frame.

261 */

262 static double get_qscale(MpegEncContext *s, RateControlEntry *rce,

263 double rate_factor, int frame_num)

264 {

265 RateControlContext *rcc = &s->rc_context;

266 AVCodecContext *a = s->avctx;

267 const int pict_type = rce->new_pict_type;

268 const double mb_num = s->mb_num;

269 double q, bits;

270 int i;

271

272 double const_values[] = {

273 M_PI,

274 M_E,

275 rce->i_tex_bits * rce->qscale,

276 rce->p_tex_bits * rce->qscale,

277 (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,

278 rce->mv_bits / mb_num,

279 rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,

280 rce->i_count / mb_num,

281 rce->mc_mb_var_sum / mb_num,

282 rce->mb_var_sum / mb_num,

283 rce->pict_type == AV_PICTURE_TYPE_I,

284 rce->pict_type == AV_PICTURE_TYPE_P,

285 rce->pict_type == AV_PICTURE_TYPE_B,

286 rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],

287 a->qcompress,

288 rcc->i_cplx_sum[AV_PICTURE_TYPE_I] / (double)rcc->frame_count[AV_PICTURE_TYPE_I],

289 rcc->i_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],

290 rcc->p_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],

291 rcc->p_cplx_sum[AV_PICTURE_TYPE_B] / (double)rcc->frame_count[AV_PICTURE_TYPE_B],

292 (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],

293 0

294 };

295

296 bits = av_expr_eval(rcc->rc_eq_eval, const_values, rce);

297 if (isnan(bits)) {

298 av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->rc_eq);

299 return -1;

300 }

301

302 rcc->pass1_rc_eq_output_sum += bits;

303 bits *= rate_factor;

304 if (bits < 0.0)

305 bits = 0.0;

306 bits += 1.0; // avoid 1/0 issues

307

308 /* user override */

309 for (i = 0; i < s->avctx->rc_override_count; i++) {

310 RcOverride *rco = s->avctx->rc_override;

311 if (rco[i].start_frame > frame_num)

312 continue;

313 if (rco[i].end_frame < frame_num)

314 continue;

315

316 if (rco[i].qscale)

317 bits = qp2bits(rce, rco[i].qscale); // FIXME move at end to really force it?

318 else

319 bits *= rco[i].quality_factor;

320 }

321

322 q = bits2qp(rce, bits);

323

324 /* I/B difference */

325 if (pict_type == AV_PICTURE_TYPE_I && s->avctx->i_quant_factor < 0.0)

326 q = -q * s->avctx->i_quant_factor + s->avctx->i_quant_offset;

327 else if (pict_type == AV_PICTURE_TYPE_B && s->avctx->b_quant_factor < 0.0)

328 q = -q * s->avctx->b_quant_factor + s->avctx->b_quant_offset;

329 if (q < 1)

330 q = 1;

331

332 return q;

333 }

334

335 static int init_pass2(MpegEncContext *s)

336 {

337 RateControlContext *rcc = &s->rc_context;

338 AVCodecContext *a = s->avctx;

339 int i, toobig;

340 AVRational fps = get_fpsQ(s->avctx);

341 double complexity[5] = { 0 }; // approximate bits at quant=1

342 uint64_t const_bits[5] = { 0 }; // quantizer independent bits

343 uint64_t all_const_bits;

344 uint64_t all_available_bits = av_rescale_q(s->bit_rate,

345 (AVRational){rcc->num_entries,1},

346 fps);

347 double rate_factor = 0;

348 double step;

349 const int filter_size = (int)(a->qblur * 4) | 1;

350 double expected_bits = 0; // init to silence gcc warning

351 double *qscale, *blurred_qscale, qscale_sum;

352

353 /* find complexity & const_bits & decide the pict_types */

354 for (i = 0; i < rcc->num_entries; i++) {

355 RateControlEntry *rce = &rcc->entry[i];

356

357 rce->new_pict_type = rce->pict_type;

358 rcc->i_cplx_sum[rce->pict_type] += rce->i_tex_bits * rce->qscale;

359 rcc->p_cplx_sum[rce->pict_type] += rce->p_tex_bits * rce->qscale;

360 rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;

361 rcc->frame_count[rce->pict_type]++;

362

363 complexity[rce->new_pict_type] += (rce->i_tex_bits + rce->p_tex_bits) *

364 (double)rce->qscale;

365 const_bits[rce->new_pict_type] += rce->mv_bits + rce->misc_bits;

366 }

367

368 all_const_bits = const_bits[AV_PICTURE_TYPE_I] +

369 const_bits[AV_PICTURE_TYPE_P] +

370 const_bits[AV_PICTURE_TYPE_B];

371

372 if (all_available_bits < all_const_bits) {

373 av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");

374 return -1;

375 }

376

377 qscale = av_malloc_array(rcc->num_entries, sizeof(double));

378 blurred_qscale = av_malloc_array(rcc->num_entries, sizeof(double));

379 if (!qscale || !blurred_qscale) {

380 av_free(qscale);

381 av_free(blurred_qscale);

382 return AVERROR(ENOMEM);

383 }

384 toobig = 0;

385

386 for (step = 256 * 256; step > 0.0000001; step *= 0.5) {

387 expected_bits = 0;

388 rate_factor += step;

389

390 rcc->buffer_index = s->avctx->rc_buffer_size / 2;

391

392 /* find qscale */

393 for (i = 0; i < rcc->num_entries; i++) {

394 const RateControlEntry *rce = &rcc->entry[i];

395

396 qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i);

397 rcc->last_qscale_for[rce->pict_type] = qscale[i];

398 }

399 av_assert0(filter_size % 2 == 1);

400

401 /* fixed I/B QP relative to P mode */

402 for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {

403 const RateControlEntry *rce = &rcc->entry[i];

404

405 qscale[i] = get_diff_limited_q(s, rce, qscale[i]);

406 }

407

408 for (i = rcc->num_entries - 1; i >= 0; i--) {

409 const RateControlEntry *rce = &rcc->entry[i];

410

411 qscale[i] = get_diff_limited_q(s, rce, qscale[i]);

412 }

413

414 /* smooth curve */

415 for (i = 0; i < rcc->num_entries; i++) {

416 const RateControlEntry *rce = &rcc->entry[i];

417 const int pict_type = rce->new_pict_type;

418 int j;

419 double q = 0.0, sum = 0.0;

420

421 for (j = 0; j < filter_size; j++) {

422 int index = i + j - filter_size / 2;

423 double d = index - i;

424 double coeff = a->qblur == 0 ? 1.0 : exp(-d * d / (a->qblur * a->qblur));

425

426 if (index < 0 || index >= rcc->num_entries)

427 continue;

428 if (pict_type != rcc->entry[index].new_pict_type)

429 continue;

430 q += qscale[index] * coeff;

431 sum += coeff;

432 }

433 blurred_qscale[i] = q / sum;

434 }

435

436 /* find expected bits */

437 for (i = 0; i < rcc->num_entries; i++) {

438 RateControlEntry *rce = &rcc->entry[i];

439 double bits;

440

441 rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i);

442

443 bits = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;

444 bits += 8 * ff_vbv_update(s, bits);

445

446 rce->expected_bits = expected_bits;

447 expected_bits += bits;

448 }

449

450 ff_dlog(s->avctx,

451 "expected_bits: %f all_available_bits: %d rate_factor: %f\n",

452 expected_bits, (int)all_available_bits, rate_factor);

453 if (expected_bits > all_available_bits) {

454 rate_factor -= step;

455 ++toobig;

456 }

457 }

458 av_free(qscale);

459 av_free(blurred_qscale);

460

461 /* check bitrate calculations and print info */

462 qscale_sum = 0.0;

463 for (i = 0; i < rcc->num_entries; i++) {

464 ff_dlog(s, "[lavc rc] entry[%d].new_qscale = %.3f qp = %.3f\n",

465 i,

466 rcc->entry[i].new_qscale,

467 rcc->entry[i].new_qscale / FF_QP2LAMBDA);

468 qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,

469 s->avctx->qmin, s->avctx->qmax);

470 }

471 av_assert0(toobig <= 40);

472 av_log(s->avctx, AV_LOG_DEBUG,

473 "[lavc rc] requested bitrate: %"PRId64" bps expected bitrate: %"PRId64" bps\n",

474 s->bit_rate,

475 (int64_t)(expected_bits / ((double)all_available_bits / s->bit_rate)));

476 av_log(s->avctx, AV_LOG_DEBUG,

477 "[lavc rc] estimated target average qp: %.3f\n",

478 (float)qscale_sum / rcc->num_entries);

479 if (toobig == 0) {

480 av_log(s->avctx, AV_LOG_INFO,

481 "[lavc rc] Using all of requested bitrate is not "

482 "necessary for this video with these parameters.\n");

483 } else if (toobig == 40) {

484 av_log(s->avctx, AV_LOG_ERROR,

485 "[lavc rc] Error: bitrate too low for this video "

486 "with these parameters.\n");

487 return -1;

488 } else if (fabs(expected_bits / all_available_bits - 1.0) > 0.01) {

489 av_log(s->avctx, AV_LOG_ERROR,

490 "[lavc rc] Error: 2pass curve failed to converge\n");

491 return -1;

492 }

493

494 return 0;

495 }

496

497 av_cold int ff_rate_control_init(MpegEncContext *s)

498 {

499 RateControlContext *rcc = &s->rc_context;

500 int i, res;

501 static const char * const const_names[] = {

502 "PI",

503 "E",

504 "iTex",

505 "pTex",

506 "tex",

507 "mv",

508 "fCode",

509 "iCount",

510 "mcVar",

511 "var",

512 "isI",

513 "isP",

514 "isB",

515 "avgQP",

516 "qComp",

517 "avgIITex",

518 "avgPITex",

519 "avgPPTex",

520 "avgBPTex",

521 "avgTex",

522 NULL

523 };

524 static double (* const func1[])(void *, double) = {

525 bits2qp_cb,

526 qp2bits_cb,

527 NULL

528 };

529 static const char * const func1_names[] = {

530 "bits2qp",

531 "qp2bits",

532 NULL

533 };

534 emms_c();

535

536 if (!s->avctx->rc_max_available_vbv_use && s->avctx->rc_buffer_size) {

537 if (s->avctx->rc_max_rate) {

538 s->avctx->rc_max_available_vbv_use = av_clipf(s->avctx->rc_max_rate/(s->avctx->rc_buffer_size*get_fps(s->avctx)), 1.0/3, 1.0);

539 } else

540 s->avctx->rc_max_available_vbv_use = 1.0;

541 }

542

543 res = av_expr_parse(&rcc->rc_eq_eval,

544 s->rc_eq ? s->rc_eq : "tex^qComp",

545 const_names, func1_names, func1,

546 NULL, NULL, 0, s->avctx);

547 if (res < 0) {

548 av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\"\n", s->rc_eq);

549 return res;

550 }

551

552 for (i = 0; i < 5; i++) {

553 rcc->pred[i].coeff = FF_QP2LAMBDA * 7.0;

554 rcc->pred[i].count = 1.0;

555 rcc->pred[i].decay = 0.4;

556

557 rcc->i_cplx_sum [i] =

558 rcc->p_cplx_sum [i] =

559 rcc->mv_bits_sum[i] =

560 rcc->qscale_sum [i] =

561 rcc->frame_count[i] = 1; // 1 is better because of 1/0 and such

562

563 rcc->last_qscale_for[i] = FF_QP2LAMBDA * 5;

564 }

565 rcc->buffer_index = s->avctx->rc_initial_buffer_occupancy;

566 if (!rcc->buffer_index)

567 rcc->buffer_index = s->avctx->rc_buffer_size * 3 / 4;

568

569 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {

570 int i;

571 char *p;

572

573 /* find number of pics */

574 p = s->avctx->stats_in;

575 for (i = -1; p; i++)

576 p = strchr(p + 1, ';');

577 i += s->max_b_frames;

578 if (i <= 0 || i >= INT_MAX / sizeof(RateControlEntry))

579 return -1;

580 rcc->entry = av_mallocz(i * sizeof(RateControlEntry));

581 if (!rcc->entry)

582 return AVERROR(ENOMEM);

583 rcc->num_entries = i;

584

585 /* init all to skipped P-frames

586 * (with B-frames we might have a not encoded frame at the end FIXME) */

587 for (i = 0; i < rcc->num_entries; i++) {

588 RateControlEntry *rce = &rcc->entry[i];

589

590 rce->pict_type = rce->new_pict_type = AV_PICTURE_TYPE_P;

591 rce->qscale = rce->new_qscale = FF_QP2LAMBDA * 2;

592 rce->misc_bits = s->mb_num + 10;

593 rce->mb_var_sum = s->mb_num * 100;

594 }

595

596 /* read stats */

597 p = s->avctx->stats_in;

598 for (i = 0; i < rcc->num_entries - s->max_b_frames; i++) {

599 RateControlEntry *rce;

600 int picture_number;

601 int e;

602 char *next;

603

604 next = strchr(p, ';');

605 if (next) {

606 (*next) = 0; // sscanf is unbelievably slow on looong strings // FIXME copy / do not write

607 next++;

608 }

609 e = sscanf(p, " in:%d ", &picture_number);

610

611 av_assert0(picture_number >= 0);

612 av_assert0(picture_number < rcc->num_entries);

613 rce = &rcc->entry[picture_number];

614

615 e += sscanf(p, " in:%*d out:%*d type:%d q:%f itex:%d ptex:%d "

616 "mv:%d misc:%d "

617 "fcode:%d bcode:%d "

618 "mc-var:%"SCNd64" var:%"SCNd64" "

619 "icount:%d hbits:%d",

620 &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits,

621 &rce->mv_bits, &rce->misc_bits,

622 &rce->f_code, &rce->b_code,

623 &rce->mc_mb_var_sum, &rce->mb_var_sum,

624 &rce->i_count, &rce->header_bits);

625 if (e != 13) {

626 av_log(s->avctx, AV_LOG_ERROR,

627 "statistics are damaged at line %d, parser out=%d\n",

628 i, e);

629 return -1;

630 }

631

632 p = next;

633 }

634

635 res = init_pass2(s);

636 if (res < 0)

637 return res;

638 }

639

640 if (!(s->avctx->flags & AV_CODEC_FLAG_PASS2)) {

641 rcc->short_term_qsum = 0.001;

642 rcc->short_term_qcount = 0.001;

643

644 rcc->pass1_rc_eq_output_sum = 0.001;

645 rcc->pass1_wanted_bits = 0.001;

646

647 if (s->avctx->qblur > 1.0) {

648 av_log(s->avctx, AV_LOG_ERROR, "qblur too large\n");

649 return -1;

650 }

651 /* init stuff with the user specified complexity */

652 if (s->rc_initial_cplx) {

653 for (i = 0; i < 60 * 30; i++) {

654 double bits = s->rc_initial_cplx * (i / 10000.0 + 1.0) * s->mb_num;

655 RateControlEntry rce;

656

657 if (i % ((s->gop_size + 3) / 4) == 0)

658 rce.pict_type = AV_PICTURE_TYPE_I;

659 else if (i % (s->max_b_frames + 1))

660 rce.pict_type = AV_PICTURE_TYPE_B;

661 else

662 rce.pict_type = AV_PICTURE_TYPE_P;

663

664 rce.new_pict_type = rce.pict_type;

665 rce.mc_mb_var_sum = bits * s->mb_num / 100000;

666 rce.mb_var_sum = s->mb_num;

667

668 rce.qscale = FF_QP2LAMBDA * 2;

669 rce.f_code = 2;

670 rce.b_code = 1;

671 rce.misc_bits = 1;

672

673 if (s->pict_type == AV_PICTURE_TYPE_I) {

674 rce.i_count = s->mb_num;

675 rce.i_tex_bits = bits;

676 rce.p_tex_bits = 0;

677 rce.mv_bits = 0;

678 } else {

679 rce.i_count = 0; // FIXME we do know this approx

680 rce.i_tex_bits = 0;

681 rce.p_tex_bits = bits * 0.9;

682 rce.mv_bits = bits * 0.1;

683 }

684 rcc->i_cplx_sum[rce.pict_type] += rce.i_tex_bits * rce.qscale;

685 rcc->p_cplx_sum[rce.pict_type] += rce.p_tex_bits * rce.qscale;

686 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;

687 rcc->frame_count[rce.pict_type]++;

688

689 get_qscale(s, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);

690

691 // FIXME misbehaves a little for variable fps

692 rcc->pass1_wanted_bits += s->bit_rate / get_fps(s->avctx);

693 }

694 }

695 }

696

697 return 0;

698 }

699

700 av_cold void ff_rate_control_uninit(RateControlContext *rcc)

701 {

702 emms_c();

703

704 av_expr_free(rcc->rc_eq_eval);

705 rcc->rc_eq_eval = NULL;

706 av_freep(&rcc->entry);

707 }

708

709 int ff_vbv_update(MpegEncContext *s, int frame_size)

710 {

711 RateControlContext *rcc = &s->rc_context;

712 const double fps = get_fps(s->avctx);

713 const int buffer_size = s->avctx->rc_buffer_size;

714 const double min_rate = s->avctx->rc_min_rate / fps;

715 const double max_rate = s->avctx->rc_max_rate / fps;

716

717 ff_dlog(s, "%d %f %d %f %f\n",

718 buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);

719

720 if (buffer_size) {

721 int left;

722

723 rcc->buffer_index -= frame_size;

724 if (rcc->buffer_index < 0) {

725 av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");

726 if (frame_size > max_rate && s->qscale == s->avctx->qmax) {

727 av_log(s->avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");

728 }

729 rcc->buffer_index = 0;

730 }

731

732 left = buffer_size - rcc->buffer_index - 1;

733 rcc->buffer_index += av_clip(left, min_rate, max_rate);

734

735 if (rcc->buffer_index > buffer_size) {

736 int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);

737

738 if (stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)

739 stuffing = 4;

740 rcc->buffer_index -= 8 * stuffing;

741

742 if (s->avctx->debug & FF_DEBUG_RC)

743 av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);

744

745 return stuffing;

746 }

747 }

748 return 0;

749 }

750

751 static double predict_size(Predictor *p, double q, double var)

752 {

753 return p->coeff * var / (q * p->count);

754 }

755

756 static void update_predictor(Predictor *p, double q, double var, double size)

757 {

758 double new_coeff = size * q / (var + 1);

759 if (var < 10)

760 return;

761

762 p->count *= p->decay;

763 p->coeff *= p->decay;

764 p->count++;

765 p->coeff += new_coeff;

766 }

767

768 static void adaptive_quantization(MpegEncContext *s, double q)

769 {

770 int i;

771 const float lumi_masking = s->avctx->lumi_masking / (128.0 * 128.0);

772 const float dark_masking = s->avctx->dark_masking / (128.0 * 128.0);

773 const float temp_cplx_masking = s->avctx->temporal_cplx_masking;

774 const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;

775 const float p_masking = s->avctx->p_masking;

776 const float border_masking = s->border_masking;

777 float bits_sum = 0.0;

778 float cplx_sum = 0.0;

779 float *cplx_tab = s->cplx_tab;

780 float *bits_tab = s->bits_tab;

781 const int qmin = s->avctx->mb_lmin;

782 const int qmax = s->avctx->mb_lmax;

783 const int mb_width = s->mb_width;

784 const int mb_height = s->mb_height;

785

786 for (i = 0; i < s->mb_num; i++) {

787 const int mb_xy = s->mb_index2xy[i];

788 float temp_cplx = sqrt(s->mc_mb_var[mb_xy]); // FIXME merge in pow()

789 float spat_cplx = sqrt(s->mb_var[mb_xy]);

790 const int lumi = s->mb_mean[mb_xy];

791 float bits, cplx, factor;

792 int mb_x = mb_xy % s->mb_stride;

793 int mb_y = mb_xy / s->mb_stride;

794 int mb_distance;

795 float mb_factor = 0.0;

796 if (spat_cplx < 4)

797 spat_cplx = 4; // FIXME fine-tune

798 if (temp_cplx < 4)

799 temp_cplx = 4; // FIXME fine-tune

800

801 if ((s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_INTRA)) { // FIXME hq mode

802 cplx = spat_cplx;

803 factor = 1.0 + p_masking;

804 } else {

805 cplx = temp_cplx;

806 factor = pow(temp_cplx, -temp_cplx_masking);

807 }

808 factor *= pow(spat_cplx, -spatial_cplx_masking);

809

810 if (lumi > 127)

811 factor *= (1.0 - (lumi - 128) * (lumi - 128) * lumi_masking);

812 else

813 factor *= (1.0 - (lumi - 128) * (lumi - 128) * dark_masking);

814

815 if (mb_x < mb_width / 5) {

816 mb_distance = mb_width / 5 - mb_x;

817 mb_factor = (float)mb_distance / (float)(mb_width / 5);

818 } else if (mb_x > 4 * mb_width / 5) {

819 mb_distance = mb_x - 4 * mb_width / 5;

820 mb_factor = (float)mb_distance / (float)(mb_width / 5);

821 }

822 if (mb_y < mb_height / 5) {

823 mb_distance = mb_height / 5 - mb_y;

824 mb_factor = FFMAX(mb_factor,

825 (float)mb_distance / (float)(mb_height / 5));

826 } else if (mb_y > 4 * mb_height / 5) {

827 mb_distance = mb_y - 4 * mb_height / 5;

828 mb_factor = FFMAX(mb_factor,

829 (float)mb_distance / (float)(mb_height / 5));

830 }

831

832 factor *= 1.0 - border_masking * mb_factor;

833

834 if (factor < 0.00001)

835 factor = 0.00001;

836

837 bits = cplx * factor;

838 cplx_sum += cplx;

839 bits_sum += bits;

840 cplx_tab[i] = cplx;

841 bits_tab[i] = bits;

842 }

843

844 /* handle qmin/qmax clipping */

845 if (s->mpv_flags & FF_MPV_FLAG_NAQ) {

846 float factor = bits_sum / cplx_sum;

847 for (i = 0; i < s->mb_num; i++) {

848 float newq = q * cplx_tab[i] / bits_tab[i];

849 newq *= factor;

850

851 if (newq > qmax) {

852 bits_sum -= bits_tab[i];

853 cplx_sum -= cplx_tab[i] * q / qmax;

854 } else if (newq < qmin) {

855 bits_sum -= bits_tab[i];

856 cplx_sum -= cplx_tab[i] * q / qmin;

857 }

858 }

859 if (bits_sum < 0.001)

860 bits_sum = 0.001;

861 if (cplx_sum < 0.001)

862 cplx_sum = 0.001;

863 }

864

865 for (i = 0; i < s->mb_num; i++) {

866 const int mb_xy = s->mb_index2xy[i];

867 float newq = q * cplx_tab[i] / bits_tab[i];

868 int intq;

869

870 if (s->mpv_flags & FF_MPV_FLAG_NAQ) {

871 newq *= bits_sum / cplx_sum;

872 }

873

874 intq = (int)(newq + 0.5);

875

876 if (intq > qmax)

877 intq = qmax;

878 else if (intq < qmin)

879 intq = qmin;

880 s->lambda_table[mb_xy] = intq;

881 }

882 }

883

884 void ff_get_2pass_fcode(MpegEncContext *s)

885 {

886 const RateControlContext *rcc = &s->rc_context;

887 const RateControlEntry *rce = &rcc->entry[s->picture_number];

888

889 s->f_code = rce->f_code;

890 s->b_code = rce->b_code;

891 }

892

893 // FIXME rd or at least approx for dquant

894

895 float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)

896 {

897 float q;

898 int qmin, qmax;

899 float br_compensation;

900 double diff;

901 double short_term_q;

902 double fps;

903 int picture_number = s->picture_number;

904 int64_t wanted_bits;

905 RateControlContext *rcc = &s->rc_context;

906 AVCodecContext *a = s->avctx;

907 RateControlEntry local_rce, *rce;

908 double bits;

909 double rate_factor;

910 int64_t var;

911 const int pict_type = s->pict_type;

912 emms_c();

913

914 get_qminmax(&qmin, &qmax, s, pict_type);

915

916 fps = get_fps(s->avctx);

917 /* update predictors */

918 if (picture_number > 2 && !dry_run) {

919 const int64_t last_var =

920 s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum

921 : rcc->last_mc_mb_var_sum;

922 av_assert1(s->frame_bits >= s->stuffing_bits);

923 update_predictor(&rcc->pred[s->last_pict_type],

924 rcc->last_qscale,

925 sqrt(last_var),

926 s->frame_bits - s->stuffing_bits);

927 }

928

929 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {

930 av_assert0(picture_number >= 0);

931 if (picture_number >= rcc->num_entries) {

932 av_log(s, AV_LOG_ERROR, "Input is longer than 2-pass log file\n");

933 return -1;

934 }

935 rce = &rcc->entry[picture_number];

936 wanted_bits = rce->expected_bits;

937 } else {

938 const MPVPicture *dts_pic;

939 double wanted_bits_double;

940 rce = &local_rce;

941

942 /* FIXME add a dts field to AVFrame and ensure it is set and use it

943 * here instead of reordering but the reordering is simpler for now

944 * until H.264 B-pyramid must be handled. */

945 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)

946 dts_pic = s->cur_pic.ptr;

947 else

948 dts_pic = s->last_pic.ptr;

949

950 if (!dts_pic || dts_pic->f->pts == AV_NOPTS_VALUE)

951 wanted_bits_double = s->bit_rate * (double)picture_number / fps;

952 else

953 wanted_bits_double = s->bit_rate * (double)dts_pic->f->pts / fps;

954 if (wanted_bits_double > INT64_MAX) {

955 av_log(s, AV_LOG_WARNING, "Bits exceed 64bit range\n");

956 wanted_bits = INT64_MAX;

957 } else

958 wanted_bits = (int64_t)wanted_bits_double;

959 }

960

961 diff = s->total_bits - wanted_bits;

962 br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;

963 if (br_compensation <= 0.0)

964 br_compensation = 0.001;

965

966 var = pict_type == AV_PICTURE_TYPE_I ? s->mb_var_sum : s->mc_mb_var_sum;

967

968 short_term_q = 0; /* avoid warning */

969 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {

970 if (pict_type != AV_PICTURE_TYPE_I)

971 av_assert0(pict_type == rce->new_pict_type);

972

973 q = rce->new_qscale / br_compensation;

974 ff_dlog(s, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,

975 br_compensation, s->frame_bits, var, pict_type);

976 } else {

977 rce->pict_type =

978 rce->new_pict_type = pict_type;

979 rce->mc_mb_var_sum = s->mc_mb_var_sum;

980 rce->mb_var_sum = s->mb_var_sum;

981 rce->qscale = FF_QP2LAMBDA * 2;

982 rce->f_code = s->f_code;

983 rce->b_code = s->b_code;

984 rce->misc_bits = 1;

985

986 bits = predict_size(&rcc->pred[pict_type], rce->qscale, sqrt(var));

987 if (pict_type == AV_PICTURE_TYPE_I) {

988 rce->i_count = s->mb_num;

989 rce->i_tex_bits = bits;

990 rce->p_tex_bits = 0;

991 rce->mv_bits = 0;

992 } else {

993 rce->i_count = 0; // FIXME we do know this approx

994 rce->i_tex_bits = 0;

995 rce->p_tex_bits = bits * 0.9;

996 rce->mv_bits = bits * 0.1;

997 }

998 rcc->i_cplx_sum[pict_type] += rce->i_tex_bits * rce->qscale;

999 rcc->p_cplx_sum[pict_type] += rce->p_tex_bits * rce->qscale;

1000 rcc->mv_bits_sum[pict_type] += rce->mv_bits;

1001 rcc->frame_count[pict_type]++;

1002

1003 rate_factor = rcc->pass1_wanted_bits /

1004 rcc->pass1_rc_eq_output_sum * br_compensation;

1005

1006 q = get_qscale(s, rce, rate_factor, picture_number);

1007 if (q < 0)

1008 return -1;

1009

1010 av_assert0(q > 0.0);

1011 q = get_diff_limited_q(s, rce, q);

1012 av_assert0(q > 0.0);

1013

1014 // FIXME type dependent blur like in 2-pass

1015 if (pict_type == AV_PICTURE_TYPE_P || s->intra_only) {

1016 rcc->short_term_qsum *= a->qblur;

1017 rcc->short_term_qcount *= a->qblur;

1018

1019 rcc->short_term_qsum += q;

1020 rcc->short_term_qcount++;

1021 q = short_term_q = rcc->short_term_qsum / rcc->short_term_qcount;

1022 }

1023 av_assert0(q > 0.0);

1024

1025 q = modify_qscale(s, rce, q, picture_number);

1026

1027 rcc->pass1_wanted_bits += s->bit_rate / fps;

1028

1029 av_assert0(q > 0.0);

1030 }

1031

1032 if (s->avctx->debug & FF_DEBUG_RC) {

1033 av_log(s->avctx, AV_LOG_DEBUG,

1034 "%c qp:%d<%2.1f<%d %d want:%"PRId64" total:%"PRId64" comp:%f st_q:%2.2f "

1035 "size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n",

1036 av_get_picture_type_char(pict_type),

1037 qmin, q, qmax, picture_number,

1038 wanted_bits / 1000, s->total_bits / 1000,

1039 br_compensation, short_term_q, s->frame_bits,

1040 s->mb_var_sum, s->mc_mb_var_sum,

1041 s->bit_rate / 1000, (int)fps);

1042 }

1043

1044 if (q < qmin)

1045 q = qmin;

1046 else if (q > qmax)

1047 q = qmax;

1048

1049 if (s->adaptive_quant)

1050 adaptive_quantization(s, q);

1051 else

1052 q = (int)(q + 0.5);

1053

1054 if (!dry_run) {

1055 rcc->last_qscale = q;

1056 rcc->last_mc_mb_var_sum = s->mc_mb_var_sum;

1057 rcc->last_mb_var_sum = s->mb_var_sum;

1058 }

1059 return q;

1060 }

FF_DEBUG_RC

#define FF_DEBUG_RC

Definition: avcodec.h:1408

ratecontrol.h

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:73

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

av_clip

#define av_clip

Definition: common.h:100

RateControlContext::last_mb_var_sum

int64_t last_mb_var_sum

Definition: ratecontrol.h:72

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

FF_MPV_FLAG_NAQ

#define FF_MPV_FLAG_NAQ

Definition: mpegvideoenc.h:62

av_div_q

AVRational av_div_q(AVRational b, AVRational c)

Divide one rational by another.

Definition: rational.c:88

mpegvideoenc.h

int64_t

long long int64_t

Definition: coverity.c:34

normalize.log

log

Definition: normalize.py:21

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

RateControlEntry

Definition: ratecontrol.h:39

AVFrame::pts

int64_t pts

Presentation timestamp in time_base units (time when frame should be shown to user).

Definition: frame.h:501

step

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

Definition: rate_distortion.txt:58

get_fpsQ

static AVRational get_fpsQ(AVCodecContext *avctx)

Definition: ratecontrol.c:59

FF_LAMBDA_MAX

#define FF_LAMBDA_MAX

Definition: avutil.h:228

RateControlEntry::i_count

int i_count

Definition: ratecontrol.h:42

RateControlContext::rc_eq_eval

struct AVExpr * rc_eq_eval

Definition: ratecontrol.h:80

get_qscale

static double get_qscale(MpegEncContext *s, RateControlEntry *rce, double rate_factor, int frame_num)

Modify the bitrate curve from pass1 for one frame.

Definition: ratecontrol.c:262

ff_rate_control_init

av_cold int ff_rate_control_init(MpegEncContext *s)

Definition: ratecontrol.c:497

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

RateControlEntry::f_code

int f_code

Definition: ratecontrol.h:43

RateControlEntry::p_tex_bits

int p_tex_bits

Definition: ratecontrol.h:47

RateControlContext::short_term_qcount

double short_term_qcount

count of recent qscales

Definition: ratecontrol.h:66

qp2bits

static double qp2bits(const RateControlEntry *rce, double qp)

Definition: ratecontrol.c:78

const_values

static const double const_values[]

Definition: eval.c:28

bits2qp

static double bits2qp(const RateControlEntry *rce, double bits)

Definition: ratecontrol.c:91

init_pass2

static int init_pass2(MpegEncContext *s)

Definition: ratecontrol.c:335

av_expr_parse

int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)

Parse an expression.

Definition: eval.c:710

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:566

modify_qscale

static double modify_qscale(MpegEncContext *s, const RateControlEntry *rce, double q, int frame_num)

Definition: ratecontrol.c:171

func1_names

static const char *const func1_names[]

Definition: vf_rotate.c:188

av_expr_free

void av_expr_free(AVExpr *e)

Free a parsed expression previously created with av_expr_parse().

Definition: eval.c:358

AVRational::num

int num

Numerator.

Definition: rational.h:59

RateControlContext::pred

Predictor pred[5]

Definition: ratecontrol.h:64

ff_rate_estimate_qscale

float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)

Definition: ratecontrol.c:895

ceil

static __device__ float ceil(float a)

Definition: cuda_runtime.h:176

RateControlContext

rate control context.

Definition: ratecontrol.h:60

RateControlContext::num_entries

int num_entries

number of RateControlEntries

Definition: ratecontrol.h:61

RcOverride::quality_factor

float quality_factor

Definition: avcodec.h:208

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

emms_c

#define emms_c()

Definition: emms.h:63

float

Definition: af_crystalizer.c:122

#define s(width, name)

Definition: cbs_vp9.c:198

M_E

#define M_E

Definition: mathematics.h:37

RcOverride

Definition: avcodec.h:204

frame_size

int frame_size

Definition: mxfenc.c:2424

RateControlContext::pass1_wanted_bits

double pass1_wanted_bits

bits which should have been output by the pass1 code (including complexity init)

Definition: ratecontrol.h:68

av_q2d

static double av_q2d(AVRational a)

Convert an AVRational to a double.

Definition: rational.h:104

bits

uint8_t bits

Definition: vp3data.h:128

RateControlEntry::misc_bits

int misc_bits

Definition: ratecontrol.h:48

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

adaptive_quantization

static void adaptive_quantization(MpegEncContext *s, double q)

Definition: ratecontrol.c:768

Predictor::coeff

double coeff

Definition: ratecontrol.h:34

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

RateControlEntry::new_pict_type

int new_pict_type

Definition: ratecontrol.h:51

av_expr_eval

double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)

Evaluate a previously parsed expression.

Definition: eval.c:792

av_rescale_q

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

Rescale a 64-bit integer by 2 rational numbers.

Definition: mathematics.c:142

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:394

Predictor::count

double count

Definition: ratecontrol.h:35

FFABS

#define FFABS(a)

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

Definition: common.h:74

if(ret)

Definition: filter_design.txt:179

RateControlEntry::b_code

int b_code

Definition: ratecontrol.h:44

ff_write_pass1_stats

void ff_write_pass1_stats(MpegEncContext *s)

Definition: ratecontrol.c:38

fabs

static __device__ float fabs(float a)

Definition: cuda_runtime.h:182

NULL

#define NULL

Definition: coverity.c:32

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

isnan

#define isnan(x)

Definition: libm.h:340

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:279

ff_vbv_update

int ff_vbv_update(MpegEncContext *s, int frame_size)

Definition: ratecontrol.c:709

double

Definition: af_crystalizer.c:132

RateControlEntry::pict_type

int pict_type

Definition: ratecontrol.h:40

RateControlEntry::header_bits

int header_bits

Definition: ratecontrol.h:49

av_clipf

Definition: af_crystalizer.c:122

exp

int8_t exp

Definition: eval.c:73

index

int index

Definition: gxfenc.c:90

RateControlContext::qscale_sum

uint64_t qscale_sum[5]

Definition: ratecontrol.h:76

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

RateControlEntry::new_qscale

float new_qscale

Definition: ratecontrol.h:52

update_predictor

static void update_predictor(Predictor *p, double q, double var, double size)

Definition: ratecontrol.c:756

AVCodecContext::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.

Definition: avcodec.h:550

eval.h

RateControlContext::mv_bits_sum

uint64_t mv_bits_sum[5]

Definition: ratecontrol.h:75

size

int size

Definition: twinvq_data.h:10344

CANDIDATE_MB_TYPE_INTRA

#define CANDIDATE_MB_TYPE_INTRA

Definition: mpegvideoenc.h:40

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

Predictor::decay

double decay

Definition: ratecontrol.h:36

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

get_fps

static double get_fps(AVCodecContext *avctx)

Definition: ratecontrol.c:73

AV_CODEC_FLAG_PASS2

#define AV_CODEC_FLAG_PASS2

Use internal 2pass ratecontrol in second pass mode.

Definition: avcodec.h:314

Predictor

Definition: ratecontrol.h:33

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

attributes.h

RateControlContext::pass1_rc_eq_output_sum

double pass1_rc_eq_output_sum

sum of the output of the rc equation, this is used for normalization

Definition: ratecontrol.h:67

M_PI

#define M_PI

Definition: mathematics.h:67

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

av_get_picture_type_char

char av_get_picture_type_char(enum AVPictureType pict_type)

Return a single letter to describe the given picture type pict_type.

Definition: utils.c:40

emms.h

RateControlEntry::qscale

float qscale

Definition: ratecontrol.h:41

func1

static double(*const func1[])(void *, double)

Definition: vf_rotate.c:182

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

Definition: cbs_h2645.c:256

RateControlEntry::mv_bits

int mv_bits

Definition: ratecontrol.h:45

RateControlContext::last_mc_mb_var_sum

int64_t last_mc_mb_var_sum

Definition: ratecontrol.h:71

internal.h

RateControlContext::frame_count

int frame_count[5]

Definition: ratecontrol.h:77

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:31

get_diff_limited_q

static double get_diff_limited_q(MpegEncContext *s, const RateControlEntry *rce, double q)

Definition: ratecontrol.c:104

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:56

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:256

av_inv_q

static av_always_inline AVRational av_inv_q(AVRational q)

Invert a rational.

Definition: rational.h:159

RateControlContext::buffer_index

double buffer_index

amount of bits in the video/audio buffer

Definition: ratecontrol.h:63

avcodec.h

RateControlContext::last_non_b_pict_type

int last_non_b_pict_type

Definition: ratecontrol.h:78

RateControlContext::last_qscale_for

double last_qscale_for[5]

last qscale for a specific pict type, used for max_diff & ipb factor stuff

Definition: ratecontrol.h:70

bits2qp_cb

static double bits2qp_cb(void *rce, double qp)

Definition: ratecontrol.c:99

const_names

static const char *const const_names[]

Definition: eval.c:34

MPVPicture::f

struct AVFrame * f

Definition: mpegpicture.h:59

left

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

Definition: snow.txt:386

RateControlContext::i_cplx_sum

uint64_t i_cplx_sum[5]

Definition: ratecontrol.h:73

RateControlEntry::mc_mb_var_sum

int64_t mc_mb_var_sum

Definition: ratecontrol.h:53

AVCodecContext

main external API structure.

Definition: avcodec.h:451

RateControlContext::short_term_qsum

double short_term_qsum