samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

driver: video: port settings changes

Browse Source 
updated hfi command, property header files.
deleted hfi definition header file.
added new input and output properties for decoder.
added profile, level and tier properties as part of
port settings subscription.

Change-Id: I072d0bb56183950920975950b3873003218d526e
Signed-off-by: Darshana Patil <darshana@codeaurora.org>
This commit is contained in:
Darshana Patil
2020-10-29 12:45:19 -07:00
committed by Gerrit - the friendly Code Review server
parent 10e2017aa8
commit 9b4556df59
11 changed files with 686 additions and 447 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
driver/platform/waipio/src/msm_vidc_waipio.c
View File

@@ -17,6 +17,7 @@
#define DDR_TYPE_LPDDR4X 0x7
#define DDR_TYPE_LPDDR5 0x8
#define DDR_TYPE_LPDDR5X 0x9
#define DEFAULT_VIDEO_CONCEAL_COLOR_BLACK 0x8020010
#define UBWC_CONFIG(mco, mlo, hbo, bslo, bso, rs, mc, ml, hbb, bsl, bsp) \
{ \
@@ -894,6 +895,16 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
{0},
{ENTROPY_MODE},
NULL, msm_vidc_set_u32},
/* conceal color */
{CONCEAL_COLOR_8BIT, DEC, CODECS_ALL, 0x0, 0xff3fcff, 1,
DEFAULT_VIDEO_CONCEAL_COLOR_BLACK,
V4L2_CID_MPEG_VIDEO_MUTE_YUV,
HFI_PROP_CONCEAL_COLOR_8BIT},
{CONCEAL_COLOR_10BIT, DEC, CODECS_ALL, 0x0, 0x3fffffff, 1,
DEFAULT_VIDEO_CONCEAL_COLOR_BLACK,
V4L2_CID_MPEG_VIDEO_MUTE_YUV,
HFI_PROP_CONCEAL_COLOR_10BIT},
};
/*

127
driver/vidc/inc/hfi_command.h
View File

@@ -9,7 +9,7 @@
#include <linux/types.h>
#include <linux/bits.h>
#define HFI_VIDEO_ARCH_OX 0x1
#define HFI_VIDEO_ARCH_LX 0x1
struct hfi_header {
u32 size;
@@ -43,19 +43,24 @@ struct hfi_buffer {
};
enum hfi_packet_host_flags {
HFI_HOST_FLAGS_NONE = 0,
HFI_HOST_FLAGS_INTR_REQUIRED = BIT(0),
HFI_HOST_FLAGS_RESPONSE_REQUIRED = BIT(1),
HFI_HOST_FLAGS_NON_DISCARDABLE = BIT(2),
HFI_HOST_FLAGS_GET_PROPERTY = BIT(3),
HFI_HOST_FLAGS_NONE = 0x00000000,
HFI_HOST_FLAGS_INTR_REQUIRED = 0x00000001,
HFI_HOST_FLAGS_RESPONSE_REQUIRED = 0x00000002,
HFI_HOST_FLAGS_NON_DISCARDABLE = 0x00000004,
HFI_HOST_FLAGS_GET_PROPERTY = 0x00000008,
HFI_HOST_FLAGS_CB_NON_SECURE = 0x00000010,
HFI_HOST_FLAGS_CB_SECURE_PIXEL = 0x00000020,
HFI_HOST_FLAGS_CB_SECURE_BITSTREAM = 0x00000040,
HFI_HOST_FLAGS_CB_SECURE_NON_PIXEL = 0x00000080,
HFI_HOST_FLAGS_CB_NON_SECURE_PIXEL = 0x00000100,
};
enum hfi_packet_firmware_flags {
HFI_FW_FLAGS_NONE = 0,
HFI_FW_FLAGS_SUCCESS = BIT(0),
HFI_FW_FLAGS_INFORMATION = BIT(1),
HFI_FW_FLAGS_SESSION_ERROR = BIT(2),
HFI_FW_FLAGS_SYSTEM_ERROR = BIT(3),
HFI_FW_FLAGS_NONE = 0x00000000,
HFI_FW_FLAGS_SUCCESS = 0x00000001,
HFI_FW_FLAGS_INFORMATION = 0x00000002,
HFI_FW_FLAGS_SESSION_ERROR = 0x00000004,
HFI_FW_FLAGS_SYSTEM_ERROR = 0x00000008,
};
enum hfi_packet_payload_info {
@@ -72,52 +77,49 @@ enum hfi_packet_payload_info {
HFI_PAYLOAD_32_PACKED = 0x0000000a,
HFI_PAYLOAD_U32_ARRAY = 0x0000000b,
HFI_PAYLOAD_S32_ARRAY = 0x0000000c,
HFI_PAYLOAD_64_PACKED = 0x0000000d,
};
enum hfi_packet_port_type {
HFI_PORT_NONE = 0,
HFI_PORT_BITSTREAM = BIT(0),
HFI_PORT_RAW = BIT(1),
HFI_PORT_NONE = 0x00000000,
HFI_PORT_BITSTREAM = 0x00000001,
HFI_PORT_RAW = 0x00000002,
};
enum hfi_buffer_type {
HFI_BUFFER_BITSTREAM = 0x00000001,
HFI_BUFFER_RAW = 0x00000002,
HFI_BUFFER_METADATA = 0x00000003,
HFI_BUFFER_DPB = 0x00000004,
HFI_BUFFER_BIN = 0x00000005,
HFI_BUFFER_LINE = 0x00000006,
HFI_BUFFER_ARP = 0x00000007,
HFI_BUFFER_COMV = 0x00000008,
HFI_BUFFER_NON_COMV = 0x00000009,
HFI_BUFFER_PERSIST = 0x0000000A,
HFI_BUFFER_SUBCACHE = 0x0000000B,
HFI_BUFFER_SFR = 0x0000000C,
HFI_BUFFER_SUBCACHE = 0x00000004,
HFI_BUFFER_SFR = 0x00000005,
HFI_BUFFER_DPB = 0x00000006,
HFI_BUFFER_BIN = 0x00000007,
HFI_BUFFER_LINE = 0x00000008,
HFI_BUFFER_ARP = 0x00000009,
HFI_BUFFER_COMV = 0x0000000A,
HFI_BUFFER_NON_COMV = 0x0000000B,
HFI_BUFFER_PERSIST = 0x0000000C,
HFI_BUFFER_VPSS = 0x0000000D,
};
enum hfi_buffer_host_flags {
HFI_BUF_HOST_FLAG_NONE = 0,
HFI_BUF_HOST_FLAG_RELEASE = BIT(0),
HFI_BUF_HOST_FLAG_READONLY = BIT(1),
HFI_BUF_HOST_FLAG_CODEC_CONFIG = BIT(2),
HFI_BUF_HOST_FLAG_NONE = 0x00000000,
HFI_BUF_HOST_FLAG_RELEASE = 0x00000001,
HFI_BUF_HOST_FLAG_READONLY = 0x00000002,
HFI_BUF_HOST_FLAG_CODEC_CONFIG = 0x00000004,
};
enum hfi_buffer_firmware_flags {
HFI_BUF_FW_FLAG_NONE = 0,
HFI_BUF_FW_FLAG_LAST = BIT(0),
HFI_BUF_FW_FLAG_READONLY = BIT(1),
HFI_BUF_FW_FLAG_CODEC_CONFIG = BIT(2),
// TODO
HFI_BUF_FW_FLAG_SUBFRAME = BIT(3),
HFI_BUF_FW_FLAG_KEYFRAME = BIT(4),
HFI_BUF_FW_FLAG_CORRUPT = BIT(28),
HFI_BUF_FW_FLAG_UNSUPPORTED = BIT(29),
HFI_BUF_FW_FLAG_NONE = 0x00000000,
HFI_BUF_FW_FLAG_LAST = 0x00000001,
HFI_BUF_FW_FLAG_READONLY = 0x00000002,
HFI_BUF_FW_FLAG_CODEC_CONFIG = 0x00000004,
};
enum hfi_metapayload_header_flags {
HFI_METADATA_FLAGS_NONE = 0,
HFI_METADATA_FLAGS_TOP_FIELD = BIT(0),
HFI_METADATA_FLAGS_BOTTOM_FIELDS = BIT(1),
HFI_METADATA_FLAGS_NONE = 0x00000000,
HFI_METADATA_FLAGS_TOP_FIELD = 0x00000001,
HFI_METADATA_FLAGS_BOTTOM_FIELD = 0x00000002,
};
struct metabuf_header {
@@ -137,25 +139,36 @@ struct metapayload_header {
};
enum hfi_property_mode_type {
HFI_MODE_NONE = 0,
HFI_MODE_PORT_SETTINGS_CHANGE = BIT(0),
HFI_MODE_PROPERTY = BIT(1),
HFI_MODE_METADATA = BIT(2),
HFI_MODE_NONE = 0x00000000,
HFI_MODE_PORT_SETTINGS_CHANGE = 0x00000001,
HFI_MODE_PROPERTY = 0x00000002,
HFI_MODE_METADATA = 0x00000004,
};
#define HFI_CMD_BEGIN 0x0
#define HFI_CMD_INIT 0x1
#define HFI_CMD_POWER_COLLAPSE 0x2
#define HFI_CMD_OPEN 0x3
#define HFI_CMD_CLOSE 0x4
#define HFI_CMD_START 0x5
#define HFI_CMD_STOP 0x6
#define HFI_CMD_DRAIN 0x7
#define HFI_CMD_RESUME 0x8
#define HFI_CMD_BUFFER 0x9
#define HFI_CMD_DELIVERY_MODE 0xA
#define HFI_CMD_SUBSCRIBE_MODE 0xB
#define HFI_CMD_SETTINGS_CHANGE 0xC
#define HFI_CMD_END 0xD
#define HFI_CMD_BEGIN 0x01000000
#define HFI_CMD_INIT 0x01000001
#define HFI_CMD_POWER_COLLAPSE 0x01000002
#define HFI_CMD_OPEN 0x01000003
#define HFI_CMD_CLOSE 0x01000004
#define HFI_CMD_START 0x01000005
#define HFI_CMD_STOP 0x01000006
#define HFI_CMD_DRAIN 0x01000007
#define HFI_CMD_RESUME 0x01000008
#define HFI_CMD_BUFFER 0x01000009
#define HFI_CMD_DELIVERY_MODE 0x0100000A
#define HFI_CMD_SUBSCRIBE_MODE 0x0100000B
#define HFI_CMD_SETTINGS_CHANGE 0x0100000C
#define HFI_SSR_TYPE_SW_ERR_FATAL 0x1
#define HFI_SSR_TYPE_SW_DIV_BY_ZERO 0x2
#define HFI_SSR_TYPE_HW_WDOG_IRQ 0x3
#define HFI_SSR_TYPE_NOC_ERROR 0x4
#define HFI_SSR_TYPE_VCODEC_HUNG 0x5
#define HFI_BITMASK_SSR_SUB_CLIENT_ID 0x000000f0
#define HFI_BITMASK_SSR_TYPE 0x0000000f
#define HFI_CMD_SSR 0x0100000D
#define HFI_CMD_END 0x01FFFFFF
#endif //__H_HFI_COMMAND_H__

30
driver/vidc/inc/hfi_definition.h
View File

@@ -1,30 +0,0 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2012-2021, The Linux Foundation. All rights reserved.
*/
#ifndef __H_HFI_DEFINITION_H__
#define __H_HFI_DEFINITION_H__
typedef u8 HFI_U8;
typedef s8 HFI_S8;
typedef u16 HFI_U16;
typedef s16 HFI_S16;
typedef u32 HFI_U32;
typedef s32 HFI_S32;
typedef u64 HFI_U64;
typedef HFI_U32 HFI_BOOL;
#define HFI_FALSE 0
#define HFI_TRUE (!HFI_FALSE)
typedef HFI_U32 HFI_STATUS;
#define HFI_FAIL 0
#define HFI_SUCCESS 1
#define HFI_ALIGN(a, b) (((b) & ((b) - 1)) ? \
(((a) + (b) - 1) / (b) * (b)) : \
(((a) + (b) - 1) & (~((b) - 1))))
#endif // __H_HFI_DEFINITION_H__

