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/internal.h"

31 #include "avcodec.h"

32 #include "ratecontrol.h"

33 #include "mpegutils.h"

34 #include "mpegvideoenc.h"

35 #include "libavutil/eval.h"

37 void ff_write_pass1_stats(MpegEncContext *s)

38 {

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

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

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

42 s->current_picture_ptr->display_picture_number,

43 s->current_picture_ptr->coded_picture_number,

44 s->pict_type,

45 s->current_picture.f->quality,

46 s->i_tex_bits,

47 s->p_tex_bits,

48 s->mv_bits,

49 s->misc_bits,

50 s->f_code,

51 s->b_code,

52 s->mc_mb_var_sum,

53 s->mb_var_sum,

54 s->i_count, s->skip_count,

55 s->header_bits);

56 }

58 static double get_fps(AVCodecContext *avctx)

59 {

60 return 1.0 / av_q2d(avctx->time_base) / FFMAX(avctx->ticks_per_frame, 1);

61 }

63 static inline double qp2bits(RateControlEntry *rce, double qp)

64 {

65 if (qp <= 0.0) {

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

67 }

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

69 }

71 static inline double bits2qp(RateControlEntry *rce, double bits)

72 {

73 if (bits < 0.9) {

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

75 }

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

77 }

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

80 {

81 RateControlContext *rcc = &s->rc_context;

82 AVCodecContext *a = s->avctx;

83 const int pict_type = rce->new_pict_type;

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

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

87 if (pict_type == AV_PICTURE_TYPE_I &&

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

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

90 else if (pict_type == AV_PICTURE_TYPE_B &&

91 a->b_quant_factor > 0.0)

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

93 if (q < 1)

94 q = 1;

96 /* last qscale / qdiff stuff */

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

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

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

100

101 if (q > last_q + maxdiff)

102 q = last_q + maxdiff;

103 else if (q < last_q - maxdiff)

104 q = last_q - maxdiff;

105 }

106

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

108

109 if (pict_type != AV_PICTURE_TYPE_B)

110 rcc->last_non_b_pict_type = pict_type;

111

112 return q;

113 }

114

115 /**

116 * Get the qmin & qmax for pict_type.

117 */

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

119 {

120 int qmin = s->lmin;

121 int qmax = s->lmax;

122

123 av_assert0(qmin <= qmax);

124

125 switch (pict_type) {

126 case AV_PICTURE_TYPE_B:

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

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

129 break;

130 case AV_PICTURE_TYPE_I:

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

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

133 break;

134 }

135

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

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

138

139 if (qmax < qmin)

140 qmax = qmin;

141

142 *qmin_ret = qmin;

143 *qmax_ret = qmax;

144 }

145

146 static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,

147 double q, int frame_num)

148 {

149 RateControlContext *rcc = &s->rc_context;

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

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

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

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

154 const int pict_type = rce->new_pict_type;

155 int qmin, qmax;

156

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

158

159 /* modulation */

160 if (s->rc_qmod_freq &&

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

162 pict_type == AV_PICTURE_TYPE_P)

163 q *= s->rc_qmod_amp;

164

165 /* buffer overflow/underflow protection */

166 if (buffer_size) {

167 double expected_size = rcc->buffer_index;

168 double q_limit;

169

170 if (min_rate) {

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

172 if (d > 1.0)

173 d = 1.0;

174 else if (d < 0.0001)

175 d = 0.0001;

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

177

178 q_limit = bits2qp(rce,

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

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

181

182 if (q > q_limit) {

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

184 av_log(s->avctx, AV_LOG_DEBUG,

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

186 q = q_limit;

187 }

188 }

189

190 if (max_rate) {

191 double d = 2 * expected_size / buffer_size;

192 if (d > 1.0)

193 d = 1.0;

194 else if (d < 0.0001)

195 d = 0.0001;

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

197

198 q_limit = bits2qp(rce,

199 FFMAX(rcc->buffer_index *

200 s->avctx->rc_max_available_vbv_use,

201 1));

202 if (q < q_limit) {

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

204 av_log(s->avctx, AV_LOG_DEBUG,

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

206 q = q_limit;

207 }

208 }

209 }

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

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

212 s->rc_buffer_aggressivity);

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

214 if (q < qmin)

215 q = qmin;

216 else if (q > qmax)

217 q = qmax;

218 } else {

219 double min2 = log(qmin);

220 double max2 = log(qmax);

221

222 q = log(q);

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

224 q *= -4.0;

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

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

227

228 q = exp(q);

229 }

230

231 return q;

232 }

233

234 /**

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

236 */

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

238 double rate_factor, int frame_num)

