Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b28387c5 authored by Dikshita Agarwal's avatar Dikshita Agarwal
Browse files

msm-vidc: update bw calculation for ar50LT 



Update bw calculation formulas for ar50LT.

Change-Id: Ife2342304947f4108f908f7a5c56de24ad088b23
Signed-off-by: default avatarDikshita Agarwal <dikshita@codeaurora.org>
parent 583ad02d

msm/vidc/msm_vidc_bus_ar50lite.c

+107 −88
Original line number Diff line number Diff line 
// 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,

		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,22 +153,22 @@ 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,

		bse_lb_read, bse_lb_write,

		collocated_read, collocated_write,

		bitstream_read, bitstream_write,

		total_read, total_write,

		total;
@@ -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);

	recon_write = fp_mult(y_bw, recon_write_factor);

	ref_read = fp_mult(y_bw, ref_read_factor);



	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;

	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;



	total_write_factor = fp_div(rest_factor, FP_INT(2));

	total_write_factor = total_write_factor +

		recon_write_factor + opb_factor;

	collocated_read = fp_div(FP_INT(lcu_per_frame *

		collocated_bytes_per_lcu * fps), FP_INT(bps(1)));

	collocated_write = collocated_read;



	total_factor = total_read_factor + total_write_factor;

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



	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;

	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},