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

Commit ed24a007 authored by Maheshwar Ajja's avatar Maheshwar Ajja
Browse files

msm: vidc: add platform specific capabilities



Add platform specific capabilities and use them
in place of firmware capabilities.

Change-Id: I58e34aefe7594c701e261c8c5ec3f98f1fb7f2bd
Signed-off-by: default avatarMaheshwar Ajja <majja@codeaurora.org>
parent 00474817
Loading
Loading
Loading
Loading
+0 −661
Original line number Diff line number Diff line
@@ -15,11 +15,6 @@
#include "msm_vidc_debug.h"
#include "vidc_hfi.h"

static enum vidc_status hfi_parse_init_done_properties(
		struct msm_vidc_capability *capability,
		u32 num_sessions, u8 *data_ptr, u32 num_properties,
		u32 rem_bytes);

static enum vidc_status hfi_map_err_status(u32 hfi_err)
{
	enum vidc_status vidc_err;
@@ -469,662 +464,6 @@ static int hfi_process_sys_rel_resource_done(u32 device_id,
	return 0;
}

enum hal_capability get_hal_cap_type(u32 capability_type)
{
	enum hal_capability hal_cap = 0;

	switch (capability_type) {
	case HFI_CAPABILITY_FRAME_WIDTH:
		hal_cap = HAL_CAPABILITY_FRAME_WIDTH;
		break;
	case HFI_CAPABILITY_FRAME_HEIGHT:
		hal_cap = HAL_CAPABILITY_FRAME_HEIGHT;
		break;
	case HFI_CAPABILITY_MBS_PER_FRAME:
		hal_cap = HAL_CAPABILITY_MBS_PER_FRAME;
		break;
	case HFI_CAPABILITY_MBS_PER_SECOND:
		hal_cap = HAL_CAPABILITY_MBS_PER_SECOND;
		break;
	case HFI_CAPABILITY_FRAMERATE:
		hal_cap = HAL_CAPABILITY_FRAMERATE;
		break;
	case HFI_CAPABILITY_SCALE_X:
		hal_cap = HAL_CAPABILITY_SCALE_X;
		break;
	case HFI_CAPABILITY_SCALE_Y:
		hal_cap = HAL_CAPABILITY_SCALE_Y;
		break;
	case HFI_CAPABILITY_BITRATE:
		hal_cap = HAL_CAPABILITY_BITRATE;
		break;
	case HFI_CAPABILITY_BFRAME:
		hal_cap = HAL_CAPABILITY_BFRAME;
		break;
	case HFI_CAPABILITY_PEAKBITRATE:
		hal_cap = HAL_CAPABILITY_PEAKBITRATE;
		break;
	case HFI_CAPABILITY_HIER_P_NUM_ENH_LAYERS:
		hal_cap = HAL_CAPABILITY_HIER_P_NUM_ENH_LAYERS;
		break;
	case HFI_CAPABILITY_ENC_LTR_COUNT:
		hal_cap = HAL_CAPABILITY_ENC_LTR_COUNT;
		break;
	case HFI_CAPABILITY_CP_OUTPUT2_THRESH:
		hal_cap = HAL_CAPABILITY_SECURE_OUTPUT2_THRESHOLD;
		break;
	case HFI_CAPABILITY_HIER_B_NUM_ENH_LAYERS:
		hal_cap = HAL_CAPABILITY_HIER_B_NUM_ENH_LAYERS;
		break;
	case HFI_CAPABILITY_LCU_SIZE:
		hal_cap = HAL_CAPABILITY_LCU_SIZE;
		break;
	case HFI_CAPABILITY_HIER_P_HYBRID_NUM_ENH_LAYERS:
		hal_cap = HAL_CAPABILITY_HIER_P_HYBRID_NUM_ENH_LAYERS;
		break;
	case HFI_CAPABILITY_MBS_PER_SECOND_POWERSAVE:
		hal_cap = HAL_CAPABILITY_MBS_PER_SECOND_POWER_SAVE;
		break;
	case HFI_CAPABILITY_EXTRADATA:
		hal_cap = HAL_CAPABILITY_EXTRADATA;
		break;
	case HFI_CAPABILITY_PROFILE:
		hal_cap = HAL_CAPABILITY_PROFILE;
		break;
	case HFI_CAPABILITY_LEVEL:
		hal_cap = HAL_CAPABILITY_LEVEL;
		break;
	case HFI_CAPABILITY_I_FRAME_QP:
		hal_cap = HAL_CAPABILITY_I_FRAME_QP;
		break;
	case HFI_CAPABILITY_P_FRAME_QP:
		hal_cap = HAL_CAPABILITY_P_FRAME_QP;
		break;
	case HFI_CAPABILITY_B_FRAME_QP:
		hal_cap = HAL_CAPABILITY_B_FRAME_QP;
		break;
	case HFI_CAPABILITY_RATE_CONTROL_MODES:
		hal_cap = HAL_CAPABILITY_RATE_CONTROL_MODES;
		break;
	case HFI_CAPABILITY_BLUR_WIDTH:
		hal_cap = HAL_CAPABILITY_BLUR_WIDTH;
		break;
	case HFI_CAPABILITY_BLUR_HEIGHT:
		hal_cap = HAL_CAPABILITY_BLUR_HEIGHT;
		break;
	case HFI_CAPABILITY_SLICE_BYTE:
		hal_cap = HAL_CAPABILITY_SLICE_BYTE;
		break;
	case HFI_CAPABILITY_SLICE_MB:
		hal_cap = HAL_CAPABILITY_SLICE_MB;
		break;
	case HFI_CAPABILITY_SECURE:
		hal_cap = HAL_CAPABILITY_SECURE;
		break;
	case HFI_CAPABILITY_MAX_NUM_B_FRAMES:
		hal_cap = HAL_CAPABILITY_MAX_NUM_B_FRAMES;
		break;
	case HFI_CAPABILITY_MAX_VIDEOCORES:
		hal_cap = HAL_CAPABILITY_MAX_VIDEOCORES;
		break;
	case HFI_CAPABILITY_MAX_WORKMODES:
		hal_cap = HAL_CAPABILITY_MAX_WORKMODES;
		break;
	case HFI_CAPABILITY_UBWC_CR_STATS:
		hal_cap = HAL_CAPABILITY_UBWC_CR_STATS;
		break;
	default:
		dprintk(VIDC_DBG, "%s: unknown capablity %#x\n",
			__func__, capability_type);
		break;
	}