239 {

240 RateControlContext *rcc = &s->rc_context;

241 AVCodecContext *a = s->avctx;

242 const int pict_type = rce->new_pict_type;

243 const double mb_num = s->mb_num;

244 double q, bits;

245 int i;

246

247 double const_values[] = {

248 M_PI,

249 M_E,

250 rce->i_tex_bits * rce->qscale,

251 rce->p_tex_bits * rce->qscale,

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

253 rce->mv_bits / mb_num,

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

255 rce->i_count / mb_num,

256 rce->mc_mb_var_sum / mb_num,

257 rce->mb_var_sum / mb_num,

258 rce->pict_type == AV_PICTURE_TYPE_I,

259 rce->pict_type == AV_PICTURE_TYPE_P,

260 rce->pict_type == AV_PICTURE_TYPE_B,

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

262 a->qcompress,

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

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

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

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

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

268 0

269 };

270

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

272 if (isnan(bits)) {

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

274 return -1;

275 }

276

277 rcc->pass1_rc_eq_output_sum += bits;

278 bits *= rate_factor;

279 if (bits < 0.0)

280 bits = 0.0;

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

282

283 /* user override */

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

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

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

287 continue;

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

289 continue;

290

291 if (rco[i].qscale)

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

293 else

294 bits *= rco[i].quality_factor;

295 }

296

297 q = bits2qp(rce, bits);

298

299 /* I/B difference */

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

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

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

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

304 if (q < 1)

305 q = 1;

306

307 return q;

308 }

309

310 static int init_pass2(MpegEncContext *s)

311 {

312 RateControlContext *rcc = &s->rc_context;

313 AVCodecContext *a = s->avctx;

314 int i, toobig;

315 double fps = get_fps(s->avctx);

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

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

318 uint64_t all_const_bits;

319 uint64_t all_available_bits = (uint64_t)(s->bit_rate *

320 (double)rcc->num_entries / fps);

321 double rate_factor = 0;

322 double step;

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

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

325 double *qscale, *blurred_qscale, qscale_sum;

326

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

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

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

330

331 rce->new_pict_type = rce->pict_type;

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

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

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

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

336

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

338 (double)rce->qscale;

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

340 }

341

342 all_const_bits = const_bits[AV_PICTURE_TYPE_I] +

343 const_bits[AV_PICTURE_TYPE_P] +

344 const_bits[AV_PICTURE_TYPE_B];

345

346 if (all_available_bits < all_const_bits) {

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

348 return -1;

349 }

350

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

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

353 if (!qscale || !blurred_qscale) {

354 av_free(qscale);

355 av_free(blurred_qscale);

356 return AVERROR(ENOMEM);

357 }

358 toobig = 0;

359

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

361 expected_bits = 0;

362 rate_factor += step;

363

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

365

366 /* find qscale */

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

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

369

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

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

372 }

373 av_assert0(filter_size % 2 == 1);

374

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

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

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

378

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

380 }

381

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

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

384

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

386 }

387

388 /* smooth curve */

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

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

391 const int pict_type = rce->new_pict_type;

392 int j;

393 double q = 0.0, sum = 0.0;

394

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

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

397 double d = index - i;

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

399

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

401 continue;

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

403 continue;

404 q += qscale[index] * coeff;

405 sum += coeff;

406 }

407 blurred_qscale[i] = q / sum;

408 }

409

410 /* find expected bits */

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

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

413 double bits;

414

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

416

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

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

419

420 rce->expected_bits = expected_bits;

421 expected_bits += bits;

422 }

423

