1 /*
2 * Copyright 2015 Rockchip Electronics Co. LTD
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define MODULE_TAG "vp8e_rc"
18
19 #include <string.h>
20
21 #include "mpp_env.h"
22 #include "mpp_mem.h"
23 #include "mpp_common.h"
24 #include "mpp_rc.h"
25
26 #include "vp8e_syntax.h"
27 #include "vp8e_debug.h"
28 #include "vp8e_rc.h"
29
30 #define DSCY 64
31 #define UPSCALE 8000
32 #define I32_MPP_MAX 0x7fffffff
33 #define QINDEX_RANGE 128
34 #define RC_ERROR_RESET 0x7fffffff
35 #define BIT_COUNT_MAX 0x1fffffff
36 #define BIT_COUNT_MIN (-BIT_COUNT_MAX)
37
38 static const RK_S32 ac_q_lookup_tbl[QINDEX_RANGE] = {
39 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
40 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
41 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
42 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
43 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
44 54, 55, 56, 57, 58, 60, 62, 64, 66, 68,
45 70, 72, 74, 76, 78, 80, 82, 84, 86, 88,
46 90, 92, 94, 96, 98, 100, 102, 104, 106, 108,
47 110, 112, 114, 116, 119, 122, 125, 128, 131, 134,
48 137, 140, 143, 146, 149, 152, 155, 158, 161, 164,
49 167, 170, 173, 177, 181, 185, 189, 193, 197, 201,
50 205, 209, 213, 217, 221, 225, 229, 234, 239, 245,
51 249, 254, 259, 264, 269, 274, 279, 284
52 };
53
initial_qp(RK_S32 bits,RK_S32 pels)54 static RK_S32 initial_qp(RK_S32 bits, RK_S32 pels)
55 {
56 RK_S32 i = -1;
57 static const RK_S32 qp_tbl[2][12] = {
58 {47, 57, 73, 93, 122, 155, 214, 294, 373, 506, 781, 0x7FFFFFFF},
59 {120, 110, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10}
60 };
61
62 if (bits > 1000000)
63 return 10;
64
65 pels >>= 8;
66 bits >>= 5;
67
68 bits *= pels + 250;
69 bits /= 350 + (3 * pels) / 4;
70 bits = axb_div_c(bits, UPSCALE, pels << 6);
71
72 while (qp_tbl[0][++i] < bits);
73
74 return qp_tbl[1][i];
75 }
76
update_rc_error(Vp8eLinReg * p,RK_S32 bits)77 static MPP_RET update_rc_error(Vp8eLinReg *p, RK_S32 bits)
78 {
79 p->len = 3;
80
81 if (bits >= (RK_S32)I32_MPP_MAX) {
82 p->bits[0] = 0;
83 p->bits[1] = 0;
84 p->bits[2] = 0;
85 return MPP_NOK;
86 }
87
88 p->bits[0] = bits - p->bits[2];
89 p->bits[1] = bits + p->bits[1];
90 p->bits[2] = bits;
91
92 return MPP_OK;
93 }
94
lin_sxy(RK_S32 * qp,RK_S32 * r,RK_S32 n)95 static RK_S32 lin_sxy(RK_S32 *qp, RK_S32 *r, RK_S32 n)
96 {
97 RK_S32 tmp, sum = 0;
98
99 while (n--) {
100 tmp = qp[n] * qp[n] * qp[n];
101 if (tmp > r[n]) {
102 sum += MPP_DIV_SIGN(tmp, DSCY) * r[n];
103 } else {
104 sum += tmp * MPP_DIV_SIGN(r[n], DSCY);
105 }
106
107 if (sum < 0) {
108 return I32_MPP_MAX;
109 }
110 }
111
112 return sum;
113 }
114
lin_sx(RK_S32 * qp,RK_S32 n)115 static RK_S32 lin_sx(RK_S32 *qp, RK_S32 n)
116 {
117 RK_S32 tmp = 0;
118
119 while (n--) {
120 tmp += qp[n];
121 }
122
123 return tmp;
124 }
125
lin_sy(RK_S32 * qp,RK_S32 * r,RK_S32 n)126 static RK_S32 lin_sy(RK_S32 *qp, RK_S32 *r, RK_S32 n)
127 {
128 RK_S32 sum = 0;
129
130 while (n--) {
131 sum += qp[n] * qp[n] * r[n];
132 if (sum < 0) {
133 return 2147483647 / 64;
134 }
135 }
136
137 return MPP_DIV_SIGN(sum, DSCY);
138 }
139
lin_nsxx(RK_S32 * qp,RK_S32 n)140 static RK_S32 lin_nsxx(RK_S32 *qp, RK_S32 n)
141 {
142 RK_S32 tmp = 0;
143 RK_S32 sum = 0;
144 RK_S32 d = n;
145
146 while (n--) {
147 tmp = qp[n];
148 tmp *= tmp;
149 sum += d * tmp;
150 }
151
152 return sum;
153 }
154
update_model(Vp8eLinReg * p)155 static void update_model(Vp8eLinReg *p)
156 {
157 RK_S32 a1, a2;
158
159 RK_S32 *qs = p->qs;
160 RK_S32 *r = p->bits;
161 RK_S32 n = p->len;
162 RK_S32 sx = lin_sx(qs, n);
163 RK_S32 sy = lin_sy(qs, r, n);
164
165 a1 = lin_sxy(qs, r, n);
166 a1 = (a1 < (I32_MPP_MAX / n)) ? (a1 * n) : I32_MPP_MAX;
167
168 if (sy == 0) {
169 a1 = 0;
170 } else {
171 a1 -= (sx < I32_MPP_MAX / sy) ? (sx * sy) : I32_MPP_MAX;
172 }
173
174 a2 = (lin_nsxx(qs, n) - (sx * sx));
175 if (a2 == 0) {
176 if (p->a1 == 0) {
177 a1 = 0;
178 } else {
179 a1 = (p->a1 * 2) / 3;
180 }
181 } else {
182 a1 = axb_div_c(a1, DSCY, a2);
183 }
184
185 a1 = MPP_MAX(a1, -4096 * DSCY);
186 a1 = MPP_MIN(a1, 4096 * DSCY - 1);
187
188 a2 = MPP_DIV_SIGN(sy * DSCY, n) - MPP_DIV_SIGN(a1 * sx, n);
189
190 if (p->len > 0) {
191 p->a1 = a1;
192 p->a2 = a2;
193 }
194
195 }
196
get_vir_buffer_bitcnt(Vp8eVirBuf * vb,RK_S32 time_inc)197 static RK_S32 get_vir_buffer_bitcnt(Vp8eVirBuf *vb, RK_S32 time_inc)
198 {
199 RK_S32 drift = 0;
200 RK_S32 target = 0;
201
202 /* Saturate realBitCnt, this is to prevent overflows caused by much greater
203 bitrate setting than is really possible to reach */
204 if (vb->real_bit_cnt > BIT_COUNT_MAX)
205 vb->real_bit_cnt = BIT_COUNT_MAX;
206 if (vb->real_bit_cnt < BIT_COUNT_MIN)
207 vb->real_bit_cnt = BIT_COUNT_MIN;
208
209 vb->pic_time_inc += time_inc;
210 vb->virtual_bit_cnt += axb_div_c(vb->bit_rate, time_inc,
211 vb->time_scale);
212 target = vb->virtual_bit_cnt - vb->real_bit_cnt;
213
214 /* Saturate target, prevents rc going totally out of control.
215 This situation should never happen. */
216 if (target > BIT_COUNT_MAX)
217 target = BIT_COUNT_MAX;
218 if (target < BIT_COUNT_MIN)
219 target = BIT_COUNT_MIN;
220
221 while (vb->pic_time_inc >= vb->time_scale) {
222 vb->pic_time_inc -= vb->time_scale;
223 vb->virtual_bit_cnt -= vb->bit_rate;
224 vb->real_bit_cnt -= vb->bit_rate;
225 }
226
227 drift = axb_div_c(vb->bit_rate, vb->pic_time_inc, vb->time_scale);
228 drift -= vb->virtual_bit_cnt;
229 vb->virtual_bit_cnt += drift;
230
231 return target;
232 }
233
skip_pic(Vp8eRc * rc)234 static MPP_RET skip_pic(Vp8eRc *rc)
235 {
236 Vp8eVirBuf *vb = &rc->virbuf;
237 RK_S32 skip_inc_limit = -vb->bit_per_pic / 3;
238 RK_S32 skip_dec_limit = vb->bit_per_pic / 3;
239 RK_S32 bit_available = vb->virtual_bit_cnt - vb->real_bit_cnt;
240
241 if (((rc->pic_rc_enable == 0) || (vb->skip_frame_target == 0)) &&
242 (bit_available < skip_inc_limit))
243 vb->skip_frame_target++;
244
245 if ((bit_available > skip_dec_limit) && vb->skip_frame_target > 0)
246 vb->skip_frame_target--;
247
248 if (vb->skipped_frames < vb->skip_frame_target) {
249 vb->skipped_frames++;
250 rc->frame_coded = 0;
251 } else {
252 vb->skipped_frames = 0;
253 }
254
255 return MPP_OK;
256 }
257
new_pic_quant(Vp8eLinReg * p,RK_S32 bits,RK_U8 use_qp_delta_limit)258 static RK_S32 new_pic_quant(Vp8eLinReg *p, RK_S32 bits, RK_U8 use_qp_delta_limit)
259 {
260 RK_S32 tmp, diff;
261 RK_S32 qp = p->qp_prev;
262 RK_S32 qp_best = p->qp_prev;
263 RK_S32 diff_best = I32_MPP_MAX;
264
265 if (p->a1 == 0 && p->a2 == 0) {
266 return qp;
267 }
268
269 if (bits <= 0) {
270 if (use_qp_delta_limit)
271 qp = MPP_MIN(QINDEX_RANGE - 1, MPP_MAX(0, qp + 4));
272 else
273 qp = MPP_MIN(QINDEX_RANGE - 1, MPP_MAX(0, qp + 10));
274
275 return qp;
276 }
277
278 do {
279 tmp = MPP_DIV_SIGN(p->a1, ac_q_lookup_tbl[qp]);
280 tmp += MPP_DIV_SIGN(p->a2, ac_q_lookup_tbl[qp] * ac_q_lookup_tbl[qp]);
281 diff = MPP_ABS(tmp - bits);
282
283 if (diff < diff_best) {
284 diff_best = diff;
285 qp_best = qp;
286 if ((tmp - bits) <= 0) {
287 if (qp < 1) {
288 break;
289 }
290 qp--;
291 } else {
292 if (qp >= QINDEX_RANGE - 1) {
293 break;
294 }
295 qp++;
296 }
297 } else {
298 break;
299 }
300 } while ((qp >= 0) && (qp < QINDEX_RANGE));
301 qp = qp_best;
302
303 if (use_qp_delta_limit) {
304 tmp = qp - p->qp_prev;
305 if (tmp > 4) {
306 qp = p->qp_prev + 4;
307 } else if (tmp < -4) {
308 qp = p->qp_prev - 4;
309 }
310 }
311
312 return qp;
313 }
314
avg_rc_error(Vp8eLinReg * p)315 static RK_S32 avg_rc_error(Vp8eLinReg *p)
316 {
317 return MPP_DIV_SIGN(p->bits[2] * 4 + p->bits[1] * 6 + p->bits[0] * 0, 100);
318 }
319
cal_pic_quant(Vp8eRc * rc)320 static MPP_RET cal_pic_quant(Vp8eRc *rc)
321 {
322 RK_S32 tmp = 0;
323 RK_S32 tmp_value = 0;
324 RK_S32 tmp_avg_rc_error;
325 RK_U8 use_qp_delta_limit = 1;
326
327 if (!rc->pic_rc_enable) {
328 rc->qp_hdr = rc->fixed_qp;
329 return MPP_OK;
330 }
331
332 if (rc->curr_frame_intra) {
333 if (rc->gop_len == 1 || rc->gop_len == 2) {
334 tmp = new_pic_quant(&rc->lin_reg,
335 axb_div_c(rc->target_pic_size, 256, rc->mb_per_pic),
336 use_qp_delta_limit);
337 } else {
338 if (rc->gop_qp_sum) {
339 tmp = MPP_DIV_SIGN(rc->gop_qp_sum, rc->gop_qp_div);
340 }
341 rc->gop_qp_sum = 0;
342 rc->gop_qp_div = 0;
343 }
344 if (tmp) {
345 rc->qp_hdr = tmp;
346 }
347 } else if (rc->prev_frame_intra) {
348 rc->qp_hdr = rc->qp_hdr_prev;
349 } else {
350 tmp_avg_rc_error = avg_rc_error(&rc->r_error);
351 tmp_value = axb_div_c(rc->target_pic_size - tmp_avg_rc_error,
352 256, rc->mb_per_pic);
353 rc->qp_hdr = new_pic_quant(&rc->lin_reg, tmp_value,
354 use_qp_delta_limit);
355 }
356
357 vp8e_rc_dbg_rc("frame_cnt = %d, qp = %d\n", rc->frame_cnt, rc->qp_hdr);
358
359 rc->qp_hdr = MPP_MIN(rc->qp_max, MPP_MAX(rc->qp_min, rc->qp_hdr));
360 rc->qp_hdr_prev = rc->qp_hdr;
361
362 if (rc->curr_frame_intra) {
363 if (rc->fixed_intra_qp)
364 rc->qp_hdr = rc->fixed_intra_qp;
365 else if (!rc->prev_frame_intra)
366 rc->qp_hdr += rc->intra_qp_delta;
367
368 rc->qp_hdr = MPP_MIN(rc->qp_max, MPP_MAX(rc->qp_min, rc->qp_hdr));
369 } else {
370 rc->gop_qp_sum += rc->qp_hdr;
371 rc->gop_qp_div++;
372 }
373
374 return MPP_OK;
375 }
376
update_tables(Vp8eLinReg * p,RK_S32 qp,RK_S32 bits)377 static void update_tables(Vp8eLinReg *p, RK_S32 qp, RK_S32 bits)
378 {
379 RK_S32 len = 10;
380 RK_S32 tmp = p->pos;
381
382 p->qp_prev = qp;
383 p->qs[tmp] = ac_q_lookup_tbl[qp];
384 p->bits[tmp] = bits;
385
386 if ((++p->pos) >= len) {
387 p->pos = 0;
388 }
389
390 if (p->len < len) {
391 p->len++;
392 }
393 }
394
vp8e_update_rc_cfg(Vp8eRc * rc,MppEncRcCfg * cfg)395 MPP_RET vp8e_update_rc_cfg(Vp8eRc *rc, MppEncRcCfg *cfg)
396 {
397 RK_U32 change = cfg->change;
398 Vp8eVirBuf *vb = &rc->virbuf;
399
400 if (change & MPP_ENC_RC_CFG_CHANGE_BPS) {
401 vp8e_rc_dbg_cfg("bps: %d [%d %d]\n",
402 cfg->bps_target, cfg->bps_min, cfg->bps_max);
403 vb->bps_min = cfg->bps_min;
404 vb->bps_max = cfg->bps_max;
405 vb->bit_rate = cfg->bps_target;
406 }
407
408 if (change & MPP_ENC_RC_CFG_CHANGE_FPS_OUT) {
409 vp8e_rc_dbg_cfg("fps: %d / %d\n", cfg->fps_out_num, cfg->fps_out_denorm);
410 rc->fps_out_num = cfg->fps_out_num;
411 rc->fps_out_denorm = cfg->fps_out_denorm;
412 if (rc->fps_out_denorm == 0) {
413 mpp_err("denorm can not be 0, change to default 1");
414 rc->fps_out_denorm = 1;
415 }
416 rc->fps_out = rc->fps_out_num / rc->fps_out_denorm;
417 if (rc->fps_out == 0) {
418 rc->fps_out = 30;
419 rc->fps_out_num = 30;
420 rc->fps_out_denorm = 1;
421 mpp_err("fps out can not be 0, change to default 30");
422 }
423 }
424
425 if ((change & MPP_ENC_RC_CFG_CHANGE_GOP) &&
426 (rc->gop_len != cfg->gop)) {
427 rc->gop_len = cfg->gop;
428 vp8e_rc_dbg_cfg("gop: %d\n", cfg->gop);
429 }
430 vb->bit_per_pic = axb_div_c(vb->bit_rate, rc->fps_out_denorm, rc->fps_out_num);
431
432 cfg->change = 0;
433
434 return MPP_OK;
435 }
436
437
vp8e_init_rc(Vp8eRc * rc,MppEncCfgSet * cfg)438 MPP_RET vp8e_init_rc(Vp8eRc *rc, MppEncCfgSet *cfg)
439 {
440 RK_S32 max_bps;
441 Vp8eVirBuf *vb = &rc->virbuf;
442
443 rc->qp_hdr = -1;
444 rc->qp_min = 0;
445 rc->qp_max = QINDEX_RANGE;
446 rc->pic_skip = 0;
447 rc->pic_rc_enable = 1;
448 rc->gop_len = cfg->rc.gop;
449 rc->intra_qp_delta = 0;
450 rc->fixed_intra_qp = 0;
451 rc->intra_picture_rate = 30;
452 rc->golden_picture_rate = 0;
453 rc->altref_picture_rate = 0;
454 rc->virbuf.bit_rate = cfg->rc.bps_target;
455 rc->fps_out_denorm = cfg->rc.fps_out_denorm;
456 rc->fps_out_num = cfg->rc.fps_out_num;
457 rc->mb_per_pic = ((cfg->prep.width + 15) / 16) * ((cfg->prep.height + 15) / 16);
458
459 if (rc->qp_max >= QINDEX_RANGE)
460 rc->qp_max = QINDEX_RANGE - 1;
461
462 if (rc->qp_min < 0)
463 rc->qp_min = 0;
464
465 max_bps = rc->mb_per_pic * 16 * 16 * 6;
466 max_bps = axb_div_c(max_bps, rc->fps_out_num,
467 rc->fps_out_denorm);
468
469 if (max_bps < 0)
470 max_bps = I32_MPP_MAX;
471 vb->bit_rate = MPP_MIN(vb->bit_rate, max_bps);
472 vb->bit_per_pic = axb_div_c(vb->bit_rate, rc->fps_out_denorm,
473 rc->fps_out_num);
474
475 if (rc->qp_hdr == -1)
476 rc->qp_hdr = initial_qp(vb->bit_per_pic, rc->mb_per_pic * 16 * 16);
477
478 rc->qp_hdr = MPP_MIN(rc->qp_max, MPP_MAX(rc->qp_min, rc->qp_hdr));
479 vp8e_rc_dbg_rc("init qp, qp = %d, bitRate = %d, bitPerPic = %d\n",
480 rc->qp_hdr, vb->bit_rate, vb->bit_per_pic);
481
482 rc->qp_hdr_prev = rc->qp_hdr;
483 rc->fixed_qp = rc->qp_hdr;
484 rc->frame_coded = 1;
485 rc->curr_frame_intra = 1;
486 rc->prev_frame_intra = 0;
487 rc->frame_cnt = 0;
488 rc->gop_qp_sum = 0;
489 rc->gop_qp_div = 0;
490 rc->target_pic_size = 0;
491 rc->frame_bit_cnt = 0;
492 rc->time_inc = 0;
493
494 memset(&rc->lin_reg, 0, sizeof(rc->lin_reg));
495 rc->lin_reg.qs[0] = ac_q_lookup_tbl[QINDEX_RANGE - 1];
496 rc->lin_reg.qp_prev = rc->qp_hdr;
497
498 vb->gop_rem = rc->gop_len;
499 vb->time_scale = rc->fps_out_num;
500
501 update_rc_error(&rc->r_error, RC_ERROR_RESET);
502
503 return MPP_OK;
504 }
505
vp8e_before_pic_rc(Vp8eRc * rc)506 MPP_RET vp8e_before_pic_rc(Vp8eRc *rc)
507 {
508 RK_S32 tmp = 0;
509 Vp8eVirBuf *vb = &rc->virbuf;
510
511 rc->frame_coded = 1;
512
513 if (rc->curr_frame_intra || vb->gop_rem == 1) {
514 vb->gop_rem = rc->gop_len;
515 } else {
516 vb->gop_rem--;
517 }
518
519 tmp = get_vir_buffer_bitcnt(&rc->virbuf, (RK_S32)rc->time_inc);
520
521 rc->target_pic_size = vb->bit_per_pic +
522 MPP_DIV_SIGN(tmp, MPP_MAX(vb->gop_rem, 3));
523 rc->target_pic_size = MPP_MAX(0, rc->target_pic_size);
524
525 if (rc->pic_skip)
526 skip_pic(rc);
527
528 cal_pic_quant(rc);
529
530 return MPP_OK;
531 }
532
vp8e_after_pic_rc(Vp8eRc * rc,RK_S32 bitcnt)533 MPP_RET vp8e_after_pic_rc(Vp8eRc *rc, RK_S32 bitcnt)
534 {
535 Vp8eVirBuf *vb = &rc->virbuf;
536
537 rc->time_inc = 1;
538 rc->frame_cnt++;
539 rc->frame_bit_cnt = bitcnt;
540 rc->prev_frame_intra = rc->curr_frame_intra;
541 vb->real_bit_cnt += bitcnt;
542
543 if ((!rc->curr_frame_intra) || (rc->gop_len == 1)) {
544 update_tables(&rc->lin_reg, rc->qp_hdr_prev,
545 axb_div_c(bitcnt, 256, rc->mb_per_pic));
546
547
548 if (vb->gop_rem == rc->gop_len - 1) {
549 update_rc_error(&rc->r_error, RC_ERROR_RESET);
550 } else {
551 update_rc_error(&rc->r_error,
552 MPP_MIN(bitcnt - rc->target_pic_size,
553 2 * rc->target_pic_size));
554 }
555 update_model(&rc->lin_reg);
556 }
557
558 return MPP_OK;
559 }
560