	return hal_cap;
}

static inline void copy_cap_prop(
		struct hfi_capability_supported *in,
		struct msm_vidc_capability *capability)
{
	struct hal_capability_supported *out = NULL;

	if (!in || !capability) {
		dprintk(VIDC_ERR, "%s Invalid input parameters\n",
			__func__);
		return;
	}

	switch (in->capability_type) {
	case HFI_CAPABILITY_FRAME_WIDTH:
		out = &capability->width;
		break;
	case HFI_CAPABILITY_FRAME_HEIGHT:
		out = &capability->height;
		break;
	case HFI_CAPABILITY_MBS_PER_FRAME:
		out = &capability->mbs_per_frame;
		break;
	case HFI_CAPABILITY_MBS_PER_SECOND:
		out = &capability->mbs_per_sec;
		break;
	case HFI_CAPABILITY_FRAMERATE:
		out = &capability->frame_rate;
		break;
	case HFI_CAPABILITY_SCALE_X:
		out = &capability->scale_x;
		break;
	case HFI_CAPABILITY_SCALE_Y:
		out = &capability->scale_y;
		break;
	case HFI_CAPABILITY_BITRATE:
		out = &capability->bitrate;
		break;
	case HFI_CAPABILITY_BFRAME:
		out = &capability->bframe;
		break;
	case HFI_CAPABILITY_HIER_P_NUM_ENH_LAYERS:
		out = &capability->hier_p;
		break;
	case HFI_CAPABILITY_ENC_LTR_COUNT:
		out = &capability->ltr_count;
		break;
	case HFI_CAPABILITY_CP_OUTPUT2_THRESH:
		out = &capability->secure_output2_threshold;
		break;
	case HFI_CAPABILITY_HIER_B_NUM_ENH_LAYERS:
		out = &capability->hier_b;
		break;
	case HFI_CAPABILITY_LCU_SIZE:
		out = &capability->lcu_size;
		break;
	case HFI_CAPABILITY_HIER_P_HYBRID_NUM_ENH_LAYERS:
		out = &capability->hier_p_hybrid;
		break;
	case HFI_CAPABILITY_MBS_PER_SECOND_POWERSAVE:
		out = &capability->mbs_per_sec_power_save;
		break;
	case HFI_CAPABILITY_EXTRADATA:
		out = &capability->extradata;
		break;
	case HFI_CAPABILITY_PROFILE:
		out = &capability->profile;
		break;
	case HFI_CAPABILITY_LEVEL:
		out = &capability->level;
		break;
	case HFI_CAPABILITY_I_FRAME_QP:
		out = &capability->i_qp;
		break;
	case HFI_CAPABILITY_P_FRAME_QP:
		out = &capability->p_qp;
		break;
	case HFI_CAPABILITY_B_FRAME_QP:
		out = &capability->b_qp;
		break;
	case HFI_CAPABILITY_RATE_CONTROL_MODES:
		out = &capability->rc_modes;
		break;
	case HFI_CAPABILITY_BLUR_WIDTH:
		out = &capability->blur_width;
		break;
	case HFI_CAPABILITY_BLUR_HEIGHT:
		out = &capability->blur_height;
		break;
	case HFI_CAPABILITY_SLICE_BYTE:
		out = &capability->slice_bytes;
		break;
	case HFI_CAPABILITY_SLICE_MB:
		out = &capability->slice_mbs;
		break;
	case HFI_CAPABILITY_SECURE:
		out = &capability->secure;
		break;
	case HFI_CAPABILITY_MAX_NUM_B_FRAMES:
		out = &capability->max_num_b_frames;
		break;
	case HFI_CAPABILITY_MAX_VIDEOCORES:
		out = &capability->max_video_cores;
		break;
	case HFI_CAPABILITY_MAX_WORKMODES:
		out = &capability->max_work_modes;
		break;
	case HFI_CAPABILITY_UBWC_CR_STATS:
		out = &capability->ubwc_cr_stats;
		break;
	default:
		dprintk(VIDC_DBG, "%s: unknown capablity %#x\n",
			__func__, in->capability_type);
		break;
	}