424 ff_dlog(s->avctx,

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

426 expected_bits, (int)all_available_bits, rate_factor);

427 if (expected_bits > all_available_bits) {

428 rate_factor -= step;

429 ++toobig;

430 }

431 }

432 av_free(qscale);

433 av_free(blurred_qscale);

434

435 /* check bitrate calculations and print info */

436 qscale_sum = 0.0;

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

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

439 i,

440 rcc->entry[i].new_qscale,

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

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

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

444 }

445 av_assert0(toobig <= 40);

446 av_log(s->avctx, AV_LOG_DEBUG,

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

448 s->bit_rate,

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

450 av_log(s->avctx, AV_LOG_DEBUG,

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

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

453 if (toobig == 0) {

454 av_log(s->avctx, AV_LOG_INFO,

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

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

457 } else if (toobig == 40) {

458 av_log(s->avctx, AV_LOG_ERROR,

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

460 "with these parameters.\n");

461 return -1;

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

463 av_log(s->avctx, AV_LOG_ERROR,

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

465 return -1;

466 }

467

468 return 0;

469 }

470

471 av_cold int ff_rate_control_init(MpegEncContext *s)

472 {

473 RateControlContext *rcc = &s->rc_context;

474 int i, res;

475 static const char * const const_names[] = {

476 "PI",

477 "E",

478 "iTex",

479 "pTex",

480 "tex",

481 "mv",

482 "fCode",

483 "iCount",

484 "mcVar",

485 "var",

486 "isI",

487 "isP",

488 "isB",

489 "avgQP",

490 "qComp",

491 "avgIITex",

492 "avgPITex",

493 "avgPPTex",

494 "avgBPTex",

495 "avgTex",

496 NULL

497 };

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

499 (double (*)(void *, double)) bits2qp,

500 (double (*)(void *, double)) qp2bits,

501 NULL

502 };

503 static const char * const func1_names[] = {

504 "bits2qp",

505 "qp2bits",

506 NULL

507 };

508 emms_c();

509

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

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

512 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);

513 } else

514 s->avctx->rc_max_available_vbv_use = 1.0;

515 }

516

517 res = av_expr_parse(&rcc->rc_eq_eval,

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

519 const_names, func1_names, func1,

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

521 if (res < 0) {

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

523 return res;

524 }

525

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

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

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

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

530

531 rcc->i_cplx_sum [i] =

532 rcc->p_cplx_sum [i] =

533 rcc->mv_bits_sum[i] =

534 rcc->qscale_sum [i] =

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

536

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

538 }

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

540 if (!rcc->buffer_index)

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

542

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

544 int i;

545 char *p;

546

547 /* find number of pics */

548 p = s->avctx->stats_in;

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

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

551 i += s->max_b_frames;

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

553 return -1;

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

555 if (!rcc->entry)

556 return AVERROR(ENOMEM);

557 rcc->num_entries = i;

558

559 /* init all to skipped P-frames

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

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

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

563

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

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

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

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

568 }

569

570 /* read stats */

571 p = s->avctx->stats_in;

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

573 RateControlEntry *rce;

574 int picture_number;

575 int e;

576 char *next;

577

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

579 if (next) {

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

581 next++;

582 }

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

584

585 av_assert0(picture_number >= 0);

586 av_assert0(picture_number < rcc->num_entries);

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

588

589 e += sscanf(p, " in:%*d out:%*d type:%d q:%f itex:%d ptex:%d mv:%d misc:%d fcode:%d bcode:%d mc-var:%"SCNd64" var:%"SCNd64" icount:%d skipcount:%d hbits:%d",

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

591 &rce->mv_bits, &rce->misc_bits,

592 &rce->f_code, &rce->b_code,

593 &rce->mc_mb_var_sum, &rce->mb_var_sum,

594 &rce->i_count, &rce->skip_count, &rce->header_bits);

595 if (e != 14) {

596 av_log(s->avctx, AV_LOG_ERROR,

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

598 i, e);

599 return -1;

600 }

601

602 p = next;

603 }

604

605 if (init_pass2(s) < 0) {

606 ff_rate_control_uninit(s);

607 return -1;

608 }