1
driver/vidc/inc/hfi_packet.h
View File

@@ -11,7 +11,6 @@
#include "msm_vidc_core.h"
#include "hfi_command.h"
#include "hfi_property.h"
#include "hfi_definition.h"
u32 get_hfi_port(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port);

212
driver/vidc/inc/hfi_property.h
View File

@@ -18,21 +18,27 @@
#define HFI_PROP_UBWC_BANK_SPREADING 0x03000009
enum hfi_debug_config {
HFI_DEBUG_CONFIG_DEFAULT = 0,
HFI_DEBUG_CONFIG_CLRDBGQ = BIT(0),
HFI_DEBUG_CONFIG_WFI = BIT(1),
HFI_DEBUG_CONFIG_ARM9WD = BIT(2),
HFI_DEBUG_CONFIG_DEFAULT = 0x00000000,
HFI_DEBUG_CONFIG_CLRDBGQ = 0x00000001,
HFI_DEBUG_CONFIG_WFI = 0x00000002,
HFI_DEBUG_CONFIG_ARM9WD = 0x00000004,
};
#define HFI_PROP_DEBUG_CONFIG 0x0300000a
enum hfi_debug_log_level {
HFI_DEBUG_LOG_NONE = 0,
HFI_DEBUG_LOG_ERROR = BIT(0),
HFI_DEBUG_LOG_FATAL = BIT(1),
HFI_DEBUG_LOG_PERF = BIT(2),
HFI_DEBUG_LOG_HIGH = BIT(3),
HFI_DEBUG_LOG_MEDIUM = BIT(4),
HFI_DEBUG_LOG_LOW = BIT(5),
HFI_DEBUG_LOG_NONE = 0x00000000,
HFI_DEBUG_LOG_ERROR = 0x00000001,
HFI_DEBUG_LOG_FATAL = 0x00000002,
HFI_DEBUG_LOG_PERF = 0x00000004,
HFI_DEBUG_LOG_HIGH = 0x00000008,
HFI_DEBUG_LOG_MEDIUM = 0x00000010,
HFI_DEBUG_LOG_LOW = 0x00000020,
};
struct hfi_debug_header {
u32 size;
u32 debug_level;
u32 reserved[2];
};
#define HFI_PROP_DEBUG_LOG_LEVEL 0x0300000b
@@ -60,17 +66,19 @@ enum hfi_color_format {
#define HFI_PROP_SECURE 0x03000102
#define HFI_BITMASK_ALIGN_WIDTH 0xffff0000
#define HFI_BITMASK_ALIGN_HEIGHT 0x0000ffff
#define HFI_PROP_ALIGN_RESOLUTION 0x03000103
#define HFI_BITMASK_BITSTREAM_WIDTH 0xffff0000
#define HFI_BITMASK_BITSTREAM_HEIGHT 0x0000ffff
#define HFI_PROP_BITSTREAM_RESOLUTION 0x03000103
#define HFI_BITMASK_CROP_WIDTH 0xffff0000
#define HFI_BITMASK_CROP_HEIGHT 0x0000ffff
#define HFI_PROP_CROP_RESOLUTION 0x03000104
#define HFI_BITMASK_LINEAR_STRIDE 0xffff0000
#define HFI_BITMASK_LINEAR_SCANLINE 0x0000ffff
#define HFI_PROP_LINEAR_STRIDE_SCANLINE 0x03000104
#define HFI_BITMASK_FRAME_COORDINATE_TOP 0xffff0000
#define HFI_BITMASK_FRAME_COORDINATE_LEFT 0x0000ffff
#define HFI_PROP_CROP_COORDINATE_TOP_LEFT 0x03000105
#define HFI_BITMASK_CROP_RIGHT_OFFSET 0xffff0000
#define HFI_BITMASK_CROP_BOTTOM_OFFSET 0x0000ffff
#define HFI_BITMASK_CROP_LEFT_OFFSET 0xffff0000
#define HFI_BITMASK_CROP_TOP_OFFSET 0x0000ffff
#define HFI_PROP_CROP_OFFSETS 0x03000105
#define HFI_PROP_REALTIME 0x03000106
@@ -83,9 +91,9 @@ enum hfi_avc_profile_type {
};
enum hfi_hevc_profile_type {
HFI_HEVC_HEVC_PROFILE_MAIN = 0,
HFI_HEVC_PROFILE_MAIN_STILL_PICTURE = 1,
HFI_HEVC_PROFILE_MAIN_10 = 2,
HFI_H265_PROFILE_MAIN = 0,
HFI_H265_PROFILE_MAIN_STILL_PICTURE = 1,
HFI_H265_PROFILE_MAIN_10 = 2,
};
enum hfi_vp9_profile_type {
@@ -96,8 +104,8 @@ enum hfi_vp9_profile_type {
};
enum hfi_mpeg2_profile_type {
HFI_MPEG2_PROFILE_SIMPLE = 0,
HFI_MPEG2_PROFILE_MAIN = 1,
HFI_MP2_PROFILE_SIMPLE = 0,
HFI_MP2_PROFILE_MAIN = 1,
};
#define HFI_PROP_PROFILE 0x03000107
@@ -126,53 +134,52 @@ enum hfi_avc_level_type {
};
enum hfi_hevc_level_type {
HFI_HEVC_LEVEL_1 = 0,
HFI_HEVC_LEVEL_2 = 1,
HFI_HEVC_LEVEL_2_1 = 2,
HFI_HEVC_LEVEL_3 = 3,
HFI_HEVC_LEVEL_3_1 = 4,
HFI_HEVC_LEVEL_4 = 5,
HFI_HEVC_LEVEL_4_1 = 6,
HFI_HEVC_LEVEL_5 = 7,
HFI_HEVC_LEVEL_5_1 = 8,
HFI_HEVC_LEVEL_5_2 = 9,
HFI_HEVC_LEVEL_6 = 10,
HFI_HEVC_LEVEL_6_1 = 11,
HFI_HEVC_LEVEL_6_2 = 12,
HFI_H265_LEVEL_1 = 0,
HFI_H265_LEVEL_2 = 1,
HFI_H265_LEVEL_2_1 = 2,
HFI_H265_LEVEL_3 = 3,
HFI_H265_LEVEL_3_1 = 4,
HFI_H265_LEVEL_4 = 5,
HFI_H265_LEVEL_4_1 = 6,
HFI_H265_LEVEL_5 = 7,
HFI_H265_LEVEL_5_1 = 8,
HFI_H265_LEVEL_5_2 = 9,
HFI_H265_LEVEL_6 = 10,
HFI_H265_LEVEL_6_1 = 11,
HFI_H265_LEVEL_6_2 = 12,
};
enum hfi_vp9_level_type {
HFI_VP9_LEVEL_1 = 0,
HFI_VP9_LEVEL_11 = 1,
HFI_VP9_LEVEL_2 = 2,
HFI_VP9_LEVEL_21 = 3,
HFI_VP9_LEVEL_3 = 4,
HFI_VP9_LEVEL_31 = 5,
HFI_VP9_LEVEL_4 = 6,
HFI_VP9_LEVEL_41 = 7,
HFI_VP9_LEVEL_5 = 8,
HFI_VP9_LEVEL_51 = 9,
HFI_VP9_LEVEL_6 = 10,
HFI_VP9_LEVEL_61 = 11,
HFI_VP9_LEVEL_1_0 = 0,
HFI_VP9_LEVEL_1_1 = 1,
HFI_VP9_LEVEL_2_0 = 2,
HFI_VP9_LEVEL_2_1 = 3,
HFI_VP9_LEVEL_3_0 = 4,
HFI_VP9_LEVEL_3_1 = 5,
HFI_VP9_LEVEL_4_0 = 6,
HFI_VP9_LEVEL_4_1 = 7,
HFI_VP9_LEVEL_5_0 = 8,
HFI_VP9_LEVEL_5_1 = 9,
HFI_VP9_LEVEL_6_0 = 10,
HFI_VP9_LEVEL_6_1 = 11,
};
enum hfi_mpeg2_level_type {
HFI_MPEG2_LEVEL_LOW = 0,
HFI_MPEG2_LEVEL_MAIN = 1,
HFI_MPEG2_LEVEL_HIGH_1440 = 2,
HFI_MPEG2_LEVEL_HIGH = 3,
HFI_MP2_LEVEL_LOW = 0,
HFI_MP2_LEVEL_MAIN = 1,
HFI_MP2_LEVEL_HIGH_1440 = 2,
HFI_MP2_LEVEL_HIGH = 3,
};
enum hfi_codec_level_type {
HFI_LEVEL_UNKNOWN = 0xFFFFFFFF,
HFI_LEVEL_NONE = 0xFFFFFFFF,
};
#define HFI_PROP_LEVEL 0x03000108
enum hfi_hevc_tier_type {
HFI_HEVC_TIER_MAIN = 0,
HFI_HEVC_TIER_HIGH = 1,
HFI_H265_TIER_MAIN = 0,
HFI_H265_TIER_HIGH = 1,
};
#define HFI_PROP_TIER 0x03000109
@@ -212,24 +219,25 @@ enum hfi_hevc_tier_type {
#define HFI_PROP_BUFFER_MAX_NUM_REFERENCE 0x03000126
#define HFI_PROP_BUFFER_VUI_RESTRICTION 0x03000127
#define HFI_PROP_MAX_NUM_REORDER_FRAMES 0x03000127
#define HFI_PROP_PIC_ORDER_CNT_TYPE 0x03000128
enum hfi_deblock_mode {
HFI_DB_MODE_DISABLE = 0,
HFI_DB_MODE_SKIP_SLICE_BOUNDARY = BIT(0),
HFI_DB_MODE_ALL_BOUNDARY = BIT(1),
HFI_DEBLOCK_ALL_BOUNDARY = 0x0,
HFI_DEBLOCK_DISABLE = 0x1,
HFI_DEBLOCK_DISABLE_AT_SLICE_BOUNDARY = 0x2,
};
#define HFI_PROP_DEBLOCKING_MODE 0x03000129
enum hfi_rate_control {
HFI_RC_OFF = 0x00000000,
HFI_RC_VBR_CFR = 0x00000001,
HFI_RC_CBR_CFR = 0x00000002,
HFI_RC_CBR_VFR = 0x00000003,
HFI_RC_CQ = 0x00000004,
HFI_RC_VBR_CFR = 0x00000000,
HFI_RC_CBR_CFR = 0x00000001,
HFI_RC_CQ = 0x00000002,
HFI_RC_OFF = 0x00000003,
HFI_RC_CBR_VFR = 0x00000004,
HFI_RC_LOSSLESS = 0x00000005,
HFI_RC_CBR_VFR_LEGACY = 0x00000006,
};
#define HFI_PROP_RATE_CONTROL 0x0300012a
@@ -267,7 +275,7 @@ enum hfi_rate_control {
enum hfi_layer_encoding_type {
HFI_HIER_P_SLIDING_WINDOW = 0x1,
HFI_HIER_P_HYBRID_LTR = 0x2,
HFI_HIER_B = 0x4,
HFI_HIER_B = 0x3,
};
#define HFI_PROP_LAYER_ENCODING_TYPE 0x03000138
@@ -304,16 +312,16 @@ enum hfi_layer_encoding_type {
#define HFI_PROP_MAX_B_FRAMES 0x03000147
enum hfi_quality_mode {
HFI_MODE_MAX_QUALITY = BIT(0),
HFI_MODE_POWER_SAVE = BIT(1),
HFI_MODE_MAX_QUALITY = 0x1,
HFI_MODE_POWER_SAVE = 0x2,
};
#define HFI_PROP_QUALITY_MODE 0x03000148
enum hfi_seq_header_mode {
HFI_SEQ_HEADER_SEPERATE_FRAME = BIT(0),
HFI_SEQ_HEADER_JOINED_WITH_1ST_FRAME = BIT(1),
HFI_SEQ_HEADER_PREFIX_WITH_SYNC_FRAME = BIT(2),
HFI_SEQ_HEADER_METADATA = BIT(3),
HFI_SEQ_HEADER_SEPERATE_FRAME = 0x00000001,
HFI_SEQ_HEADER_JOINED_WITH_1ST_FRAME = 0x00000002,
HFI_SEQ_HEADER_PREFIX_WITH_SYNC_FRAME = 0x00000004,
HFI_SEQ_HEADER_METADATA = 0x00000008,
};
#define HFI_PROP_SEQ_HEADER_MODE 0x03000149
@@ -328,18 +336,18 @@ enum hfi_rotation {
#define HFI_PROP_ROTATION 0x0300014b
enum hfi_flip {
HFI_FLIP_NONE = 0,
HFI_FLIP_HORIZONTAL = BIT(0),
HFI_FLIP_VERTICAL = BIT(1),
HFI_DISABLE_FLIP = 0x00000000,
HFI_HORIZONTAL_FLIP = 0x00000001,
HFI_VERTICAL_FLIP = 0x00000002,
};
#define HFI_PROP_FLIP 0x0300014c
#define HFI_PROP_SCALAR 0x0300014d
enum hfi_blur_types {
HFI_BLUR_NONE = 0,
HFI_BLUR_EXTERNAL = BIT(0),
HFI_BLUR_ADAPTIVE = BIT(1),
HFI_BLUR_NONE = 0x00000000,
HFI_BLUR_EXTERNAL = 0x00000001,
HFI_BLUR_ADAPTIVE = 0x00000002,
};
#define HFI_PROP_BLUR_TYPES 0x0300014e
@@ -354,8 +362,6 @@ enum hfi_blur_types {
#define HFI_PROP_AUD 0x03000151
#define HFI_PROP_VUI_TIMING_INFO 0x03000152
#define HFI_PROP_DPB_LUMA_CHROMA_MISR 0x03000153
#define HFI_PROP_OPB_LUMA_CHROMA_MISR 0x03000154
@@ -368,13 +374,13 @@ enum hfi_blur_types {
#define HFI_PROP_SIGNAL_COLOR_INFO 0x03000155
enum hfi_interlace_info {
HFI_INTERLACE_INFO_NONE = 0,
HFI_FRAME_PROGRESSIVE = BIT(0),
HFI_FRAME_MBAFF = BIT(1),
HFI_FRAME_INTERLEAVE_TOPFIELD_FIRST = BIT(2),
HFI_FRAME_INTERLEAVE_BOTTOMFIELD_FIRST = BIT(3),
HFI_FRAME_INTERLACE_TOPFIELD_FIRST = BIT(4),
HFI_FRAME_INTERLACE_BOTTOMFIELD_FIRST = BIT(5),
HFI_INTERLACE_INFO_NONE = 0x00000000,
HFI_FRAME_PROGRESSIVE = 0x00000001,
HFI_FRAME_MBAFF = 0x00000002,
HFI_FRAME_INTERLEAVE_TOPFIELD_FIRST = 0x00000004,
HFI_FRAME_INTERLEAVE_BOTTOMFIELD_FIRST = 0x00000008,
HFI_FRAME_INTERLACE_TOPFIELD_FIRST = 0x00000010,
HFI_FRAME_INTERLACE_BOTTOMFIELD_FIRST = 0x00000020,
};
#define HFI_PROP_INTERLACE_INFO 0x03000156
@@ -403,12 +409,12 @@ enum hfi_interlace_info {
#define HFI_PROP_HISTOGRAM_INFO 0x03000161
enum hfi_picture_type {
HFI_PICTURE_TYPE_IDR = BIT(0),
HFI_PICTURE_TYPE_P = BIT(1),
HFI_PICTURE_TYPE_B = BIT(2),
HFI_PICTURE_TYPE_I = BIT(3),
HFI_PICTURE_TYPE_CRA = BIT(4),
HFI_PICTURE_TYPE_BLA = BIT(5),
HFI_PICTURE_IDR = 0x00000001,
HFI_PICTURE_P = 0x00000002,
HFI_PICTURE_B = 0x00000004,
HFI_PICTURE_I = 0x00000008,
HFI_PICTURE_CRA = 0x00000010,
HFI_PICTURE_BLA = 0x00000020,
};
#define HFI_PROP_PICTURE_TYPE 0x03000162
@@ -420,13 +426,13 @@ enum hfi_picture_type {
#define HFI_PROP_SEI_STREAM_USERDATA 0x03000166
#define HFI_PROP_CVP_STAT_INFO 0x03000167
#define HFI_PROP_EVA_STAT_INFO 0x03000167
#define HFI_PROP_DEC_DEFAULT_HEADER 0x03000168
#define HFI_PROP_DEC_START_FROM_RAP_FRAME 0x03000169
#define HFI_PROP_TAG_NOT_PROPAGATED_TO_OUTPUT 0x0300016a
#define HFI_PROP_NO_OUTPUT 0x0300016a
#define HFI_PROP_BUFFER_TAG 0x0300016b
@@ -454,7 +460,13 @@ enum hfi_picture_type {
#define HFI_ERROR_MAX_SESSIONS 0x04000002
#define HFI_ERROR_UNSUPPORTED 0x04000003
#define HFI_ERROR_FATAL 0x04000003
#define HFI_ERROR_INVALID_STATE 0x04000004
#define HFI_ERROR_INSUFFICIENT_RESOURCES 0x04000005
#define HFI_ERROR_BUFFER_NOT_SET 0x04000006
#define HFI_SESSION_ERROR_END 0x04FFFFFF
@@ -464,13 +476,15 @@ enum hfi_picture_type {
#define HFI_SYS_ERROR_NOC 0x05000002
#define HFI_SYS_ERROR_FATAL 0x05000003
#define HFI_SYSTEM_ERROR_END 0x05FFFFFF
#define HFI_INFORMATION_BEGIN 0x06000000
#define HFI_INFO_UNSUPPORTED 0x06000001
#define HFI_INFO_BITSTREAM_CORRUPT 0x06000002
#define HFI_INFO_DATA_CORRUPT 0x06000002
#define HFI_INFORMATION_END 0x06FFFFFF

11
driver/vidc/inc/msm_vidc_internal.h
View File

@@ -321,6 +321,8 @@ enum msm_vidc_inst_capability_type {
CHROMA_QP_INDEX_OFFSET,
DISPLAY_DELAY_ENABLE,
DISPLAY_DELAY,
CONCEAL_COLOR_8BIT,
CONCEAL_COLOR_10BIT,
INST_CAP_MAX,
};
@@ -525,8 +527,8 @@ struct msm_vidc_color_info {
};
struct msm_vidc_crop {
u32 x;
u32 y;
u32 left;
u32 top;
u32 width;
u32 height;
};
@@ -534,11 +536,6 @@ struct msm_vidc_crop {
struct msm_vidc_properties {
u32 frame_rate;
u32 operating_rate;
u32 bit_rate;
u32 profile;
u32 level;
u32 entropy_mode;
u32 rc_type;
};
struct msm_vidc_subscription_params {

2
driver/vidc/src/hfi_packet.c
View File

@@ -313,7 +313,7 @@ int hfi_packet_sys_init(struct msm_vidc_core *core,
goto err_sys_init;
/* HFI_CMD_SYSTEM_INIT */
payload = HFI_VIDEO_ARCH_OX;
payload = HFI_VIDEO_ARCH_LX;
rc = hfi_create_packet(pkt, pkt_size,
HFI_CMD_INIT,
(HFI_HOST_FLAGS_RESPONSE_REQUIRED |

610
driver/vidc/src/msm_vdec.c
View File

@@ -14,23 +14,26 @@
#include "msm_vidc_platform.h"
#include "msm_vidc_control.h"
#include "msm_vidc_debug.h"
#include "msm_vidc_control.h"
#include "venus_hfi.h"
#include "hfi_packet.h"
u32 msm_vdec_subscribe_for_port_settings_change[] = {
HFI_PROP_ALIGN_RESOLUTION,
HFI_PROP_CROP_COORDINATE_TOP_LEFT,
HFI_PROP_CROP_RESOLUTION,
HFI_PROP_BITSTREAM_RESOLUTION,
HFI_PROP_CROP_OFFSETS,
HFI_PROP_LUMA_CHROMA_BIT_DEPTH,
HFI_PROP_CABAC_SESSION,
HFI_PROP_CODED_FRAMES,
HFI_PROP_BUFFER_FW_MIN_OUTPUT_COUNT,
HFI_PROP_PIC_ORDER_CNT_TYPE,
HFI_PROP_SIGNAL_COLOR_INFO,
HFI_PROP_PROFILE,
HFI_PROP_LEVEL,
HFI_PROP_TIER,
};
u32 msm_vdec_subscribe_for_properties[] = {
HFI_PROP_TAG_NOT_PROPAGATED_TO_OUTPUT,
HFI_PROP_NO_OUTPUT,
};
u32 msm_vdec_subscribe_for_metadata[] = {
@@ -68,79 +71,103 @@ exit:
return rc;
}
static int msm_vdec_set_resolution(struct msm_vidc_inst *inst,
static int msm_vdec_set_bitstream_resolution(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 resolution;
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
resolution = inst->fmts[port].fmt.pix_mp.width << 16 |
inst->fmts[port].fmt.pix_mp.height;
resolution = inst->fmts[INPUT_PORT].fmt.pix_mp.width << 16 |
inst->fmts[INPUT_PORT].fmt.pix_mp.height;
s_vpr_h(inst->sid, "%s: width: %d height: %d\n", __func__,
inst->fmts[INPUT_PORT].fmt.pix_mp.width,
inst->fmts[INPUT_PORT].fmt.pix_mp.height);
rc = venus_hfi_session_property(inst,
HFI_PROP_ALIGN_RESOLUTION,
HFI_PROP_BITSTREAM_RESOLUTION,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_U32,
&resolution,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_crop_top_left(struct msm_vidc_inst *inst,
static int msm_vdec_set_linear_stride_scanline(struct msm_vidc_inst *inst)
{
int rc = 0;
u32 stride_y, scanline_y, stride_uv, scanline_uv;
u32 payload[2];
if (inst->fmts[OUTPUT_PORT].fmt.pix_mp.pixelformat !=
V4L2_PIX_FMT_NV12 &&
inst->fmts[OUTPUT_PORT].fmt.pix_mp.pixelformat !=
V4L2_PIX_FMT_VIDC_P010)
return 0;
stride_y = inst->fmts[OUTPUT_PORT].fmt.pix_mp.width;
scanline_y = inst->fmts[OUTPUT_PORT].fmt.pix_mp.height;
stride_uv = stride_y;
scanline_uv = scanline_y / 2;
payload[0] = stride_y << 16 | scanline_y;
payload[1] = stride_uv << 16 | scanline_uv;
s_vpr_h(inst->sid, "%s: stride_y: %d scanline_y: %d "
"stride_uv: %d, scanline_uv: %d", __func__,
stride_y, scanline_y, stride_uv, scanline_uv);
rc = venus_hfi_session_property(inst,
HFI_PROP_LINEAR_STRIDE_SCANLINE,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, OUTPUT_PORT),
HFI_PAYLOAD_U64,
&payload,
sizeof(u64));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
}
static int msm_vdec_set_crop_offsets(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 crop_top_left;
u32 left_offset, top_offset, right_offset, bottom_offset;
u32 payload[2];
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
if (inst->fmts[INPUT_PORT].fmt.pix_mp.width <
inst->crop.width)
return -EINVAL;
}
crop_top_left = 0;
if (inst->fmts[INPUT_PORT].fmt.pix_mp.height <
inst->crop.height)
return -EINVAL;
left_offset = inst->crop.left;
top_offset = inst->crop.top;
right_offset = (inst->fmts[INPUT_PORT].fmt.pix_mp.width -
inst->crop.width);
bottom_offset = (inst->fmts[INPUT_PORT].fmt.pix_mp.height -
inst->crop.height);
payload[0] = right_offset << 16 | bottom_offset;
payload[1] = left_offset << 16 | top_offset;
s_vpr_h(inst->sid, "%s: left_offset: %d top_offset: %d "
"right_offset: %d bottom_offset: %d", __func__,
left_offset, top_offset, right_offset, bottom_offset);
rc = venus_hfi_session_property(inst,
HFI_PROP_CROP_COORDINATE_TOP_LEFT,
HFI_PROP_CROP_OFFSETS,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_U32,
&crop_top_left,
sizeof(u32));
HFI_PAYLOAD_U64,
&payload,
sizeof(u64));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_crop_resolution(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 crop;
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
/* output buffer resolution is nothing but crop */
crop = inst->fmts[OUTPUT_PORT].fmt.pix_mp.width << 16 |
inst->fmts[OUTPUT_PORT].fmt.pix_mp.height;
rc = venus_hfi_session_property(inst,
HFI_PROP_CROP_RESOLUTION,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_U32,
&crop,
sizeof(u32));
if (rc)
return rc;
return 0;
}
static int msm_vdec_set_bit_depth(struct msm_vidc_inst *inst,
@@ -159,6 +186,7 @@ static int msm_vdec_set_bit_depth(struct msm_vidc_inst *inst,
if (colorformat == V4L2_PIX_FMT_VIDC_P010 ||
colorformat == V4L2_PIX_FMT_VIDC_TP10C)
bitdepth = 10 << 16 | 10;
s_vpr_h(inst->sid, "%s: bit depth: %d", __func__, bitdepth);
rc = venus_hfi_session_property(inst,
HFI_PROP_LUMA_CHROMA_BIT_DEPTH,
HFI_HOST_FLAGS_NONE,
@@ -167,8 +195,9 @@ static int msm_vdec_set_bit_depth(struct msm_vidc_inst *inst,
&bitdepth,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_cabac(struct msm_vidc_inst *inst,
@@ -182,6 +211,10 @@ static int msm_vdec_set_cabac(struct msm_vidc_inst *inst,
return -EINVAL;
}
rc = msm_vidc_v4l2_menu_to_hfi(inst, ENTROPY_MODE, &cabac);
if (rc)
return rc;
s_vpr_h(inst->sid, "%s: entropy mode: %d", __func__, cabac);
rc = venus_hfi_session_property(inst,
HFI_PROP_CABAC_SESSION,
HFI_HOST_FLAGS_NONE,
@@ -190,8 +223,9 @@ static int msm_vdec_set_cabac(struct msm_vidc_inst *inst,
&cabac,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_coded_frames(struct msm_vidc_inst *inst,
@@ -206,7 +240,8 @@ static int msm_vdec_set_coded_frames(struct msm_vidc_inst *inst,
}
/* (mb_adaptive_frame_field_flag << 1) | frame_mbs_only_flag */
coded_frames = 1;
coded_frames = 0;
s_vpr_h(inst->sid, "%s: coded frames: %d", __func__, coded_frames);
rc = venus_hfi_session_property(inst,
HFI_PROP_CODED_FRAMES,
HFI_HOST_FLAGS_NONE,
@@ -215,8 +250,9 @@ static int msm_vdec_set_coded_frames(struct msm_vidc_inst *inst,
&coded_frames,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_min_output_count(struct msm_vidc_inst *inst,
@@ -231,6 +267,8 @@ static int msm_vdec_set_min_output_count(struct msm_vidc_inst *inst,
}
min_output = inst->buffers.output.min_count;
s_vpr_h(inst->sid, "%s: firmware min output count: %d",
__func__, min_output);
rc = venus_hfi_session_property(inst,
HFI_PROP_BUFFER_FW_MIN_OUTPUT_COUNT,
HFI_HOST_FLAGS_NONE,
@@ -239,21 +277,23 @@ static int msm_vdec_set_min_output_count(struct msm_vidc_inst *inst,
&min_output,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_picture_order_count(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 poc = 1;
u32 poc = 0;
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
s_vpr_h(inst->sid, "%s: picture order count: %d", __func__, poc);
rc = venus_hfi_session_property(inst,
HFI_PROP_PIC_ORDER_CNT_TYPE,
HFI_HOST_FLAGS_NONE,
@@ -262,8 +302,9 @@ static int msm_vdec_set_picture_order_count(struct msm_vidc_inst *inst,
&poc,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_colorspace(struct msm_vidc_inst *inst,
@@ -278,6 +319,7 @@ static int msm_vdec_set_colorspace(struct msm_vidc_inst *inst,
}
colorspace = inst->fmts[OUTPUT_PORT].fmt.pix_mp.colorspace;
s_vpr_h(inst->sid, "%s: colorspace: %d", __func__, colorspace);
rc = venus_hfi_session_property(inst,
HFI_PROP_SIGNAL_COLOR_INFO,
HFI_HOST_FLAGS_NONE,
@@ -286,152 +328,353 @@ static int msm_vdec_set_colorspace(struct msm_vidc_inst *inst,
&colorspace,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_colorformat(struct msm_vidc_inst *inst,
static int msm_vdec_set_profile(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 profile;
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
profile = inst->capabilities->cap[PROFILE].value;
s_vpr_h(inst->sid, "%s: profile: %d", __func__, profile);
rc = venus_hfi_session_property(inst,
HFI_PROP_PROFILE,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_U32_ENUM,
&profile,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
}
static int msm_vdec_set_level(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 level;
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
level = inst->capabilities->cap[LEVEL].value;
s_vpr_h(inst->sid, "%s: level: %d", __func__, level);
rc = venus_hfi_session_property(inst,
HFI_PROP_LEVEL,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_U32_ENUM,
&level,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
}
static int msm_vdec_set_tier(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 tier;
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
tier = inst->capabilities->cap[HEVC_TIER].value;
s_vpr_h(inst->sid, "%s: tier: %d", __func__, tier);
rc = venus_hfi_session_property(inst,
HFI_PROP_TIER,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_U32_ENUM,
&tier,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
}
static int msm_vdec_set_colorformat(struct msm_vidc_inst *inst)
{
int rc = 0;
u32 pixelformat;
enum msm_vidc_colorformat_type colorformat;
u32 hfi_colorformat;
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
pixelformat = inst->fmts[OUTPUT_PORT].fmt.pix_mp.pixelformat;
if (pixelformat != V4L2_PIX_FMT_VIDC_NV12C &&
pixelformat != V4L2_PIX_FMT_VIDC_TP10C) {
s_vpr_e(inst->sid, "%s: invalid pixelformat %#x\n",
__func__, pixelformat);
return -EINVAL;
}
colorformat = v4l2_colorformat_to_driver(pixelformat, __func__);
hfi_colorformat = get_hfi_colorformat(inst, colorformat);
s_vpr_h(inst->sid, "%s: hfi colorformat: %d",
__func__, hfi_colorformat);
rc = venus_hfi_session_property(inst,
HFI_PROP_COLOR_FORMAT,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
get_hfi_port(inst, OUTPUT_PORT),
HFI_PAYLOAD_U32,
&hfi_colorformat,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_stage(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
static int msm_vdec_set_stage(struct msm_vidc_inst *inst)
{
int rc = 0;
u32 stage = 0;
struct msm_vidc_core *core = inst->core;
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
rc = call_session_op(core, decide_work_mode, inst);
if (rc) {
s_vpr_e(inst->sid, "%s: decide_work_mode failed %d\n",
__func__, port);
__func__);
return -EINVAL;
}
stage = inst->stage;
s_vpr_h(inst->sid, "%s: stage: %d", __func__, stage);
rc = venus_hfi_session_property(inst,
HFI_PROP_STAGE,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PORT_NONE,
HFI_PAYLOAD_U32,
&inst->stage,
&stage,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_pipe(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
static int msm_vdec_set_pipe(struct msm_vidc_inst *inst)
{
int rc = 0;
u32 pipe;
struct msm_vidc_core *core = inst->core;
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
rc = call_session_op(core, decide_work_route, inst);
if (rc) {
s_vpr_e(inst->sid, "%s: decide_work_route failed %d\n",
__func__, port);
s_vpr_e(inst->sid, "%s: decide_work_route failed\n",
__func__);
return -EINVAL;
}
pipe = inst->pipe;
s_vpr_h(inst->sid, "%s: pipe: %d", __func__, pipe);
rc = venus_hfi_session_property(inst,
HFI_PROP_PIPE,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PORT_NONE,
HFI_PAYLOAD_U32,
&inst->pipe,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
}
static int msm_vdec_set_output_order(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 output_order;
if (port != INPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
output_order = inst->capabilities->cap[DISPLAY_DELAY_ENABLE].value;
s_vpr_h(inst->sid, "%s: output order: %d", __func__, output_order);
rc = venus_hfi_session_property(inst,
HFI_PROP_DECODE_ORDER_OUTPUT,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_U32,
&output_order,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
}
static int msm_vdec_set_secure_mode(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 secure_mode;
secure_mode = inst->capabilities->cap[SECURE_MODE].value;
s_vpr_h(inst->sid, "%s: secure mode: %d", __func__, secure_mode);
rc = venus_hfi_session_property(inst,
HFI_PROP_SECURE,
HFI_HOST_FLAGS_NONE,
HFI_PORT_NONE,
HFI_PAYLOAD_U32,
&secure_mode,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
}
static int msm_vdec_set_thumbnail_mode(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 thumbnail_mode = 0;
if (port != INPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
s_vpr_h(inst->sid, "%s: thumbnail mode: %d", __func__, thumbnail_mode);
rc = venus_hfi_session_property(inst,
HFI_PROP_THUMBNAIL_MODE,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_U32,
&thumbnail_mode,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
}
static int msm_vdec_set_realtime(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 realtime = 1; //todo
if (port != INPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
s_vpr_h(inst->sid, "%s: priority: %d", __func__, realtime);
rc = venus_hfi_session_property(inst,
HFI_PROP_REALTIME,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_U32,
&realtime,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
}
static int msm_vdec_set_conceal_color_8bit(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 conceal_color_8bit;
if (port != INPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
conceal_color_8bit = inst->capabilities->cap[CONCEAL_COLOR_8BIT].value;
s_vpr_h(inst->sid, "%s: conceal color 8bit: %#x",
__func__, conceal_color_8bit);
rc = venus_hfi_session_property(inst,
HFI_PROP_CONCEAL_COLOR_8BIT,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_32_PACKED,
&conceal_color_8bit,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
}
static int msm_vdec_set_conceal_color_10bit(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 conceal_color_10bit;
if (port != INPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
conceal_color_10bit = inst->capabilities->cap[CONCEAL_COLOR_8BIT].value;
s_vpr_h(inst->sid, "%s: conceal color 10bit: %#x",
__func__, conceal_color_10bit);
rc = venus_hfi_session_property(inst,
HFI_PROP_CONCEAL_COLOR_10BIT,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_32_PACKED,
&conceal_color_10bit,
sizeof(u32));
if (rc)
s_vpr_e(inst->sid, "%s: set property failed\n", __func__);
return rc;
return 0;
}
static int msm_vdec_set_input_properties(struct msm_vidc_inst *inst)
{
int rc = 0;
int i = 0;
d_vpr_h("%s()\n", __func__);
if (!inst) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
for (i = 0; i < ARRAY_SIZE(msm_vdec_subscribe_for_port_settings_change);
i++) {
switch (msm_vdec_subscribe_for_port_settings_change[i]) {
case HFI_PROP_ALIGN_RESOLUTION:
rc = msm_vdec_set_resolution(inst, INPUT_PORT);
break;
case HFI_PROP_CROP_COORDINATE_TOP_LEFT:
rc = msm_vdec_set_crop_top_left(inst, INPUT_PORT);
break;
case HFI_PROP_CROP_RESOLUTION:
rc = msm_vdec_set_crop_resolution(inst, INPUT_PORT);
break;
case HFI_PROP_LUMA_CHROMA_BIT_DEPTH:
rc = msm_vdec_set_bit_depth(inst, INPUT_PORT);
break;
case HFI_PROP_CABAC_SESSION:
rc = msm_vdec_set_cabac(inst, INPUT_PORT);
break;
case HFI_PROP_CODED_FRAMES:
rc = msm_vdec_set_coded_frames(inst, INPUT_PORT);
break;
case HFI_PROP_BUFFER_FW_MIN_OUTPUT_COUNT:
rc = msm_vdec_set_min_output_count(inst, INPUT_PORT);
break;
case HFI_PROP_PIC_ORDER_CNT_TYPE:
rc = msm_vdec_set_picture_order_count(inst, INPUT_PORT);
break;
case HFI_PROP_SIGNAL_COLOR_INFO:
rc = msm_vdec_set_colorspace(inst, INPUT_PORT);
break;
default:
d_vpr_e("%s: unknown property %#x\n", __func__,
msm_vdec_subscribe_for_port_settings_change[i]);
rc = -EINVAL;
break;
}
}
rc = msm_vdec_set_output_order(inst, INPUT_PORT);
if (rc)
return rc;
rc = msm_vdec_set_secure_mode(inst, INPUT_PORT);
if (rc)
return rc;
rc = msm_vdec_set_thumbnail_mode(inst, INPUT_PORT);
if (rc)
return rc;
rc = msm_vdec_set_realtime(inst, INPUT_PORT);
if (rc)
return rc;
rc = msm_vdec_set_conceal_color_8bit(inst, INPUT_PORT);
if (rc)
return rc;
rc = msm_vdec_set_conceal_color_10bit(inst, INPUT_PORT);
if (rc)
return rc;
return rc;
}
@@ -439,63 +682,27 @@ static int msm_vdec_set_input_properties(struct msm_vidc_inst *inst)
static int msm_vdec_set_output_properties(struct msm_vidc_inst *inst)
{
int rc = 0;
int i = 0;
d_vpr_h("%s()\n", __func__);
if (!inst) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
rc = msm_vdec_set_colorformat(inst, OUTPUT_PORT);
rc = msm_vdec_set_colorformat(inst);
if (rc)
return rc;
rc = msm_vdec_set_stage(inst, OUTPUT_PORT);
rc = msm_vdec_set_stage(inst);
if (rc)
return rc;
rc = msm_vdec_set_pipe(inst, OUTPUT_PORT);
rc = msm_vdec_set_pipe(inst);
if (rc)
return rc;
for (i = 0; i < ARRAY_SIZE(msm_vdec_subscribe_for_port_settings_change);
i++) {
switch (msm_vdec_subscribe_for_port_settings_change[i]) {
case HFI_PROP_ALIGN_RESOLUTION:
rc = msm_vdec_set_resolution(inst, OUTPUT_PORT);
break;
case HFI_PROP_CROP_COORDINATE_TOP_LEFT:
rc = msm_vdec_set_crop_top_left(inst, OUTPUT_PORT);
break;
case HFI_PROP_CROP_RESOLUTION:
rc = msm_vdec_set_crop_resolution(inst, OUTPUT_PORT);
break;
case HFI_PROP_LUMA_CHROMA_BIT_DEPTH:
rc = msm_vdec_set_bit_depth(inst, OUTPUT_PORT);
break;
case HFI_PROP_CABAC_SESSION:
rc = msm_vdec_set_cabac(inst, OUTPUT_PORT);
break;
case HFI_PROP_CODED_FRAMES:
rc = msm_vdec_set_coded_frames(inst, OUTPUT_PORT);
break;
case HFI_PROP_BUFFER_FW_MIN_OUTPUT_COUNT:
rc = msm_vdec_set_min_output_count(inst, OUTPUT_PORT);
break;
case HFI_PROP_PIC_ORDER_CNT_TYPE:
rc = msm_vdec_set_picture_order_count(inst, OUTPUT_PORT);
break;
case HFI_PROP_SIGNAL_COLOR_INFO:
rc = msm_vdec_set_colorspace(inst, OUTPUT_PORT);
break;
default:
d_vpr_e("%s: unknown property %#x\n", __func__,
msm_vdec_subscribe_for_port_settings_change[i]);
rc = -EINVAL;
break;
}
}
rc = msm_vdec_set_linear_stride_scanline(inst);
if (rc)
return rc;
return rc;
}
@@ -664,6 +871,50 @@ static int msm_vdec_port_settings_subscription(struct msm_vidc_inst *inst,
(ARRAY_SIZE(msm_vdec_subscribe_for_port_settings_change) + 1) *
sizeof(u32));
for (i = 0; i < ARRAY_SIZE(msm_vdec_subscribe_for_port_settings_change);
i++) {
switch (msm_vdec_subscribe_for_port_settings_change[i]) {
case HFI_PROP_BITSTREAM_RESOLUTION:
rc = msm_vdec_set_bitstream_resolution(inst, port);
break;
case HFI_PROP_CROP_OFFSETS:
rc = msm_vdec_set_crop_offsets(inst, port);
break;
case HFI_PROP_LUMA_CHROMA_BIT_DEPTH:
rc = msm_vdec_set_bit_depth(inst, port);
break;
case HFI_PROP_CABAC_SESSION:
rc = msm_vdec_set_cabac(inst, port);
break;
case HFI_PROP_CODED_FRAMES:
rc = msm_vdec_set_coded_frames(inst, port);
break;
case HFI_PROP_BUFFER_FW_MIN_OUTPUT_COUNT:
rc = msm_vdec_set_min_output_count(inst, port);
break;
case HFI_PROP_PIC_ORDER_CNT_TYPE:
rc = msm_vdec_set_picture_order_count(inst, port);
break;
case HFI_PROP_SIGNAL_COLOR_INFO:
rc = msm_vdec_set_colorspace(inst, port);
break;
case HFI_PROP_PROFILE:
rc = msm_vdec_set_profile(inst, port);
break;
case HFI_PROP_LEVEL:
rc = msm_vdec_set_level(inst, port);
break;
case HFI_PROP_TIER:
rc = msm_vdec_set_tier(inst, port);
break;
default:
d_vpr_e("%s: unknown property %#x\n", __func__,
msm_vdec_subscribe_for_port_settings_change[i]);
rc = -EINVAL;
break;
}
}
return rc;
}
@@ -812,11 +1063,10 @@ int msm_vdec_start_input(struct msm_vidc_inst *inst)
//msm_vidc_scale_power(inst);
rc = msm_vdec_create_input_internal_buffers(inst);
rc = 0; // TODO
if (rc)
goto error;
rc = msm_vdec_queue_input_internal_buffers(inst);
rc = 0; // TODO
if (rc)
goto error;
@@ -978,7 +1228,7 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f)
fmt->fmt.pix_mp.plane_fmt[0].sizeimage;
/* update crop dimensions */
inst->crop.x = inst->crop.y = 0;
inst->crop.left = inst->crop.top = 0;
inst->crop.width = f->fmt.pix_mp.width;
inst->crop.height = f->fmt.pix_mp.height;
@@ -1215,7 +1465,7 @@ int msm_vdec_inst_init(struct msm_vidc_inst *inst)
inst->buffers.input.extra_count;
inst->buffers.input.size = f->fmt.pix_mp.plane_fmt[0].sizeimage;
inst->crop.x = inst->crop.y = 0;
inst->crop.left = inst->crop.top = 0;
inst->crop.width = f->fmt.pix_mp.width;
inst->crop.height = f->fmt.pix_mp.height;

69
driver/vidc/src/msm_venc.c
View File

@@ -19,19 +19,17 @@
u32 msm_venc_input_set_prop[] = {
HFI_PROP_COLOR_FORMAT,
HFI_PROP_ALIGN_RESOLUTION,
HFI_PROP_CROP_COORDINATE_TOP_LEFT,
HFI_PROP_CROP_RESOLUTION,
HFI_PROP_BITSTREAM_RESOLUTION,
HFI_PROP_CROP_OFFSETS,
};
u32 msm_venc_output_set_prop[] = {
HFI_PROP_ALIGN_RESOLUTION,
HFI_PROP_CROP_COORDINATE_TOP_LEFT,
HFI_PROP_CROP_RESOLUTION,
HFI_PROP_BITSTREAM_RESOLUTION,
HFI_PROP_CROP_OFFSETS,
};
u32 msm_venc_input_subscribe_for_properties[] = {
HFI_PROP_TAG_NOT_PROPAGATED_TO_OUTPUT,
HFI_PROP_NO_OUTPUT,
};
u32 msm_venc_deliver_as_metadata[] = {
@@ -39,7 +37,7 @@ u32 msm_venc_deliver_as_metadata[] = {
HFI_PROP_SEI_MASTERING_DISPLAY_COLOUR,
HFI_PROP_SEI_CONTENT_LIGHT_LEVEL,
HFI_PROP_SEI_HDR10PLUS_USERDATA,
HFI_PROP_CVP_STAT_INFO,
HFI_PROP_EVA_STAT_INFO,
};
u32 msm_venc_subscribe_for_metadata[] = {
@@ -83,6 +81,7 @@ exit:
return rc;
}
/* todo: add logs for each property once finalised */
static int msm_venc_set_colorformat(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
@@ -131,7 +130,7 @@ static int msm_venc_set_resolution(struct msm_vidc_inst *inst,
resolution = inst->fmts[port].fmt.pix_mp.width << 16 |
inst->fmts[port].fmt.pix_mp.height;
rc = venus_hfi_session_property(inst,
HFI_PROP_ALIGN_RESOLUTION,
HFI_PROP_BITSTREAM_RESOLUTION,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_32_PACKED,
@@ -142,31 +141,7 @@ static int msm_venc_set_resolution(struct msm_vidc_inst *inst,
return 0;
}
static int msm_venc_set_crop_top_left(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
u32 crop_top_left;
if (port != INPUT_PORT && port != OUTPUT_PORT) {
s_vpr_e(inst->sid, "%s: invalid port %d\n", __func__, port);
return -EINVAL;
}
crop_top_left = 0;
rc = venus_hfi_session_property(inst,
HFI_PROP_CROP_COORDINATE_TOP_LEFT,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_32_PACKED,
&crop_top_left,
sizeof(u32));
if (rc)
return rc;
return 0;
}
static int msm_venc_set_crop_resolution(struct msm_vidc_inst *inst,
static int msm_venc_set_crop_offsets(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
int rc = 0;
@@ -177,11 +152,11 @@ static int msm_venc_set_crop_resolution(struct msm_vidc_inst *inst,
return -EINVAL;
}
/* output buffer resolution is nothing but crop */
/* TODO: recheck later */
crop = inst->fmts[INPUT_PORT].fmt.pix_mp.width << 16 |
inst->fmts[INPUT_PORT].fmt.pix_mp.height;
rc = venus_hfi_session_property(inst,
HFI_PROP_CROP_RESOLUTION,
HFI_PROP_CROP_OFFSETS,
HFI_HOST_FLAGS_NONE,
get_hfi_port(inst, port),
HFI_PAYLOAD_32_PACKED,
@@ -257,14 +232,11 @@ static int msm_venc_set_input_properties(struct msm_vidc_inst *inst)
case HFI_PROP_COLOR_FORMAT:
rc = msm_venc_set_colorformat(inst, INPUT_PORT);
break;
case HFI_PROP_ALIGN_RESOLUTION:
case HFI_PROP_BITSTREAM_RESOLUTION:
rc = msm_venc_set_resolution(inst, INPUT_PORT);
break;
case HFI_PROP_CROP_COORDINATE_TOP_LEFT:
rc = msm_venc_set_crop_top_left(inst, INPUT_PORT);
break;
case HFI_PROP_CROP_RESOLUTION:
rc = msm_venc_set_crop_resolution(inst, INPUT_PORT);
case HFI_PROP_CROP_OFFSETS:
rc = msm_venc_set_crop_offsets(inst, INPUT_PORT);
break;
default:
d_vpr_e("%s: unknown property %#x\n", __func__,
@@ -300,14 +272,11 @@ static int msm_venc_set_output_properties(struct msm_vidc_inst *inst)
for (i = 0; i < ARRAY_SIZE(msm_venc_output_set_prop);
i++) {
switch (msm_venc_output_set_prop[i]) {
case HFI_PROP_ALIGN_RESOLUTION:
case HFI_PROP_BITSTREAM_RESOLUTION:
rc = msm_venc_set_resolution(inst, OUTPUT_PORT);
break;
case HFI_PROP_CROP_COORDINATE_TOP_LEFT:
rc = msm_venc_set_crop_top_left(inst, OUTPUT_PORT);
break;
case HFI_PROP_CROP_RESOLUTION:
rc = msm_venc_set_crop_resolution(inst, OUTPUT_PORT);
case HFI_PROP_CROP_OFFSETS:
rc = msm_venc_set_crop_offsets(inst, OUTPUT_PORT);
break;
default:
d_vpr_e("%s: unknown property %#x\n", __func__,
@@ -826,7 +795,7 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f)
goto err_invalid_fmt;
/* update crop dimensions */
inst->crop.x = inst->crop.y = 0;
inst->crop.left = inst->crop.top = 0;
inst->crop.width = f->fmt.pix_mp.width;
inst->crop.height = f->fmt.pix_mp.height;
@@ -988,7 +957,7 @@ int msm_venc_inst_init(struct msm_vidc_inst *inst)
inst->buffers.output.extra_count;
inst->buffers.output.size = f->fmt.pix_mp.plane_fmt[0].sizeimage;
inst->crop.x = inst->crop.y = 0;
inst->crop.left = inst->crop.top = 0;
inst->crop.width = f->fmt.pix_mp.width;
inst->crop.height = f->fmt.pix_mp.height;

2
driver/vidc/src/msm_vidc_control.c
View File

@@ -880,7 +880,7 @@ int msm_vidc_v4l2_menu_to_hfi(struct msm_vidc_inst *inst,
break;
default:
s_vpr_e(inst->sid,
"%s: invalid ctrl with cap_id\n", cap_id);
"%s: invalid ctrl with cap_id %d\n", __func__, cap_id);
return -EINVAL;
}
return 0;

36
driver/vidc/src/venus_hfi_response.c
View File

@@ -100,8 +100,20 @@ static int handle_session_error(struct msm_vidc_inst *inst,
case HFI_ERROR_MAX_SESSIONS:
error = "exceeded max sessions";
break;
case HFI_ERROR_UNSUPPORTED:
error = "unsupported bitstream";
case HFI_ERROR_UNKNOWN_SESSION:
error = "unknown session id";
break;
case HFI_ERROR_INVALID_STATE:
error = "invalid operation for current state";
break;
case HFI_ERROR_INSUFFICIENT_RESOURCES:
error = "insufficient resources";
break;
case HFI_ERROR_BUFFER_NOT_SET:
error = "internal buffers not set";
break;
case HFI_ERROR_FATAL:
error = "fatal error";
break;
default:
error = "unknown";
@@ -274,7 +286,8 @@ static int handle_input_buffer(struct msm_vidc_inst *inst,
buf->data_size = buffer->data_size;
buf->attr &= ~MSM_VIDC_ATTR_QUEUED;
buf->flags = 0;
if (buffer->flags & HFI_BUF_FW_FLAG_CORRUPT) {
//todo:
/*if (buffer->flags & HFI_BUF_FW_FLAG_CORRUPT) {
s_vpr_h(inst->sid, "%s: data corrupted\n", __func__);
buf->flags |= MSM_VIDC_BUF_FLAG_ERROR;
}
@@ -282,7 +295,7 @@ static int handle_input_buffer(struct msm_vidc_inst *inst,
s_vpr_e(inst->sid, "%s: unsupported input\n", __func__);
buf->flags |= MSM_VIDC_BUF_FLAG_ERROR;
// TODO: move inst->state to error state
}
}*/
print_vidc_buffer(VIDC_HIGH, "EBD", inst, buf);
msm_vidc_vb2_buffer_done(inst, buf);
@@ -326,16 +339,19 @@ static int handle_output_buffer(struct msm_vidc_inst *inst,
buf->attr &= ~MSM_VIDC_ATTR_READ_ONLY;
buf->flags = 0;
if (buffer->flags & HFI_BUF_FW_FLAG_KEYFRAME)
buf->flags |= MSM_VIDC_BUF_FLAG_KEYFRAME;
//todo: moved to HFI_PROP_PICTURE_TYPE
/*if (buffer->flags & HFI_BUF_FW_FLAG_KEYFRAME)
buf->flags |= MSM_VIDC_BUF_FLAG_KEYFRAME;*/
if (buffer->flags & HFI_BUF_FW_FLAG_LAST)
buf->flags |= MSM_VIDC_BUF_FLAG_LAST;
if (buffer->flags & HFI_BUF_FW_FLAG_CORRUPT)
buf->flags |= MSM_VIDC_BUF_FLAG_ERROR;
//moved to HFI_INFO_DATA_CORRUPT
/*if (buffer->flags & HFI_BUF_FW_FLAG_CORRUPT)
buf->flags |= MSM_VIDC_BUF_FLAG_ERROR;*/
if (buffer->flags & HFI_BUF_FW_FLAG_CODEC_CONFIG)
buf->flags |= MSM_VIDC_BUF_FLAG_CODECCONFIG;
if (buffer->flags & HFI_BUF_FW_FLAG_SUBFRAME)
buf->flags |= MSM_VIDC_BUF_FLAG_SUBFRAME;
//moved to HFI_PROP_SUBFRAME_OUTPUT
/*if (buffer->flags & HFI_BUF_FW_FLAG_SUBFRAME)
buf->flags |= MSM_VIDC_BUF_FLAG_SUBFRAME;*/
print_vidc_buffer(VIDC_HIGH, "FBD", inst, buf);
msm_vidc_vb2_buffer_done(inst, buf);