	if (out) {
		out->capability_type = get_hal_cap_type(in->capability_type);
		out->min = in->min;
		out->max = in->max;
		out->step_size = in->step_size;
	}
}

static int hfi_fill_codec_info(u8 *data_ptr,
		struct vidc_hal_sys_init_done *sys_init_done)
{
	u32 i;
	u32 codecs = 0, codec_count = 0, size = 0;
	struct msm_vidc_capability *capability;
	u32 prop_id = *((u32 *)data_ptr);
	u8 *orig_data_ptr = data_ptr;

	if (prop_id ==  HFI_PROPERTY_PARAM_CODEC_SUPPORTED) {
		struct hfi_codec_supported *prop;

		data_ptr = data_ptr + sizeof(u32);
		prop = (struct hfi_codec_supported *) data_ptr;
		sys_init_done->dec_codec_supported =
			prop->decoder_codec_supported;
		sys_init_done->enc_codec_supported =
			prop->encoder_codec_supported;
		size = sizeof(struct hfi_codec_supported) + sizeof(u32);
	} else {
		dprintk(VIDC_WARN,
			"%s: prop_id %#x, expected codec_supported property\n",
			__func__, prop_id);
	}

	codecs = sys_init_done->dec_codec_supported;
	for (i = 0; i < 8 * sizeof(codecs); i++) {
		if ((1 << i) & codecs) {
			if (codec_count >= VIDC_MAX_SESSIONS) {
				dprintk(VIDC_ERR,
					"%s: codec count exceeding max sessions %d\n",
					__func__, VIDC_MAX_SESSIONS);
				break;
			}

			capability =
				&sys_init_done->capabilities[codec_count++];
			capability->codec =
				vidc_get_hal_codec((1 << i) & codecs);
			capability->domain =
				vidc_get_hal_domain(HFI_VIDEO_DOMAIN_DECODER);
		}
	}