609 }

610

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

612 rcc->short_term_qsum = 0.001;

613 rcc->short_term_qcount = 0.001;

614

615 rcc->pass1_rc_eq_output_sum = 0.001;

616 rcc->pass1_wanted_bits = 0.001;

617

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

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

620 return -1;

621 }

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

623 if (s->rc_initial_cplx) {

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

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

626 RateControlEntry rce;

627

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

629 rce.pict_type = AV_PICTURE_TYPE_I;

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

631 rce.pict_type = AV_PICTURE_TYPE_B;

632 else

633 rce.pict_type = AV_PICTURE_TYPE_P;

634

635 rce.new_pict_type = rce.pict_type;

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

637 rce.mb_var_sum = s->mb_num;

638

639 rce.qscale = FF_QP2LAMBDA * 2;

640 rce.f_code = 2;

641 rce.b_code = 1;

642 rce.misc_bits = 1;

643

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

645 rce.i_count = s->mb_num;

646 rce.i_tex_bits = bits;

647 rce.p_tex_bits = 0;

648 rce.mv_bits = 0;

649 } else {

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

651 rce.i_tex_bits = 0;

652 rce.p_tex_bits = bits * 0.9;

653 rce.mv_bits = bits * 0.1;

654 }

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

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

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

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

659

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

661

662 // FIXME misbehaves a little for variable fps

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

664 }

665 }

666 }

667

668 return 0;

669 }

670

671 av_cold void ff_rate_control_uninit(MpegEncContext *s)

672 {

673 RateControlContext *rcc = &s->rc_context;

674 emms_c();

675

676 av_expr_free(rcc->rc_eq_eval);

677 av_freep(&rcc->entry);

678 }

679

680 int ff_vbv_update(MpegEncContext *s, int frame_size)

681 {

682 RateControlContext *rcc = &s->rc_context;

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

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

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

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

687

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

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

690

691 if (buffer_size) {

692 int left;

693

694 rcc->buffer_index -= frame_size;

695 if (rcc->buffer_index < 0) {

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

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

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

699 }

700 rcc->buffer_index = 0;

701 }

702

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

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

705

706 if (rcc->buffer_index > buffer_size) {

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

708

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

710 stuffing = 4;

711 rcc->buffer_index -= 8 * stuffing;

712

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

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

715

716 return stuffing;

717 }

718 }

719 return 0;

720 }

721

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

723 {

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

725 }

726

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

728 {

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

730 if (var < 10)

731 return;

732

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

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

735 p->count++;

736 p->coeff += new_coeff;

737 }

738

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

740 {

741 int i;

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

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

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

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

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

747 const float border_masking = s->border_masking;

748 float bits_sum = 0.0;

749 float cplx_sum = 0.0;

750 float *cplx_tab = s->cplx_tab;

751 float *bits_tab = s->bits_tab;

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

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

754 const int mb_width = s->mb_width;

755 const int mb_height = s->mb_height;

756

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

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

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

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

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

762 float bits, cplx, factor;

763 int mb_x = mb_xy % s->mb_stride;

764 int mb_y = mb_xy / s->mb_stride;

765 int mb_distance;

766 float mb_factor = 0.0;

767 if (spat_cplx < 4)

768 spat_cplx = 4; // FIXME fine-tune

769 if (temp_cplx < 4)

770 temp_cplx = 4; // FIXME fine-tune

771

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

773 cplx = spat_cplx;

774 factor = 1.0 + p_masking;

775 } else {

776 cplx = temp_cplx;

777 factor = pow(temp_cplx, -temp_cplx_masking);

778 }

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

780

781 if (lumi > 127)

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

783 else

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

785

786 if (mb_x < mb_width / 5) {

787 mb_distance = mb_width / 5 - mb_x;

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

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

790 mb_distance = mb_x - 4 * mb_width / 5;

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

792 }

