msm-vidc: update bw calculation for ar50LT

Update bw calculation formulas for ar50LT.

Change-Id: Ife2342304947f4108f908f7a5c56de24ad088b23
Signed-off-by: Dikshita Agarwal <dikshita@codeaurora.org>
This commit is contained in:
Dikshita Agarwal 2020-08-14 14:35:15 +05:30
commit b28387c5c4

View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2019, The Linux Foundation. All rights reserved.
* Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
*/
#include "msm_vidc_bus.h"
@ -9,33 +9,35 @@
static unsigned long __calculate_encoder(struct vidc_bus_vote_data *d)
{
/* Encoder Parameters */
int width, height, fps, bitrate, lcu_size;
int width, height, fps, bitrate, lcu_size, lcu_per_frame,
collocated_bytes_per_lcu, search_range_v, search_range_h,
vertical_tile_size, num_tiles;
/* Derived Parameter */
int search_range, lcu_per_frame;
unsigned int bins_to_bit_factor;
fp_t y_bw;
bool is_h264_category = true;
fp_t orig_read_factor, recon_write_factor,
ref_y_read_factor, ref_c_read_factor, lb_factor,
rest_factor, total_read_factor, total_write_factor,
total_factor, overhead_factor;
ref_y_read_factor, ref_c_read_factor, overhead_factor;
/* Output parameters */
fp_t orig_read, recon_write,
ref_y_read, ref_c_read,
lb_read, lb_write,
bse_read, bse_write,
total_read, total_write,
total;
ref_y_read, ref_c_read,
bse_lb_read, bse_lb_write,
collocated_read, collocated_write,
bitstream_read, bitstream_write,
total_read, total_write,
total;
unsigned long ret = 0;
/* Encoder Fixed Parameters */
/* Encoder Fixed Parameters setup */
search_range_h = 96;
search_range_v = 48;
bins_to_bit_factor = 4;
overhead_factor = FP(1, 3, 100);
orig_read_factor = FP(1, 50, 100); /* L + C */
recon_write_factor = FP(1, 50, 100); /* L + C */
ref_c_read_factor = FP(0, 75, 100); /* 1.5/2 ( 1.5 Cache efficiency )*/
lb_factor = FP(1, 25, 100); /* Worst case : HEVC 720p = 1.25 */
fps = d->fps;
width = max(d->output_width, BASELINE_DIMENSIONS.width);
@ -55,40 +57,46 @@ static unsigned long __calculate_encoder(struct vidc_bus_vote_data *d)
is_h264_category = false;
}
search_range = 48;
collocated_bytes_per_lcu = lcu_size == 16 ? 16 :
lcu_size == 32 ? 64 : 256;
if (width >= 1296 && width <= 1536)
vertical_tile_size = 768;
else
vertical_tile_size = 640;
num_tiles = DIV_ROUND_UP(width, vertical_tile_size);
y_bw = fp_mult(fp_mult(FP_INT(width), FP_INT(height)), FP_INT(fps));
y_bw = fp_div(y_bw, FP_INT(1000000));
y_bw = fp_div(y_bw, FP_INT(bps(1)));
ref_y_read_factor = fp_div(FP_INT(search_range * 2), FP_INT(lcu_size));
/* -1 for 1 less tile boundary penalty */
ref_y_read_factor = (num_tiles - 1) * 2;
ref_y_read_factor = fp_div(fp_mult(FP_INT(ref_y_read_factor),
FP_INT(search_range_h)), FP_INT(width));
ref_y_read_factor = ref_y_read_factor + FP_INT(1);
rest_factor = FP_INT(bitrate) + fp_div(FP_INT(bitrate), FP_INT(8));
rest_factor = fp_div(rest_factor, y_bw);
total_read_factor = fp_div(rest_factor, FP_INT(2)) +
fp_div(lb_factor, FP_INT(2));
total_read_factor = total_read_factor + orig_read_factor +
ref_y_read_factor + ref_c_read_factor;
total_write_factor = fp_div(rest_factor, FP_INT(2)) +
fp_div(lb_factor, FP_INT(2));
total_write_factor = total_write_factor + recon_write_factor;
total_factor = total_read_factor + total_write_factor;
orig_read = fp_mult(y_bw, orig_read_factor);
recon_write = fp_mult(y_bw, recon_write_factor);
ref_y_read = fp_mult(y_bw, ref_y_read_factor);
ref_c_read = fp_mult(y_bw, ref_c_read_factor);
lb_read = fp_div(fp_mult(y_bw, lb_factor), FP_INT(2));
lb_write = lb_read;
bse_read = fp_mult(y_bw, fp_div(rest_factor, FP_INT(2)));
bse_write = bse_read;
bse_lb_read = fp_div(FP_INT(16 * fps * lcu_per_frame),
FP_INT(bps(1)));
bse_lb_write = bse_lb_read;
collocated_read = fp_div(FP_INT(lcu_per_frame *
collocated_bytes_per_lcu * fps), FP_INT(bps(1)));
collocated_write = collocated_read;
bitstream_read = fp_mult(fp_div(FP_INT(bitrate), FP_INT(8)),
FP_INT(bins_to_bit_factor));
bitstream_write = fp_div(FP_INT(bitrate), FP_INT(8));
bitstream_write = bitstream_write + bitstream_read;
total_read = orig_read + ref_y_read + ref_c_read +
lb_read + bse_read;
total_write = recon_write + lb_write + bse_write;
bse_lb_read + collocated_read + bitstream_read;
total_write = recon_write + bse_lb_write +
collocated_write + bitstream_write;
total = total_read + total_write;
total = fp_mult(total, overhead_factor);
@ -101,20 +109,21 @@ static unsigned long __calculate_encoder(struct vidc_bus_vote_data *d)
{"fps", "%d", fps},
{"bitrate (Mbit/sec)", "%lu", bitrate},
{"lcu size", "%d", lcu_size},
{"collocated byter per lcu", "%d", collocated_bytes_per_lcu},
{"horizontal search range", "%d", search_range_h},
{"vertical search range", "%d", search_range_v},
{"bins to bit factor", "%d", bins_to_bit_factor},
{"DERIVED PARAMETERS", "", DUMP_HEADER_MAGIC},
{"lcu/frame", "%d", lcu_per_frame},
{"vertical tile size", "%d", vertical_tile_size},
{"number of tiles", "%d", num_tiles},
{"Y BW", DUMP_FP_FMT, y_bw},
{"search range", "%d", search_range},
{"original read factor", DUMP_FP_FMT, orig_read_factor},
{"recon write factor", DUMP_FP_FMT, recon_write_factor},
{"ref read Y factor", DUMP_FP_FMT, ref_y_read_factor},
{"ref read C factor", DUMP_FP_FMT, ref_c_read_factor},
{"lb factor", DUMP_FP_FMT, lb_factor},
{"rest factor", DUMP_FP_FMT, rest_factor},
{"total_read_factor", DUMP_FP_FMT, total_read_factor},
{"total_write_factor", DUMP_FP_FMT, total_write_factor},
{"total_factor", DUMP_FP_FMT, total_factor},
{"overhead_factor", DUMP_FP_FMT, overhead_factor},
{"INTERMEDIATE B/W DDR", "", DUMP_HEADER_MAGIC},
@ -122,10 +131,12 @@ static unsigned long __calculate_encoder(struct vidc_bus_vote_data *d)
{"recon write", DUMP_FP_FMT, recon_write},
{"ref read Y", DUMP_FP_FMT, ref_y_read},
{"ref read C", DUMP_FP_FMT, ref_c_read},
{"lb read", DUMP_FP_FMT, lb_read},
{"lb write", DUMP_FP_FMT, lb_write},
{"bse read", DUMP_FP_FMT, bse_read},
{"bse write", DUMP_FP_FMT, bse_write},
{"BSE lb read", DUMP_FP_FMT, bse_lb_read},
{"BSE lb write", DUMP_FP_FMT, bse_lb_write},
{"collocated read", DUMP_FP_FMT, collocated_read},
{"collocated write", DUMP_FP_FMT, collocated_write},
{"bitstream read", DUMP_FP_FMT, bitstream_read},
{"bitstream write", DUMP_FP_FMT, bitstream_write},
{"total read", DUMP_FP_FMT, total_read},
{"total write", DUMP_FP_FMT, total_write},
{"total", DUMP_FP_FMT, total},
@ -142,24 +153,24 @@ static unsigned long __calculate_encoder(struct vidc_bus_vote_data *d)
static unsigned long __calculate_decoder(struct vidc_bus_vote_data *d)
{
/* Decoder parameters */
int width, height, fps, bitrate, lcu_size;
int width, height, fps, bitrate, lcu_size,
lcu_per_frame, collocated_bytes_per_lcu,
motion_complexity;
/* Derived parameters */
int lcu_per_frame, motion_complexity;
unsigned int bins_to_bits_factor, vsp_read_factor;
fp_t y_bw;
bool is_h264_category = true;
fp_t recon_write_factor, ref_read_factor, lb_factor,
rest_factor, opb_factor,
total_read_factor, total_write_factor,
total_factor, overhead_factor;
fp_t recon_write_factor, ref_read_factor,
opb_factor, overhead_factor;
/* Output parameters */
fp_t opb_write, recon_write,
ref_read,
lb_read, lb_write,
bse_read, bse_write,
total_read, total_write,
total;
ref_read,
bse_lb_read, bse_lb_write,
collocated_read, collocated_write,
bitstream_read, bitstream_write,
total_read, total_write,
total;
unsigned long ret = 0;
@ -167,8 +178,9 @@ static unsigned long __calculate_decoder(struct vidc_bus_vote_data *d)
overhead_factor = FP(1, 3, 100);
recon_write_factor = FP(1, 50, 100); /* L + C */
opb_factor = FP(1, 50, 100); /* L + C */
lb_factor = FP(1, 13, 100); /* Worst case : H264 1080p = 1.125 */
motion_complexity = 5; /* worst case complexity */
bins_to_bits_factor = 4;
vsp_read_factor = 6;
fps = d->fps;
width = max(d->output_width, BASELINE_DIMENSIONS.width);
@ -188,35 +200,42 @@ static unsigned long __calculate_decoder(struct vidc_bus_vote_data *d)
is_h264_category = false;
}
collocated_bytes_per_lcu = lcu_size == 16 ? 16 :
lcu_size == 32 ? 64 : 256;
y_bw = fp_mult(fp_mult(FP_INT(width), FP_INT(height)), FP_INT(fps));
y_bw = fp_div(y_bw, FP_INT(1000000));
y_bw = fp_div(y_bw, FP_INT(bps(1)));
ref_read_factor = FP(1, 50, 100); /* L + C */
ref_read_factor = fp_mult(ref_read_factor, FP_INT(motion_complexity));
rest_factor = FP_INT(bitrate) + fp_div(FP_INT(bitrate), FP_INT(8));
rest_factor = fp_div(rest_factor, y_bw);
total_read_factor = fp_div(rest_factor, FP_INT(2)) +
fp_div(lb_factor, FP_INT(2));
total_read_factor = total_read_factor + ref_read_factor;
total_write_factor = fp_div(rest_factor, FP_INT(2));
total_write_factor = total_write_factor +
recon_write_factor + opb_factor;
total_factor = total_read_factor + total_write_factor;
recon_write = fp_mult(y_bw, recon_write_factor);
ref_read = fp_mult(y_bw, ref_read_factor);
lb_read = fp_div(fp_mult(y_bw, lb_factor), FP_INT(2));
lb_write = lb_read;
bse_read = fp_div(fp_mult(y_bw, rest_factor), FP_INT(2));
bse_write = bse_read;
if (d->codec == HAL_VIDEO_CODEC_HEVC)
bse_lb_read = FP_INT(lcu_size == 32 ? 64 :
lcu_size == 16 ? 32 : 128);
else
bse_lb_read = FP_INT(128);
bse_lb_read = fp_div(fp_mult(FP_INT(lcu_per_frame * fps), bse_lb_read),
FP_INT(bps(1)));
bse_lb_write = bse_lb_read;
collocated_read = fp_div(FP_INT(lcu_per_frame *
collocated_bytes_per_lcu * fps), FP_INT(bps(1)));
collocated_write = collocated_read;
bitstream_read = fp_mult(fp_div(FP_INT(bitrate), FP_INT(8)),
FP_INT(vsp_read_factor));
bitstream_write = fp_mult(fp_div(FP_INT(bitrate), FP_INT(8)),
FP_INT(bins_to_bits_factor));
opb_write = fp_mult(y_bw, opb_factor);
total_read = ref_read + lb_read + bse_read;
total_write = recon_write + lb_write + bse_write + opb_write;
total_read = ref_read + bse_lb_read + collocated_read +
bitstream_read;
total_write = recon_write + bse_lb_write + bitstream_write +
opb_write;
total = total_read + total_write;
total = fp_mult(total, overhead_factor);
@ -229,28 +248,28 @@ static unsigned long __calculate_decoder(struct vidc_bus_vote_data *d)
{"fps", "%d", fps},
{"bitrate (Mbit/sec)", "%lu", bitrate},
{"lcu size", "%d", lcu_size},
{"collocated byter per lcu", "%d", collocated_bytes_per_lcu},
{"vsp read factor", "%d", vsp_read_factor},
{"bins to bits factor", "%d", bins_to_bits_factor},
{"motion complexity", "%d", motion_complexity},
{"DERIVED PARAMETERS", "", DUMP_HEADER_MAGIC},
{"lcu/frame", "%d", lcu_per_frame},
{"Y BW", DUMP_FP_FMT, y_bw},
{"motion complexity", "%d", motion_complexity},
{"recon write factor", DUMP_FP_FMT, recon_write_factor},
{"ref_read_factor", DUMP_FP_FMT, ref_read_factor},
{"lb factor", DUMP_FP_FMT, lb_factor},
{"rest factor", DUMP_FP_FMT, rest_factor},
{"opb factor", DUMP_FP_FMT, opb_factor},
{"total_read_factor", DUMP_FP_FMT, total_read_factor},
{"total_write_factor", DUMP_FP_FMT, total_write_factor},
{"total_factor", DUMP_FP_FMT, total_factor},
{"overhead_factor", DUMP_FP_FMT, overhead_factor},
{"INTERMEDIATE B/W DDR", "", DUMP_HEADER_MAGIC},
{"recon write", DUMP_FP_FMT, recon_write},
{"ref read", DUMP_FP_FMT, ref_read},
{"lb read", DUMP_FP_FMT, lb_read},
{"lb write", DUMP_FP_FMT, lb_write},
{"bse read", DUMP_FP_FMT, bse_read},
{"bse write", DUMP_FP_FMT, bse_write},
{"BSE lb read", DUMP_FP_FMT, bse_lb_read},
{"BSE lb write", DUMP_FP_FMT, bse_lb_write},
{"collocated read", DUMP_FP_FMT, collocated_read},
{"collocated write", DUMP_FP_FMT, collocated_write},
{"bitstream read", DUMP_FP_FMT, bitstream_read},
{"bitstream write", DUMP_FP_FMT, bitstream_write},
{"opb write", DUMP_FP_FMT, opb_write},
{"total read", DUMP_FP_FMT, total_read},
{"total write", DUMP_FP_FMT, total_write},