	codecs = sys_init_done->enc_codec_supported;
	for (i = 0; i < 8 * sizeof(codecs); i++) {
		if ((1 << i) & codecs) {
			if (codec_count >= VIDC_MAX_SESSIONS) {
				dprintk(VIDC_ERR,
					"%s: codec count exceeding max sessions %d\n",
					__func__, VIDC_MAX_SESSIONS);
				break;
			}

			capability =
				&sys_init_done->capabilities[codec_count++];
			capability->codec =
				vidc_get_hal_codec((1 << i) & codecs);
			capability->domain =
				vidc_get_hal_domain(HFI_VIDEO_DOMAIN_ENCODER);
		}
	}
	sys_init_done->codec_count = codec_count;

	prop_id = *((u32 *)(orig_data_ptr + size));
	if (prop_id == HFI_PROPERTY_PARAM_MAX_SESSIONS_SUPPORTED) {
		struct hfi_max_sessions_supported *prop =
			(struct hfi_max_sessions_supported *)
			(orig_data_ptr + size + sizeof(u32));

		sys_init_done->max_sessions_supported = prop->max_sessions;
		size += sizeof(struct hfi_max_sessions_supported) + sizeof(u32);
		dprintk(VIDC_DBG, "max_sessions_supported %d\n",
				prop->max_sessions);
	}
	return size;
}

static int copy_profile_caps_to_sessions(struct hfi_profile_level *prof,
		u32 profile_count, struct msm_vidc_capability *capabilities,
		u32 num_sessions, u32 codecs, u32 domain)
{
	u32 i = 0, j = 0;
	struct msm_vidc_capability *capability;
	u32 sess_codec;
	u32 sess_domain;

	/*
	 * iterate over num_sessions and copy all the profile capabilities
	 * to matching sessions.
	 */
	for (i = 0; i < num_sessions; i++) {
		sess_codec = 0;
		sess_domain = 0;
		capability = &capabilities[i];

		if (capability->codec)
			sess_codec =
				vidc_get_hfi_codec(capability->codec);
		if (capability->domain)
			sess_domain =
				vidc_get_hfi_domain(capability->domain);

		if (!(sess_codec & codecs && sess_domain & domain))
			continue;

		capability->profile_level.profile_count = profile_count;
		for (j = 0; j < profile_count; j++) {
			/* HFI and HAL follow same enums, hence no conversion */
			capability->profile_level.profile_level[j].profile =
				prof[j].profile;
			capability->profile_level.profile_level[j].level =
				prof[j].level;
		}
	}

	return 0;
}

static int copy_caps_to_sessions(struct hfi_capability_supported *cap,
		u32 num_caps, struct msm_vidc_capability *capabilities,
		u32 num_sessions, u32 codecs, u32 domain)
{
	u32 i = 0, j = 0;
	struct msm_vidc_capability *capability;
	u32 sess_codec;
	u32 sess_domain;

	/*
	 * iterate over num_sessions and copy all the capabilities
	 * to matching sessions.
	 */
	for (i = 0; i < num_sessions; i++) {
		sess_codec = 0;
		sess_domain = 0;
		capability = &capabilities[i];

		if (capability->codec)
			sess_codec =
				vidc_get_hfi_codec(capability->codec);
		if (capability->domain)
			sess_domain =
				vidc_get_hfi_domain(capability->domain);

		if (!(sess_codec & codecs && sess_domain & domain))
			continue;

		for (j = 0; j < num_caps; j++)
			copy_cap_prop(&cap[j], capability);
	}

	return 0;
}

static int copy_nal_stream_format_caps_to_sessions(u32 nal_stream_format_value,
		struct msm_vidc_capability *capabilities, u32 num_sessions,
		u32 codecs, u32 domain)
{
	u32 i = 0;
	struct msm_vidc_capability *capability;
	u32 sess_codec;
	u32 sess_domain;

	for (i = 0; i < num_sessions; i++) {
		sess_codec = 0;
		sess_domain = 0;
		capability = &capabilities[i];

		if (capability->codec)
			sess_codec =
				vidc_get_hfi_codec(capability->codec);
		if (capability->domain)
			sess_domain =
				vidc_get_hfi_domain(capability->domain);

		if (!(sess_codec & codecs && sess_domain & domain))
			continue;

		capability->nal_stream_format.nal_stream_format_supported =
				nal_stream_format_value;
	}

	return 0;
}

static enum vidc_status hfi_parse_init_done_properties(
		struct msm_vidc_capability *capabilities,
		u32 num_sessions, u8 *data_ptr, u32 num_properties,
		u32 rem_bytes)
{
	enum vidc_status status = VIDC_ERR_NONE;
	u32 prop_id, next_offset;
	u32 codecs = 0, domain = 0;

	while (status == VIDC_ERR_NONE && num_properties &&
			rem_bytes >= sizeof(u32)) {

		prop_id = *((u32 *)data_ptr);
		next_offset = sizeof(u32);

		switch (prop_id) {
		case HFI_PROPERTY_PARAM_CODEC_MASK_SUPPORTED:
		{
			struct hfi_codec_mask_supported *prop =
				(struct hfi_codec_mask_supported *)
				(data_ptr + next_offset);

			codecs = prop->codecs;
			domain = prop->video_domains;
			next_offset += sizeof(struct hfi_codec_mask_supported);
			num_properties--;
			break;
		}
		case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED:
		{
			struct hfi_capability_supported_info *prop =
				(struct hfi_capability_supported_info *)
				(data_ptr + next_offset);

			if ((rem_bytes - next_offset) < prop->num_capabilities *
				sizeof(struct hfi_capability_supported)) {
				status = VIDC_ERR_BAD_PARAM;
				break;
			}
			next_offset += sizeof(u32) +
				prop->num_capabilities *
				sizeof(struct hfi_capability_supported);

			copy_caps_to_sessions(&prop->rg_data[0],
					prop->num_capabilities,
					capabilities, num_sessions,
					codecs, domain);
			num_properties--;
			break;
		}
		case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:
		{
			struct hfi_uncompressed_format_supported *prop =
				(struct hfi_uncompressed_format_supported *)
				(data_ptr + next_offset);
			u32 num_format_entries;
			char *fmt_ptr;
			struct hfi_uncompressed_plane_info *plane_info;

			if ((rem_bytes - next_offset) < sizeof(*prop)) {
				status = VIDC_ERR_BAD_PARAM;
				break;
			}
			num_format_entries = prop->format_entries;
			next_offset = sizeof(*prop);
			fmt_ptr = (char *)&prop->rg_format_info[0];

			while (num_format_entries) {
				u32 bytes_to_skip;

				plane_info =
				(struct hfi_uncompressed_plane_info *) fmt_ptr;

				if ((rem_bytes - next_offset) <
						sizeof(*plane_info)) {
					status = VIDC_ERR_BAD_PARAM;
					break;
				}
				bytes_to_skip = sizeof(*plane_info) -
					sizeof(struct
					hfi_uncompressed_plane_constraints) +
					plane_info->num_planes *
					sizeof(struct
					hfi_uncompressed_plane_constraints);

				fmt_ptr += bytes_to_skip;
				next_offset += bytes_to_skip;
				num_format_entries--;
			}
			num_properties--;
			break;
		}
		case HFI_PROPERTY_PARAM_PROPERTIES_SUPPORTED:
		{
			struct hfi_properties_supported *prop =
				(struct hfi_properties_supported *)
				(data_ptr + next_offset);
			next_offset += sizeof(*prop) - sizeof(u32)
				+ prop->num_properties * sizeof(u32);
			num_properties--;
			break;
		}
		case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED:
		{
			struct hfi_profile_level_supported *prop =
				(struct hfi_profile_level_supported *)
				(data_ptr + next_offset);

			next_offset += sizeof(u32) +
				prop->profile_count *
				sizeof(struct hfi_profile_level);

			if (prop->profile_count > MAX_PROFILE_COUNT) {
				prop->profile_count = MAX_PROFILE_COUNT;
				dprintk(VIDC_WARN,
					"prop count exceeds max profile count\n");
				break;
			}

			copy_profile_caps_to_sessions(
					&prop->rg_profile_level[0],
					prop->profile_count, capabilities,
					num_sessions, codecs, domain);
			num_properties--;
			break;
		}
		case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SUPPORTED:
		{
			struct hfi_nal_stream_format_supported *prop =
				(struct hfi_nal_stream_format_supported *)
					(data_ptr + next_offset);

			copy_nal_stream_format_caps_to_sessions(
					prop->nal_stream_format_supported,
					capabilities, num_sessions,
					codecs, domain);

			next_offset +=
				sizeof(struct hfi_nal_stream_format_supported);
			num_properties--;
			break;
		}
		case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SELECT:
		{
			next_offset += sizeof(u32);
			num_properties--;
			break;
		}
		case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH:
		{
			next_offset +=
				sizeof(struct hfi_intra_refresh);
			num_properties--;
			break;
		}
		case HFI_PROPERTY_TME_VERSION_SUPPORTED:
		{
			capabilities->tme_version =
				*((u32 *)(data_ptr + next_offset));
			next_offset +=
				sizeof(u32);
			num_properties--;
			break;
		}
		default:
			dprintk(VIDC_DBG,
				"%s: default case - data_ptr %pK, prop_id 0x%x\n",
				__func__, data_ptr, prop_id);
			break;
		}
		rem_bytes -= next_offset;
		data_ptr += next_offset;
	}

	return status;
}

enum vidc_status hfi_process_sys_init_done_prop_read(
	struct hfi_msg_sys_init_done_packet *pkt,
	struct vidc_hal_sys_init_done *sys_init_done)
{
	enum vidc_status status = VIDC_ERR_NONE;
	u32 rem_bytes, bytes_read, num_properties;
	u8 *data_ptr;