793 if (mb_y < mb_height / 5) {

794 mb_distance = mb_height / 5 - mb_y;

795 mb_factor = FFMAX(mb_factor,

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

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

798 mb_distance = mb_y - 4 * mb_height / 5;

799 mb_factor = FFMAX(mb_factor,

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

801 }

802

803 factor *= 1.0 - border_masking * mb_factor;

804

805 if (factor < 0.00001)

806 factor = 0.00001;

807

808 bits = cplx * factor;

809 cplx_sum += cplx;

810 bits_sum += bits;

811 cplx_tab[i] = cplx;

812 bits_tab[i] = bits;

813 }

814

815 /* handle qmin/qmax clipping */

816 if (s->mpv_flags & FF_MPV_FLAG_NAQ) {

817 float factor = bits_sum / cplx_sum;

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

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

820 newq *= factor;

821

822 if (newq > qmax) {

823 bits_sum -= bits_tab[i];

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

825 } else if (newq < qmin) {

826 bits_sum -= bits_tab[i];

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

828 }

829 }

830 if (bits_sum < 0.001)

831 bits_sum = 0.001;

832 if (cplx_sum < 0.001)

833 cplx_sum = 0.001;

834 }

835

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

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

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

839 int intq;

840

841 if (s->mpv_flags & FF_MPV_FLAG_NAQ) {

842 newq *= bits_sum / cplx_sum;

843 }

844

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

846

847 if (intq > qmax)

848 intq = qmax;

849 else if (intq < qmin)

850 intq = qmin;

851 s->lambda_table[mb_xy] = intq;

852 }

853 }

854

855 void ff_get_2pass_fcode(MpegEncContext *s)

856 {

857 RateControlContext *rcc = &s->rc_context;

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

859

860 s->f_code = rce->f_code;

861 s->b_code = rce->b_code;

862 }

863

864 // FIXME rd or at least approx for dquant

865

866 float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)

867 {

868 float q;

869 int qmin, qmax;

870 float br_compensation;

871 double diff;

872 double short_term_q;

873 double fps;

874 int picture_number = s->picture_number;

875 int64_t wanted_bits;

876 RateControlContext *rcc = &s->rc_context;

877 AVCodecContext *a = s->avctx;

878 RateControlEntry local_rce, *rce;

879 double bits;

880 double rate_factor;

881 int64_t var;

882 const int pict_type = s->pict_type;

883 emms_c();

884

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

886

887 fps = get_fps(s->avctx);

888 /* update predictors */

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

890 const int64_t last_var =

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

892 : rcc->last_mc_mb_var_sum;

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

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

895 rcc->last_qscale,

896 sqrt(last_var),

897 s->frame_bits - s->stuffing_bits);

898 }

899

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

901 av_assert0(picture_number >= 0);

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

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

904 return -1;

905 }

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

907 wanted_bits = rce->expected_bits;

908 } else {

909 Picture *dts_pic;

910 rce = &local_rce;

911

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

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

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

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

916 dts_pic = s->current_picture_ptr;

917 else

918 dts_pic = s->last_picture_ptr;

919

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

921 wanted_bits = (uint64_t)(s->bit_rate * (double)picture_number / fps);

922 else

923 wanted_bits = (uint64_t)(s->bit_rate * (double)dts_pic->f->pts / fps);

924 }

925

926 diff = s->total_bits - wanted_bits;

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

928 if (br_compensation <= 0.0)

929 br_compensation = 0.001;

930

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

932

933 short_term_q = 0; /* avoid warning */

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

935 if (pict_type != AV_PICTURE_TYPE_I)

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

937

938 q = rce->new_qscale / br_compensation;

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

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

