in drivers/media/platform/msm/vidc/hfi_packetization.c [1114:2241]
int create_pkt_cmd_session_set_property(
struct hfi_cmd_session_set_property_packet *pkt,
struct hal_session *session,
enum hal_property ptype, void *pdata)
{
int rc = 0;
if (!pkt || !session)
return -EINVAL;
pkt->size = sizeof(struct hfi_cmd_session_set_property_packet);
pkt->packet_type = HFI_CMD_SESSION_SET_PROPERTY;
pkt->session_id = hash32_ptr(session);
pkt->num_properties = 1;
switch (ptype) {
case HAL_CONFIG_FRAME_RATE:
{
u32 buffer_type;
struct hfi_frame_rate *hfi;
struct hal_frame_rate *prop = (struct hal_frame_rate *) pdata;
pkt->rg_property_data[0] = HFI_PROPERTY_CONFIG_FRAME_RATE;
hfi = (struct hfi_frame_rate *) &pkt->rg_property_data[1];
buffer_type = get_hfi_buffer(prop->buffer_type);
if (buffer_type)
hfi->buffer_type = buffer_type;
else
return -EINVAL;
hfi->frame_rate = prop->frame_rate;
pkt->size += sizeof(u32) + sizeof(struct hfi_frame_rate);
break;
}
case HAL_PARAM_UNCOMPRESSED_FORMAT_SELECT:
{
u32 buffer_type;
struct hfi_uncompressed_format_select *hfi;
struct hal_uncompressed_format_select *prop =
(struct hal_uncompressed_format_select *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT;
hfi = (struct hfi_uncompressed_format_select *)
&pkt->rg_property_data[1];
buffer_type = get_hfi_buffer(prop->buffer_type);
if (buffer_type)
hfi->buffer_type = buffer_type;
else
return -EINVAL;
hfi->format = hal_to_hfi_type(
HAL_PARAM_UNCOMPRESSED_FORMAT_SELECT,
prop->format);
pkt->size += sizeof(u32) +
sizeof(struct hfi_uncompressed_format_select);
break;
}
case HAL_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO:
break;
case HAL_PARAM_UNCOMPRESSED_PLANE_ACTUAL_INFO:
break;
case HAL_PARAM_EXTRA_DATA_HEADER_CONFIG:
break;
case HAL_PARAM_FRAME_SIZE:
{
struct hfi_frame_size *hfi;
struct hal_frame_size *prop = (struct hal_frame_size *) pdata;
u32 buffer_type;
pkt->rg_property_data[0] = HFI_PROPERTY_PARAM_FRAME_SIZE;
hfi = (struct hfi_frame_size *) &pkt->rg_property_data[1];
buffer_type = get_hfi_buffer(prop->buffer_type);
if (buffer_type)
hfi->buffer_type = buffer_type;
else
return -EINVAL;
hfi->height = prop->height;
hfi->width = prop->width;
pkt->size += sizeof(u32) + sizeof(struct hfi_frame_size);
break;
}
case HAL_CONFIG_REALTIME:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_CONFIG_REALTIME,
(((struct hal_enable *) pdata)->enable));
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_BUFFER_COUNT_ACTUAL:
{
struct hfi_buffer_count_actual *hfi;
struct hal_buffer_count_actual *prop =
(struct hal_buffer_count_actual *) pdata;
u32 buffer_type;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL;
hfi = (struct hfi_buffer_count_actual *)
&pkt->rg_property_data[1];
hfi->buffer_count_actual = prop->buffer_count_actual;
buffer_type = get_hfi_buffer(prop->buffer_type);
if (buffer_type)
hfi->buffer_type = buffer_type;
else
return -EINVAL;
pkt->size += sizeof(u32) + sizeof(struct
hfi_buffer_count_actual);
break;
}
case HAL_PARAM_NAL_STREAM_FORMAT_SELECT:
{
struct hfi_nal_stream_format_select *hfi;
struct hal_nal_stream_format_select *prop =
(struct hal_nal_stream_format_select *)pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SELECT;
hfi = (struct hfi_nal_stream_format_select *)
&pkt->rg_property_data[1];
dprintk(VIDC_DBG, "data is :%d\n",
prop->nal_stream_format_select);
hfi->nal_stream_format_select = hal_to_hfi_type(
HAL_PARAM_NAL_STREAM_FORMAT_SELECT,
prop->nal_stream_format_select);
pkt->size += sizeof(u32) +
sizeof(struct hfi_nal_stream_format_select);
break;
}
case HAL_PARAM_VDEC_OUTPUT_ORDER:
{
int *data = (int *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VDEC_OUTPUT_ORDER;
switch (*data) {
case HAL_OUTPUT_ORDER_DECODE:
pkt->rg_property_data[1] = HFI_OUTPUT_ORDER_DECODE;
break;
case HAL_OUTPUT_ORDER_DISPLAY:
pkt->rg_property_data[1] = HFI_OUTPUT_ORDER_DISPLAY;
break;
default:
dprintk(VIDC_ERR, "invalid output order: %#x\n",
*data);
break;
}
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VDEC_PICTURE_TYPE_DECODE:
{
struct hfi_enable_picture *hfi;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VDEC_PICTURE_TYPE_DECODE;
hfi = (struct hfi_enable_picture *) &pkt->rg_property_data[1];
hfi->picture_type =
((struct hfi_enable_picture *)pdata)->picture_type;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VDEC_OUTPUT2_KEEP_ASPECT_RATIO:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VDEC_OUTPUT2_KEEP_ASPECT_RATIO,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_CONFIG_VDEC_POST_LOOP_DEBLOCKER:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VDEC_MULTI_STREAM:
{
struct hfi_multi_stream *hfi;
struct hal_multi_stream *prop =
(struct hal_multi_stream *) pdata;
u32 buffer_type;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM;
hfi = (struct hfi_multi_stream *) &pkt->rg_property_data[1];
buffer_type = get_hfi_buffer(prop->buffer_type);
if (buffer_type)
hfi->buffer_type = buffer_type;
else
return -EINVAL;
hfi->enable = prop->enable;
hfi->width = prop->width;
hfi->height = prop->height;
pkt->size += sizeof(u32) + sizeof(struct hfi_multi_stream);
break;
}
case HAL_PARAM_VDEC_DISPLAY_PICTURE_BUFFER_COUNT:
{
struct hfi_display_picture_buffer_count *hfi;
struct hal_display_picture_buffer_count *prop =
(struct hal_display_picture_buffer_count *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VDEC_DISPLAY_PICTURE_BUFFER_COUNT;
hfi = (struct hfi_display_picture_buffer_count *)
&pkt->rg_property_data[1];
hfi->count = prop->count;
hfi->enable = prop->enable;
pkt->size += sizeof(u32) +
sizeof(struct hfi_display_picture_buffer_count);
break;
}
case HAL_PARAM_DIVX_FORMAT:
{
int *data = pdata;
pkt->rg_property_data[0] = HFI_PROPERTY_PARAM_DIVX_FORMAT;
switch (*data) {
case HAL_DIVX_FORMAT_4:
pkt->rg_property_data[1] = HFI_DIVX_FORMAT_4;
break;
case HAL_DIVX_FORMAT_5:
pkt->rg_property_data[1] = HFI_DIVX_FORMAT_5;
break;
case HAL_DIVX_FORMAT_6:
pkt->rg_property_data[1] = HFI_DIVX_FORMAT_6;
break;
default:
dprintk(VIDC_ERR, "Invalid divx format: %#x\n", *data);
break;
}
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_CONFIG_VDEC_MB_ERROR_MAP_REPORTING:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_CONFIG_VDEC_MB_ERROR_MAP_REPORTING,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VDEC_CONTINUE_DATA_TRANSFER:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VDEC_SYNC_FRAME_DECODE:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VDEC_THUMBNAIL_MODE,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VENC_SYNC_FRAME_SEQUENCE_HEADER:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_CONFIG_VENC_SYNC_FRAME_SEQUENCE_HEADER,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_CONFIG_VENC_REQUEST_IFRAME:
pkt->rg_property_data[0] =
HFI_PROPERTY_CONFIG_VENC_REQUEST_SYNC_FRAME;
pkt->size += sizeof(u32);
break;
case HAL_PARAM_VENC_MPEG4_SHORT_HEADER:
break;
case HAL_PARAM_VENC_MPEG4_AC_PREDICTION:
break;
case HAL_CONFIG_VENC_TARGET_BITRATE:
{
struct hfi_bitrate *hfi;
pkt->rg_property_data[0] =
HFI_PROPERTY_CONFIG_VENC_TARGET_BITRATE;
hfi = (struct hfi_bitrate *) &pkt->rg_property_data[1];
hfi->bit_rate = ((struct hal_bitrate *)pdata)->bit_rate;
hfi->layer_id = ((struct hal_bitrate *)pdata)->layer_id;
pkt->size += sizeof(u32) + sizeof(struct hfi_bitrate);
break;
}
case HAL_CONFIG_VENC_MAX_BITRATE:
{
struct hfi_bitrate *hfi;
pkt->rg_property_data[0] =
HFI_PROPERTY_CONFIG_VENC_MAX_BITRATE;
hfi = (struct hfi_bitrate *) &pkt->rg_property_data[1];
hfi->bit_rate = ((struct hal_bitrate *)pdata)->bit_rate;
hfi->layer_id = ((struct hal_bitrate *)pdata)->layer_id;
pkt->size += sizeof(u32) + sizeof(struct hfi_bitrate);
break;
}
case HAL_PARAM_PROFILE_LEVEL_CURRENT:
{
struct hfi_profile_level *hfi;
struct hal_profile_level *prop =
(struct hal_profile_level *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT;
hfi = (struct hfi_profile_level *)
&pkt->rg_property_data[1];
hfi->level = prop->level;
hfi->profile = hal_to_hfi_type(HAL_PARAM_PROFILE_LEVEL_CURRENT,
prop->profile);
if (hfi->profile <= 0) {
hfi->profile = HFI_H264_PROFILE_HIGH;
dprintk(VIDC_WARN,
"Profile %d not supported, falling back to high\n",
prop->profile);
}
if (!hfi->level) {
hfi->level = 1;
dprintk(VIDC_WARN,
"Level %d not supported, falling back to high\n",
prop->level);
}
pkt->size += sizeof(u32) + sizeof(struct hfi_profile_level);
break;
}
case HAL_PARAM_VENC_H264_ENTROPY_CONTROL:
{
struct hfi_h264_entropy_control *hfi;
struct hal_h264_entropy_control *prop =
(struct hal_h264_entropy_control *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_H264_ENTROPY_CONTROL;
hfi = (struct hfi_h264_entropy_control *)
&pkt->rg_property_data[1];
hfi->entropy_mode = hal_to_hfi_type(
HAL_PARAM_VENC_H264_ENTROPY_CONTROL,
prop->entropy_mode);
if (hfi->entropy_mode == HAL_H264_ENTROPY_CABAC)
hfi->cabac_model = hal_to_hfi_type(
HAL_PARAM_VENC_H264_ENTROPY_CABAC_MODEL,
prop->cabac_model);
pkt->size += sizeof(u32) + sizeof(
struct hfi_h264_entropy_control);
break;
}
case HAL_PARAM_VENC_RATE_CONTROL:
{
u32 *rc;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_RATE_CONTROL;
rc = (u32 *)pdata;
switch ((enum hal_rate_control) *rc) {
case HAL_RATE_CONTROL_OFF:
pkt->rg_property_data[1] = HFI_RATE_CONTROL_OFF;
break;
case HAL_RATE_CONTROL_CBR_CFR:
pkt->rg_property_data[1] = HFI_RATE_CONTROL_CBR_CFR;
break;
case HAL_RATE_CONTROL_CBR_VFR:
pkt->rg_property_data[1] = HFI_RATE_CONTROL_CBR_VFR;
break;
case HAL_RATE_CONTROL_VBR_CFR:
pkt->rg_property_data[1] = HFI_RATE_CONTROL_VBR_CFR;
break;
case HAL_RATE_CONTROL_VBR_VFR:
pkt->rg_property_data[1] = HFI_RATE_CONTROL_VBR_VFR;
break;
case HAL_RATE_CONTROL_MBR_CFR:
pkt->rg_property_data[1] = HFI_RATE_CONTROL_MBR_CFR;
break;
case HAL_RATE_CONTROL_MBR_VFR:
pkt->rg_property_data[1] = HFI_RATE_CONTROL_MBR_VFR;
break;
default:
dprintk(VIDC_ERR,
"Invalid Rate control setting: %pK\n",
pdata);
break;
}
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VENC_MPEG4_TIME_RESOLUTION:
{
struct hfi_mpeg4_time_resolution *hfi;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_MPEG4_TIME_RESOLUTION;
hfi = (struct hfi_mpeg4_time_resolution *)
&pkt->rg_property_data[1];
hfi->time_increment_resolution =
((struct hal_mpeg4_time_resolution *)pdata)->
time_increment_resolution;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VENC_MPEG4_HEADER_EXTENSION:
{
struct hfi_mpeg4_header_extension *hfi;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_MPEG4_HEADER_EXTENSION;
hfi = (struct hfi_mpeg4_header_extension *)
&pkt->rg_property_data[1];
hfi->header_extension = (u32)(unsigned long) pdata;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VENC_H264_DEBLOCK_CONTROL:
{
struct hfi_h264_db_control *hfi;
struct hal_h264_db_control *prop =
(struct hal_h264_db_control *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_H264_DEBLOCK_CONTROL;
hfi = (struct hfi_h264_db_control *) &pkt->rg_property_data[1];
switch (prop->mode) {
case HAL_H264_DB_MODE_DISABLE:
hfi->mode = HFI_H264_DB_MODE_DISABLE;
break;
case HAL_H264_DB_MODE_SKIP_SLICE_BOUNDARY:
hfi->mode = HFI_H264_DB_MODE_SKIP_SLICE_BOUNDARY;
break;
case HAL_H264_DB_MODE_ALL_BOUNDARY:
hfi->mode = HFI_H264_DB_MODE_ALL_BOUNDARY;
break;
default:
dprintk(VIDC_ERR, "Invalid deblocking mode: %#x\n",
prop->mode);
break;
}
hfi->slice_alpha_offset = prop->slice_alpha_offset;
hfi->slice_beta_offset = prop->slice_beta_offset;
pkt->size += sizeof(u32) +
sizeof(struct hfi_h264_db_control);
break;
}
case HAL_PARAM_VENC_SESSION_QP:
{
struct hfi_quantization *hfi;
struct hal_quantization *hal_quant =
(struct hal_quantization *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_SESSION_QP;
hfi = (struct hfi_quantization *) &pkt->rg_property_data[1];
hfi->qp_i = hal_quant->qpi;
hfi->qp_p = hal_quant->qpp;
hfi->qp_b = hal_quant->qpb;
hfi->layer_id = hal_quant->layer_id;
pkt->size += sizeof(u32) + sizeof(struct hfi_quantization);
break;
}
case HAL_PARAM_VENC_SESSION_QP_RANGE:
{
struct hfi_quantization_range *hfi;
struct hfi_quantization_range *hal_range =
(struct hfi_quantization_range *) pdata;
u32 min_qp, max_qp;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE;
hfi = (struct hfi_quantization_range *)
&pkt->rg_property_data[1];
min_qp = hal_range->min_qp;
max_qp = hal_range->max_qp;
/* We'll be packing in the qp, so make sure we
* won't be losing data when masking */
if (min_qp > 0xff || max_qp > 0xff) {
dprintk(VIDC_ERR, "qp value out of range\n");
rc = -ERANGE;
break;
}
/* When creating the packet, pack the qp value as
* 0xiippbb, where ii = qp range for I-frames,
* pp = qp range for P-frames, etc. */
hfi->min_qp = min_qp | min_qp << 8 | min_qp << 16;
hfi->max_qp = max_qp | max_qp << 8 | max_qp << 16;
hfi->layer_id = hal_range->layer_id;
pkt->size += sizeof(u32) +
sizeof(struct hfi_quantization_range);
break;
}
case HAL_PARAM_VENC_SESSION_QP_RANGE_PACKED:
{
struct hfi_quantization_range *hfi;
struct hfi_quantization_range *hal_range =
(struct hfi_quantization_range *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE;
hfi = (struct hfi_quantization_range *)
&pkt->rg_property_data[1];
hfi->min_qp = hal_range->min_qp;
hfi->max_qp = hal_range->max_qp;
hfi->layer_id = hal_range->layer_id;
pkt->size += sizeof(u32) +
sizeof(struct hfi_quantization_range);
break;
}
case HAL_PARAM_VENC_SEARCH_RANGE:
{
struct hfi_vc1e_perf_cfg_type *hfi;
struct hal_vc1e_perf_cfg_type *hal_mv_searchrange =
(struct hal_vc1e_perf_cfg_type *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_VC1_PERF_CFG;
hfi = (struct hfi_vc1e_perf_cfg_type *)
&pkt->rg_property_data[1];
hfi->search_range_x_subsampled[0] =
hal_mv_searchrange->i_frame.x_subsampled;
hfi->search_range_x_subsampled[1] =
hal_mv_searchrange->p_frame.x_subsampled;
hfi->search_range_x_subsampled[2] =
hal_mv_searchrange->b_frame.x_subsampled;
hfi->search_range_y_subsampled[0] =
hal_mv_searchrange->i_frame.y_subsampled;
hfi->search_range_y_subsampled[1] =
hal_mv_searchrange->p_frame.y_subsampled;
hfi->search_range_y_subsampled[2] =
hal_mv_searchrange->b_frame.y_subsampled;
pkt->size += sizeof(u32) +
sizeof(struct hfi_vc1e_perf_cfg_type);
break;
}
case HAL_PARAM_VENC_MAX_NUM_B_FRAMES:
{
struct hfi_max_num_b_frames *hfi;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_MAX_NUM_B_FRAMES;
hfi = (struct hfi_max_num_b_frames *) &pkt->rg_property_data[1];
memcpy(hfi, (struct hfi_max_num_b_frames *) pdata,
sizeof(struct hfi_max_num_b_frames));
pkt->size += sizeof(u32) + sizeof(struct hfi_max_num_b_frames);
break;
}
case HAL_CONFIG_VENC_INTRA_PERIOD:
{
struct hfi_intra_period *hfi;
pkt->rg_property_data[0] =
HFI_PROPERTY_CONFIG_VENC_INTRA_PERIOD;
hfi = (struct hfi_intra_period *) &pkt->rg_property_data[1];
memcpy(hfi, (struct hfi_intra_period *) pdata,
sizeof(struct hfi_intra_period));
pkt->size += sizeof(u32) + sizeof(struct hfi_intra_period);
break;
}
case HAL_CONFIG_VENC_IDR_PERIOD:
{
struct hfi_idr_period *hfi;
pkt->rg_property_data[0] = HFI_PROPERTY_CONFIG_VENC_IDR_PERIOD;
hfi = (struct hfi_idr_period *) &pkt->rg_property_data[1];
hfi->idr_period = ((struct hfi_idr_period *) pdata)->idr_period;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VDEC_CONCEAL_COLOR:
{
struct hfi_conceal_color *hfi;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR;
hfi = (struct hfi_conceal_color *) &pkt->rg_property_data[1];
if (hfi)
hfi->conceal_color =
((struct hfi_conceal_color *) pdata)->
conceal_color;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_CONFIG_VPE_OPERATIONS:
{
struct hfi_operations_type *hfi;
struct hal_operations *prop =
(struct hal_operations *) pdata;
pkt->rg_property_data[0] = HFI_PROPERTY_CONFIG_VPE_OPERATIONS;
hfi = (struct hfi_operations_type *) &pkt->rg_property_data[1];
switch (prop->rotate) {
case HAL_ROTATE_NONE:
hfi->rotation = HFI_ROTATE_NONE;
break;
case HAL_ROTATE_90:
hfi->rotation = HFI_ROTATE_90;
break;
case HAL_ROTATE_180:
hfi->rotation = HFI_ROTATE_180;
break;
case HAL_ROTATE_270:
hfi->rotation = HFI_ROTATE_270;
break;
default:
dprintk(VIDC_ERR, "Invalid rotation setting: %#x\n",
prop->rotate);
rc = -EINVAL;
break;
}
switch (prop->flip) {
case HAL_FLIP_NONE:
hfi->flip = HFI_FLIP_NONE;
break;
case HAL_FLIP_HORIZONTAL:
hfi->flip = HFI_FLIP_HORIZONTAL;
break;
case HAL_FLIP_VERTICAL:
hfi->flip = HFI_FLIP_VERTICAL;
break;
default:
dprintk(VIDC_ERR, "Invalid flip setting: %#x\n",
prop->flip);
rc = -EINVAL;
break;
}
pkt->size += sizeof(u32) + sizeof(struct hfi_operations_type);
break;
}
case HAL_PARAM_VENC_INTRA_REFRESH:
{
struct hfi_intra_refresh *hfi;
struct hal_intra_refresh *prop =
(struct hal_intra_refresh *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH;
hfi = (struct hfi_intra_refresh *) &pkt->rg_property_data[1];
switch (prop->mode) {
case HAL_INTRA_REFRESH_NONE:
hfi->mode = HFI_INTRA_REFRESH_NONE;
break;
case HAL_INTRA_REFRESH_ADAPTIVE:
hfi->mode = HFI_INTRA_REFRESH_ADAPTIVE;
break;
case HAL_INTRA_REFRESH_CYCLIC:
hfi->mode = HFI_INTRA_REFRESH_CYCLIC;
break;
case HAL_INTRA_REFRESH_CYCLIC_ADAPTIVE:
hfi->mode = HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE;
break;
case HAL_INTRA_REFRESH_RANDOM:
hfi->mode = HFI_INTRA_REFRESH_RANDOM;
break;
default:
dprintk(VIDC_ERR,
"Invalid intra refresh setting: %#x\n",
prop->mode);
break;
}
hfi->air_mbs = prop->air_mbs;
hfi->air_ref = prop->air_ref;
hfi->cir_mbs = prop->cir_mbs;
pkt->size += sizeof(u32) + sizeof(struct hfi_intra_refresh);
break;
}
case HAL_PARAM_VENC_MULTI_SLICE_CONTROL:
{
struct hfi_multi_slice_control *hfi;
struct hal_multi_slice_control *prop =
(struct hal_multi_slice_control *) pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_CONTROL;
hfi = (struct hfi_multi_slice_control *)
&pkt->rg_property_data[1];
switch (prop->multi_slice) {
case HAL_MULTI_SLICE_OFF:
hfi->multi_slice = HFI_MULTI_SLICE_OFF;
break;
case HAL_MULTI_SLICE_GOB:
hfi->multi_slice = HFI_MULTI_SLICE_GOB;
break;
case HAL_MULTI_SLICE_BY_MB_COUNT:
hfi->multi_slice = HFI_MULTI_SLICE_BY_MB_COUNT;
break;
case HAL_MULTI_SLICE_BY_BYTE_COUNT:
hfi->multi_slice = HFI_MULTI_SLICE_BY_BYTE_COUNT;
break;
default:
dprintk(VIDC_ERR, "Invalid slice settings: %#x\n",
prop->multi_slice);
break;
}
hfi->slice_size = prop->slice_size;
pkt->size += sizeof(u32) + sizeof(struct
hfi_multi_slice_control);
break;
}
case HAL_PARAM_INDEX_EXTRADATA:
{
struct hfi_index_extradata_config *hfi;
struct hal_extradata_enable *extra = pdata;
int id = 0;
pkt->rg_property_data[0] =
get_hfi_extradata_index(extra->index);
hfi = (struct hfi_index_extradata_config *)
&pkt->rg_property_data[1];
hfi->enable = extra->enable;
id = get_hfi_extradata_id(extra->index);
if (id)
hfi->index_extra_data_id = id;
else {
dprintk(VIDC_WARN,
"Failed to find extradata id: %d\n",
id);
rc = -EINVAL;
}
pkt->size += sizeof(u32) +
sizeof(struct hfi_index_extradata_config);
break;
}
case HAL_PARAM_VENC_SLICE_DELIVERY_MODE:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VENC_SLICE_DELIVERY_MODE,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VENC_H264_VUI_TIMING_INFO:
{
struct hfi_h264_vui_timing_info *hfi;
struct hal_h264_vui_timing_info *timing_info = pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_H264_VUI_TIMING_INFO;
hfi = (struct hfi_h264_vui_timing_info *)&pkt->
rg_property_data[1];
hfi->enable = timing_info->enable;
hfi->fixed_frame_rate = timing_info->fixed_frame_rate;
hfi->time_scale = timing_info->time_scale;
pkt->size += sizeof(u32) +
sizeof(struct hfi_h264_vui_timing_info);
break;
}
case HAL_CONFIG_VPE_DEINTERLACE:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_CONFIG_VPE_DEINTERLACE,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VENC_H264_GENERATE_AUDNAL:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VENC_H264_GENERATE_AUDNAL,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_BUFFER_ALLOC_MODE:
{
u32 buffer_type;
u32 buffer_mode;
struct hfi_buffer_alloc_mode *hfi;
struct hal_buffer_alloc_mode *alloc_info = pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE;
hfi = (struct hfi_buffer_alloc_mode *)
&pkt->rg_property_data[1];
buffer_type = get_hfi_buffer(alloc_info->buffer_type);
if (buffer_type)
hfi->buffer_type = buffer_type;
else
return -EINVAL;
buffer_mode = get_hfi_buf_mode(alloc_info->buffer_mode);
if (buffer_mode)
hfi->buffer_mode = buffer_mode;
else
return -EINVAL;
pkt->size += sizeof(u32) + sizeof(struct hfi_buffer_alloc_mode);
break;
}
case HAL_PARAM_VDEC_FRAME_ASSEMBLY:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VDEC_FRAME_ASSEMBLY,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VENC_H264_VUI_BITSTREAM_RESTRC:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VENC_H264_VUI_BITSTREAM_RESTRC,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VENC_PRESERVE_TEXT_QUALITY:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VENC_PRESERVE_TEXT_QUALITY,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VDEC_SCS_THRESHOLD:
{
struct hfi_scs_threshold *hfi;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VDEC_SCS_THRESHOLD;
hfi = (struct hfi_scs_threshold *) &pkt->rg_property_data[1];
hfi->threshold_value =
((struct hal_scs_threshold *) pdata)->threshold_value;
pkt->size += sizeof(u32) + sizeof(struct hfi_scs_threshold);
break;
}
case HAL_PARAM_MVC_BUFFER_LAYOUT:
{
struct hfi_mvc_buffer_layout_descp_type *hfi;
struct hal_mvc_buffer_layout *layout_info = pdata;
pkt->rg_property_data[0] = HFI_PROPERTY_PARAM_MVC_BUFFER_LAYOUT;
hfi = (struct hfi_mvc_buffer_layout_descp_type *)
&pkt->rg_property_data[1];
hfi->layout_type = get_hfi_layout(layout_info->layout_type);
hfi->bright_view_first = layout_info->bright_view_first;
hfi->ngap = layout_info->ngap;
pkt->size += sizeof(u32) +
sizeof(struct hfi_mvc_buffer_layout_descp_type);
break;
}
case HAL_PARAM_VENC_LTRMODE:
{
struct hfi_ltr_mode *hfi;
struct hal_ltr_mode *hal = pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_LTRMODE;
hfi = (struct hfi_ltr_mode *) &pkt->rg_property_data[1];
hfi->ltr_mode = get_hfi_ltr_mode(hal->mode);
hfi->ltr_count = hal->count;
hfi->trust_mode = hal->trust_mode;
pkt->size += sizeof(u32) + sizeof(struct hfi_ltr_mode);
break;
}
case HAL_CONFIG_VENC_USELTRFRAME:
{
struct hfi_ltr_use *hfi;
struct hal_ltr_use *hal = pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_CONFIG_VENC_USELTRFRAME;
hfi = (struct hfi_ltr_use *) &pkt->rg_property_data[1];
hfi->frames = hal->frames;
hfi->ref_ltr = hal->ref_ltr;
hfi->use_constrnt = hal->use_constraint;
pkt->size += sizeof(u32) + sizeof(struct hfi_ltr_use);
break;
}
case HAL_CONFIG_VENC_MARKLTRFRAME:
{
struct hfi_ltr_mark *hfi;
struct hal_ltr_mark *hal = pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_CONFIG_VENC_MARKLTRFRAME;
hfi = (struct hfi_ltr_mark *) &pkt->rg_property_data[1];
hfi->mark_frame = hal->mark_frame;
pkt->size += sizeof(u32) + sizeof(struct hfi_ltr_mark);
break;
}
case HAL_PARAM_VENC_HIER_P_MAX_ENH_LAYERS:
{
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_HIER_P_MAX_NUM_ENH_LAYER;
pkt->rg_property_data[1] = *(u32 *)pdata;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_CONFIG_VENC_HIER_P_NUM_FRAMES:
{
pkt->rg_property_data[0] =
HFI_PROPERTY_CONFIG_VENC_HIER_P_ENH_LAYER;
pkt->rg_property_data[1] = *(u32 *)pdata;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VENC_DISABLE_RC_TIMESTAMP:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VENC_DISABLE_RC_TIMESTAMP,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VENC_ENABLE_INITIAL_QP:
{
struct hfi_initial_quantization *hfi;
struct hal_initial_quantization *quant = pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_INITIAL_QP;
hfi = (struct hfi_initial_quantization *)
&pkt->rg_property_data[1];
hfi->init_qp_enable = quant->init_qp_enable;
hfi->qp_i = quant->qpi;
hfi->qp_p = quant->qpp;
hfi->qp_b = quant->qpb;
pkt->size += sizeof(u32) +
sizeof(struct hfi_initial_quantization);
break;
}
case HAL_PARAM_VPE_COLOR_SPACE_CONVERSION:
{
struct hfi_vpe_color_space_conversion *hfi = NULL;
struct hal_vpe_color_space_conversion *hal = pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VPE_COLOR_SPACE_CONVERSION;
hfi = (struct hfi_vpe_color_space_conversion *)
&pkt->rg_property_data[1];
memcpy(hfi->csc_matrix, hal->csc_matrix,
sizeof(hfi->csc_matrix));
memcpy(hfi->csc_bias, hal->csc_bias, sizeof(hfi->csc_bias));
memcpy(hfi->csc_limit, hal->csc_limit, sizeof(hfi->csc_limit));
pkt->size += sizeof(u32) +
sizeof(struct hfi_vpe_color_space_conversion);
break;
}
case HAL_PARAM_VENC_VPX_ERROR_RESILIENCE_MODE:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VENC_VPX_ERROR_RESILIENCE_MODE,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VENC_H264_NAL_SVC_EXT:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VENC_H264_NAL_SVC_EXT,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_CONFIG_VENC_PERF_MODE:
{
u32 hfi_perf_mode = 0;
enum hal_perf_mode hal_perf_mode = *(enum hal_perf_mode *)pdata;
switch (hal_perf_mode) {
case HAL_PERF_MODE_POWER_SAVE:
hfi_perf_mode = HFI_VENC_PERFMODE_POWER_SAVE;
break;
case HAL_PERF_MODE_POWER_MAX_QUALITY:
hfi_perf_mode = HFI_VENC_PERFMODE_MAX_QUALITY;
break;
default:
return -ENOTSUPP;
}
pkt->rg_property_data[0] = HFI_PROPERTY_CONFIG_VENC_PERF_MODE;
pkt->rg_property_data[1] = hfi_perf_mode;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VENC_HIER_B_MAX_ENH_LAYERS:
{
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_HIER_B_MAX_NUM_ENH_LAYER;
pkt->rg_property_data[1] = *(u32 *)pdata;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PARAM_VDEC_NON_SECURE_OUTPUT2:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VDEC_NONCP_OUTPUT2,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VENC_HIER_P_HYBRID_MODE:
{
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_HIER_P_HYBRID_MODE;
pkt->rg_property_data[1] =
((struct hfi_hybrid_hierp *)pdata)->layers;
pkt->size += sizeof(u32) +
sizeof(struct hfi_hybrid_hierp);
break;
}
case HAL_PARAM_VENC_MBI_STATISTICS_MODE:
{
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_MBI_DUMPING;
pkt->rg_property_data[1] = hal_to_hfi_type(
HAL_PARAM_VENC_MBI_STATISTICS_MODE,
*(u32 *)pdata);
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_CONFIG_VENC_FRAME_QP:
{
pkt->rg_property_data[0] =
HFI_PROPERTY_CONFIG_VENC_FRAME_QP;
pkt->rg_property_data[1] = *(u32 *)pdata;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_CONFIG_VENC_BASELAYER_PRIORITYID:
{
pkt->rg_property_data[0] =
HFI_PROPERTY_CONFIG_VENC_BASELAYER_PRIORITYID;
pkt->rg_property_data[1] = *(u32 *)pdata;
pkt->size += sizeof(u32) * 2;
break;
}
case HAL_PROPERTY_PARAM_VENC_ASPECT_RATIO:
{
struct hfi_aspect_ratio *hfi = NULL;
struct hal_aspect_ratio *hal = pdata;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_ASPECT_RATIO;
hfi = (struct hfi_aspect_ratio *)
&pkt->rg_property_data[1];
memcpy(hfi, hal,
sizeof(struct hfi_aspect_ratio));
pkt->size += sizeof(u32) +
sizeof(struct hfi_aspect_ratio);
break;
}
case HAL_PARAM_VENC_BITRATE_TYPE:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VENC_BITRATE_TYPE,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VENC_CONSTRAINED_INTRA_PRED:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VENC_CONSTRAINED_INTRA_PRED,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VENC_VIDEO_SIGNAL_INFO:
{
struct hal_video_signal_info *hal = pdata;
struct hfi_video_signal_metadata *signal_info =
(struct hfi_video_signal_metadata *)
&pkt->rg_property_data[1];
signal_info->enable = true;
signal_info->video_format = MSM_VIDC_NTSC;
signal_info->video_full_range = hal->full_range;
signal_info->color_description = MSM_VIDC_COLOR_DESC_PRESENT;
signal_info->color_primaries = hal->color_space;
signal_info->transfer_characteristics = hal->transfer_chars;
signal_info->matrix_coeffs = hal->matrix_coeffs;
pkt->rg_property_data[0] =
HFI_PROPERTY_PARAM_VENC_VIDEO_SIGNAL_INFO;
pkt->size += sizeof(u32) + sizeof(*signal_info);
break;
}
case HAL_PARAM_VENC_H264_TRANSFORM_8x8:
{
create_pkt_enable(pkt->rg_property_data,
HFI_PROPERTY_PARAM_VENC_H264_8X8_TRANSFORM,
((struct hal_enable *)pdata)->enable);
pkt->size += sizeof(u32) + sizeof(struct hfi_enable);
break;
}
case HAL_PARAM_VENC_IFRAMESIZE_TYPE:
{
enum hal_iframesize_type hal =
*(enum hal_iframesize_type *)pdata;
struct hfi_iframe_size *hfi = (struct hfi_iframe_size *)
&pkt->rg_property_data[1];
switch (hal) {
case HAL_IFRAMESIZE_TYPE_DEFAULT:
hfi->type = HFI_IFRAME_SIZE_DEFAULT;
break;
case HAL_IFRAMESIZE_TYPE_MEDIUM:
hfi->type = HFI_IFRAME_SIZE_MEDIUM;
break;
case HAL_IFRAMESIZE_TYPE_HUGE:
hfi->type = HFI_IFRAME_SIZE_HIGH;
break;
case HAL_IFRAMESIZE_TYPE_UNLIMITED:
hfi->type = HFI_IFRAME_SIZE_UNLIMITED;
break;
default:
return -ENOTSUPP;
}
pkt->rg_property_data[0] = HFI_PROPERTY_PARAM_VENC_IFRAMESIZE;
pkt->size += sizeof(u32) + sizeof(struct hfi_iframe_size);
break;
}
/* FOLLOWING PROPERTIES ARE NOT IMPLEMENTED IN CORE YET */
case HAL_CONFIG_BUFFER_REQUIREMENTS:
case HAL_CONFIG_PRIORITY:
case HAL_CONFIG_BATCH_INFO:
case HAL_PARAM_METADATA_PASS_THROUGH:
case HAL_SYS_IDLE_INDICATOR:
case HAL_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:
case HAL_PARAM_INTERLACE_FORMAT_SUPPORTED:
case HAL_PARAM_CHROMA_SITE:
case HAL_PARAM_PROPERTIES_SUPPORTED:
case HAL_PARAM_PROFILE_LEVEL_SUPPORTED:
case HAL_PARAM_CAPABILITY_SUPPORTED:
case HAL_PARAM_NAL_STREAM_FORMAT_SUPPORTED:
case HAL_PARAM_MULTI_VIEW_FORMAT:
case HAL_PARAM_MAX_SEQUENCE_HEADER_SIZE:
case HAL_PARAM_CODEC_SUPPORTED:
case HAL_PARAM_VDEC_MULTI_VIEW_SELECT:
case HAL_PARAM_VDEC_MB_QUANTIZATION:
case HAL_PARAM_VDEC_NUM_CONCEALED_MB:
case HAL_PARAM_VDEC_H264_ENTROPY_SWITCHING:
case HAL_PARAM_VENC_MPEG4_DATA_PARTITIONING:
case HAL_CONFIG_BUFFER_COUNT_ACTUAL:
case HAL_CONFIG_VDEC_MULTI_STREAM:
case HAL_PARAM_VENC_MULTI_SLICE_INFO:
case HAL_CONFIG_VENC_TIMESTAMP_SCALE:
case HAL_PARAM_BUFFER_SIZE_MINIMUM:
default:
dprintk(VIDC_ERR, "DEFAULT: Calling %#x\n", ptype);
rc = -ENOTSUPP;
break;
}
return rc;
}