	if (!pkt || !sys_init_done) {
		dprintk(VIDC_ERR,
			"hfi_msg_sys_init_done: Invalid input\n");
		return VIDC_ERR_FAIL;
	}

	rem_bytes = pkt->size - sizeof(struct
			hfi_msg_sys_init_done_packet) + sizeof(u32);

	if (!rem_bytes) {
		dprintk(VIDC_ERR,
			"hfi_msg_sys_init_done: missing_prop_info\n");
		return VIDC_ERR_FAIL;
	}

	status = hfi_map_err_status(pkt->error_type);
	if (status) {
		dprintk(VIDC_ERR, "%s: status %#x\n", __func__, status);
		return status;
	}

	data_ptr = (u8 *) &pkt->rg_property_data[0];
	num_properties = pkt->num_properties;
	dprintk(VIDC_DBG,
		"%s: data_start %pK, num_properties %#x\n",
		__func__, data_ptr, num_properties);
	if (!num_properties) {
		sys_init_done->capabilities = NULL;
		dprintk(VIDC_DBG,
			"Venus didn't set any properties in SYS_INIT_DONE");
		return status;
	}
	bytes_read = hfi_fill_codec_info(data_ptr, sys_init_done);
	data_ptr += bytes_read;
	rem_bytes -= bytes_read;
	num_properties--;