941 } else {

942 rce->pict_type =

943 rce->new_pict_type = pict_type;

944 rce->mc_mb_var_sum = s->mc_mb_var_sum;

945 rce->mb_var_sum = s->mb_var_sum;

946 rce->qscale = FF_QP2LAMBDA * 2;

947 rce->f_code = s->f_code;

948 rce->b_code = s->b_code;

949 rce->misc_bits = 1;

950

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

952 if (pict_type == AV_PICTURE_TYPE_I) {

953 rce->i_count = s->mb_num;

954 rce->i_tex_bits = bits;

955 rce->p_tex_bits = 0;

956 rce->mv_bits = 0;

957 } else {

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

959 rce->i_tex_bits = 0;

960 rce->p_tex_bits = bits * 0.9;

961 rce->mv_bits = bits * 0.1;

962 }

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

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

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

966 rcc->frame_count[pict_type]++;

967

968 rate_factor = rcc->pass1_wanted_bits /

969 rcc->pass1_rc_eq_output_sum * br_compensation;

970

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

972 if (q < 0)

973 return -1;

974

975 av_assert0(q > 0.0);

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

977 av_assert0(q > 0.0);

978

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

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

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

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

983

984 rcc->short_term_qsum += q;

985 rcc->short_term_qcount++;

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

987 }

988 av_assert0(q > 0.0);

989

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

991

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

993

994 av_assert0(q > 0.0);

995 }

996

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

998 av_log(s->avctx, AV_LOG_DEBUG,

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

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

1001 av_get_picture_type_char(pict_type),

1002 qmin, q, qmax, picture_number,

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

1004 br_compensation, short_term_q, s->frame_bits,

1005 s->mb_var_sum, s->mc_mb_var_sum,

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

1007 }

1008

1009 if (q < qmin)

1010 q = qmin;

1011 else if (q > qmax)

1012 q = qmax;

1013

1014 if (s->adaptive_quant)

1015 adaptive_quantization(s, q);

1016 else

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

1018

1019 if (!dry_run) {

1020 rcc->last_qscale = q;

1021 rcc->last_mc_mb_var_sum = s->mc_mb_var_sum;

1022 rcc->last_mb_var_sum = s->mb_var_sum;

1023 }

1024 return q;

1025 }

FF_DEBUG_RC

#define FF_DEBUG_RC

Definition: avcodec.h:1360

ratecontrol.h

av_clip

#define av_clip

Definition: common.h:95

RateControlContext::last_mb_var_sum

int64_t last_mb_var_sum

Definition: ratecontrol.h:75

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

mpegvideoenc.h

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

RateControlEntry

Definition: ratecontrol.h:41

AVFrame::pts

int64_t pts

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

Definition: frame.h:437

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

RateControlContext::rc_eq_eval

AVExpr * rc_eq_eval

Definition: ratecontrol.h:83

FF_LAMBDA_MAX

#define FF_LAMBDA_MAX

Definition: avutil.h:228

RateControlEntry::i_count

int i_count

Definition: ratecontrol.h:54

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

ff_rate_control_init

av_cold int ff_rate_control_init(MpegEncContext *s)

Definition: ratecontrol.c:471

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

Picture

Picture.

Definition: mpegpicture.h:46

RateControlEntry::f_code

int f_code

Definition: ratecontrol.h:56

mpegutils.h

RateControlEntry::p_tex_bits

int p_tex_bits

Definition: ratecontrol.h:46

RateControlContext::short_term_qcount

double short_term_qcount

count of recent qscales

Definition: ratecontrol.h:69

const_values

static const double const_values[]

Definition: eval.c:28

init_pass2

static int init_pass2(MpegEncContext *s)

Definition: ratecontrol.c:310

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

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

qp2bits

static double qp2bits(RateControlEntry *rce, double qp)

Definition: ratecontrol.c:63

RateControlContext::pred

Predictor pred[5]

Definition: ratecontrol.h:67

ff_rate_estimate_qscale

float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)

Definition: ratecontrol.c:866

ceil

static __device__ float ceil(float a)

Definition: cuda_runtime.h:176

RateControlContext

rate control context.

Definition: ratecontrol.h:63

RateControlContext::num_entries

int num_entries

number of RateControlEntries

Definition: ratecontrol.h:64

RcOverride::quality_factor

float quality_factor

Definition: avcodec.h:200

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

float

Definition: af_crystalizer.c:122

#define s(width, name)

Definition: cbs_vp9.c:256

M_E

#define M_E

Definition: mathematics.h:37

RcOverride

Definition: avcodec.h:196

frame_size

int frame_size

Definition: mxfenc.c:2205

RateControlContext::pass1_wanted_bits

double pass1_wanted_bits

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

Definition: ratecontrol.h:71

AVCodecContext::ticks_per_frame

int ticks_per_frame

For some codecs, the time base is closer to the field rate than the frame rate.

Definition: avcodec.h:557

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

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

adaptive_quantization

static void adaptive_quantization(MpegEncContext *s, double q)

Definition: ratecontrol.c:739

Predictor::coeff

double coeff

Definition: ratecontrol.h:36

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

av_expr_eval

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

Evaluate a previously parsed expression.

Definition: eval.c:766

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:388

Predictor::count

double count

Definition: ratecontrol.h:37

FFABS

#define FFABS(a)

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

Definition: common.h:64

if(ret)

Definition: filter_design.txt:179

RateControlEntry::b_code

int b_code

Definition: ratecontrol.h:57

ff_write_pass1_stats

void ff_write_pass1_stats(MpegEncContext *s)

Definition: ratecontrol.c:37

fabs

static __device__ float fabs(float a)

Definition: cuda_runtime.h:182

NULL

#define NULL

Definition: coverity.c:32

isnan

#define isnan(x)

Definition: libm.h:340

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

ff_vbv_update

int ff_vbv_update(MpegEncContext *s, int frame_size)

Definition: ratecontrol.c:680

double

Definition: af_crystalizer.c:132

RateControlEntry::pict_type

int pict_type

Definition: ratecontrol.h:42

RateControlEntry::header_bits

int header_bits

Definition: ratecontrol.h:48

av_clipf

Definition: af_crystalizer.c:122

exp

int8_t exp

Definition: eval.c:72

index

int index

Definition: gxfenc.c:89

RateControlContext::qscale_sum

uint64_t qscale_sum[5]

Definition: ratecontrol.h:79

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

RateControlEntry::new_qscale

float new_qscale

Definition: ratecontrol.h:51

update_predictor

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

Definition: ratecontrol.c:727

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

eval.h

RateControlContext::mv_bits_sum

uint64_t mv_bits_sum[5]

Definition: ratecontrol.h:78

size

int size

Definition: twinvq_data.h:10344

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:248

Predictor::decay

double decay

Definition: ratecontrol.h:38

diff

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

Definition: vf_paletteuse.c:162

get_fps

static double get_fps(AVCodecContext *avctx)

Definition: ratecontrol.c:58

AV_CODEC_FLAG_PASS2

#define AV_CODEC_FLAG_PASS2

Use internal 2pass ratecontrol in second pass mode.

Definition: avcodec.h:293

Predictor

Definition: ratecontrol.h:35

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

M_PI

#define M_PI

Definition: mathematics.h:52

get_diff_limited_q

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

Definition: ratecontrol.c:79

modify_qscale

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

Definition: ratecontrol.c:146

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

RateControlEntry::qscale

float qscale

Definition: ratecontrol.h:43

func1

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

Definition: vf_rotate.c:182

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

Definition: cbs_h2645.c:269

RateControlEntry::mv_bits

int mv_bits

Definition: ratecontrol.h:44

RateControlContext::last_mc_mb_var_sum

int64_t last_mc_mb_var_sum

Definition: ratecontrol.h:74

internal.h

RateControlContext::frame_count

int frame_count[5]

Definition: ratecontrol.h:80

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:31

av_assert1

#define av_assert1(cond)

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

Definition: avassert.h:53

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

ff_rate_control_uninit

av_cold void ff_rate_control_uninit(MpegEncContext *s)

Definition: ratecontrol.c:671

RateControlContext::buffer_index

double buffer_index

amount of bits in the video/audio buffer

Definition: ratecontrol.h:66

avcodec.h

RateControlContext::last_non_b_pict_type

int last_non_b_pict_type

Definition: ratecontrol.h:81

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

const_names

static const char *const const_names[]

Definition: eval.c:34

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

RateControlEntry::mc_mb_var_sum

int64_t mc_mb_var_sum

Definition: ratecontrol.h:52

AVCodecContext

main external API structure.

Definition: avcodec.h:426

RateControlContext::short_term_qsum

double short_term_qsum