	status = hfi_parse_init_done_properties(
			sys_init_done->capabilities,
			VIDC_MAX_SESSIONS, data_ptr, num_properties,
			rem_bytes);
	if (status) {
		dprintk(VIDC_ERR, "%s: parse status %#x\n",
			__func__, status);
		return status;
	}

	return status;
}

static void hfi_process_sess_get_prop_buf_req(
	struct hfi_msg_session_property_info_packet *prop,
	struct buffer_requirements *buffreq)
+1 −13
Original line number Diff line number Diff line
@@ -763,12 +763,6 @@ int msm_vdec_inst_init(struct msm_vidc_inst *inst)
	inst->prop.width[CAPTURE_PORT] = DEFAULT_WIDTH;
	inst->prop.height[OUTPUT_PORT] = DEFAULT_HEIGHT;
	inst->prop.width[OUTPUT_PORT] = DEFAULT_WIDTH;
	inst->capability.height.min = MIN_SUPPORTED_HEIGHT;
	inst->capability.height.max = DEFAULT_HEIGHT;
	inst->capability.width.min = MIN_SUPPORTED_WIDTH;
	inst->capability.width.max = DEFAULT_WIDTH;
	inst->capability.secure_output2_threshold.min = 0;
	inst->capability.secure_output2_threshold.max = 0;
	inst->buffer_mode_set[OUTPUT_PORT] = HAL_BUFFER_MODE_STATIC;
	inst->buffer_mode_set[CAPTURE_PORT] = HAL_BUFFER_MODE_DYNAMIC;
	inst->stream_output_mode = HAL_VIDEO_DECODER_PRIMARY;
@@ -909,13 +903,7 @@ int msm_vdec_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl)
			inst->flags |= VIDC_REALTIME;
		break;
	case V4L2_CID_MPEG_VIDC_VIDEO_OPERATING_RATE:
		if (((ctrl->val >> 16) < inst->capability.frame_rate.min ||
			(ctrl->val >> 16) > inst->capability.frame_rate.max) &&
			ctrl->val != INT_MAX) {
			dprintk(VIDC_ERR, "Invalid operating rate %u\n",
				(ctrl->val >> 16));
			rc = -ENOTSUPP;
		} else if (ctrl->val == INT_MAX) {
		if (ctrl->val == INT_MAX) {
			dprintk(VIDC_DBG,
				"inst(%pK) Request for turbo mode\n", inst);
			inst->clk_data.turbo_mode = true;
+4 −16
Original line number Diff line number Diff line
@@ -1068,16 +1068,9 @@ int msm_venc_inst_init(struct msm_vidc_inst *inst)
	inst->prop.height[OUTPUT_PORT] = DEFAULT_HEIGHT;
	inst->prop.width[OUTPUT_PORT] = DEFAULT_WIDTH;
	inst->prop.bframe_changed = false;
	inst->capability.height.min = MIN_SUPPORTED_HEIGHT;
	inst->capability.height.max = DEFAULT_HEIGHT;
	inst->capability.width.min = MIN_SUPPORTED_WIDTH;
	inst->capability.width.max = DEFAULT_WIDTH;
	inst->capability.secure_output2_threshold.min = 0;
	inst->capability.secure_output2_threshold.max = 0;
	inst->buffer_mode_set[OUTPUT_PORT] = HAL_BUFFER_MODE_DYNAMIC;
	inst->buffer_mode_set[CAPTURE_PORT] = HAL_BUFFER_MODE_STATIC;
	inst->clk_data.frame_rate = (DEFAULT_FPS << 16);
	inst->capability.pixelprocess_capabilities = 0;

	inst->bufq[OUTPUT_PORT].num_planes = 2;
	inst->bufq[CAPTURE_PORT].num_planes = 1;
@@ -1497,13 +1490,7 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl)
		}
		break;
	case V4L2_CID_MPEG_VIDC_VIDEO_OPERATING_RATE:
		if (((ctrl->val >> 16) < inst->capability.frame_rate.min ||
			(ctrl->val >> 16) > inst->capability.frame_rate.max) &&
			ctrl->val != INT_MAX) {
			dprintk(VIDC_ERR, "Invalid operating rate %u\n",
				(ctrl->val >> 16));
			rc = -ENOTSUPP;
		} else if (ctrl->val == INT_MAX) {
		if (ctrl->val == INT_MAX) {
			dprintk(VIDC_DBG, "inst(%pK) Request for turbo mode\n",
				inst);
			inst->clk_data.turbo_mode = true;
@@ -3435,9 +3422,10 @@ int msm_venc_set_ltr_mode(struct msm_vidc_inst *inst)
	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_LTRCOUNT);
	if (!ctrl->val)
		return 0;
	if (ctrl->val > inst->capability.ltr_count.max) {
	if (ctrl->val > inst->capability.cap[CAP_LTR_COUNT].max) {
		dprintk(VIDC_ERR, "%s: invalid ltr count %d, max %d\n",
			__func__, ctrl->val, inst->capability.ltr_count.max);
			__func__, ctrl->val,
			inst->capability.cap[CAP_LTR_COUNT].max);
		return -EINVAL;
	}
	ltr.ltr_count =  ctrl->val;
+31 −90

File changed.

Preview size limit exceeded, changes collapsed.

+1 −1
Original line number Diff line number Diff line
@@ -759,7 +759,7 @@ u32 msm_vidc_calculate_dec_input_frame_size(struct msm_vidc_inst *inst)
	num_mbs = ((width + 15) >> 4) * ((height + 15) >> 4);
	if (num_mbs > NUM_MBS_4k) {
		div_factor = 4;
		base_res_mbs = inst->capability.mbs_per_frame.max;
		base_res_mbs = inst->capability.cap[CAP_MBS_PER_FRAME].max;
	} else {
		base_res_mbs = NUM_MBS_4k;
		if (inst->fmts[OUTPUT_PORT].fourcc == V4L2_PIX_FMT_VP9)
Loading