Update to 07.00.00.253.024
Bug: 31713031
Change-Id: I46336f0b8c929500b28abda944e55f2cc6d05a03
diff --git a/msmcobalt/mm-core/inc/OMX_QCOMExtns.h b/msmcobalt/mm-core/inc/OMX_QCOMExtns.h
old mode 100755
new mode 100644
index a7c5b52..e4ddc51
--- a/msmcobalt/mm-core/inc/OMX_QCOMExtns.h
+++ b/msmcobalt/mm-core/inc/OMX_QCOMExtns.h
@@ -47,6 +47,29 @@
#include "OMX_Video.h"
#define OMX_VIDEO_MAX_HP_LAYERS 6
+
+/**
+ * These MACROS used by Camera and Video to decide buffer count.
+ * This is to avoid mismatch of buffer count between Camera and Video.
+ * In Meta mode, read this count as buffer count in Camera and Header
+ * count in Video.
+ * 1) Number of buffers in Non-DCVS mode.
+ * 2) DCVS resolution.
+ * 3) Buffer count when Current resolution is greater than DCVS resolution
+ * defined in 2)
+ */
+
+#define OMX_VIDEO_MIN_CAMERA_BUFFERS 9
+#define OMX_VIDEO_ENC_DCVS_RESOLUTION 3840 * 2160
+#define OMX_VIDEO_MIN_CAMERA_BUFFERS_DCVS 11
+
+/**
+ * This count indicates the number of Ints in the legacy Camera payload
+ * used for HAL1
+ */
+
+#define VIDEO_METADATA_NUM_COMMON_INTS 1
+
/**
* This extension is used to register mapping of a virtual
* address to a physical address. This extension is a parameter
@@ -95,6 +118,14 @@
*/
#define QOMX_ErrorLTRUseFailed (OMX_ErrorVendorStartUnused + 1)
+/*
+ * This rate control will be used for low bitrate applications to get better
+ * video quality for a given bitrate.
+ */
+#define QOMX_Video_ControlRateMaxBitrate (OMX_Video_ControlRateVendorStartUnused + 1)
+
+#define QOMX_Video_ControlRateMaxBitrateSkipFrames (OMX_Video_ControlRateVendorStartUnused + 2)
+
#define QOMX_VIDEO_BUFFERFLAG_BFRAME 0x00100000
#define QOMX_VIDEO_BUFFERFLAG_EOSEQ 0x00200000
@@ -190,6 +221,18 @@
OMX_U32 maxQP;
} OMX_QCOM_VIDEO_PARAM_QPRANGETYPE;
+typedef struct OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE {
+ OMX_U32 nSize;
+ OMX_VERSIONTYPE nVersion;
+ OMX_U32 nPortIndex;
+ OMX_U32 minIQP;
+ OMX_U32 maxIQP;
+ OMX_U32 minPQP;
+ OMX_U32 maxPQP;
+ OMX_U32 minBQP;
+ OMX_U32 maxBQP;
+} OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE;
+
#define OMX_QCOM_PLATFORMPVT_EXTN "OMX.QCOM.index.param.platformprivate"
/** Allowed APIs on the above Index: OMX_SetParameter() */
@@ -562,6 +605,15 @@
/* Configure BLUR resolution for encode */
OMX_QTIIndexConfigVideoBlurResolution = 0x7F00005E,
+
+ /* QP range for I frame B frame P frame */
+ OMX_QcomIndexParamVideoIPBQPRange = 0x7F00005F,
+
+ /* Enable client extradata */
+ OMX_QTIIndexParamVideoClientExtradata = 0x7F000060,
+
+ /* H264 transform 8x8 mode */
+ OMX_QcomIndexConfigH264Transform8x8 = 0x7F000061,
};
/**
@@ -1655,6 +1707,7 @@
#define OMX_QTI_INDEX_PARAM_VIDEO_ENABLE_ROIINFO "OMX.QTI.index.param.enableRoiInfo"
#define OMX_QTI_INDEX_CONFIG_VIDEO_ROIINFO "OMX.QTI.index.config.RoiInfo"
#define OMX_QTI_INDEX_CONFIG_VIDEO_BLURINFO "OMX.QTI.index.config.BlurInfo"
+#define OMX_QTI_INDEX_PARAM_VIDEO_CLIENT_EXTRADATA "OMX.QTI.index.param.client.extradata"
typedef enum {
QOMX_VIDEO_FRAME_PACKING_CHECKERBOARD = 0,
@@ -1938,6 +1991,15 @@
OMX_U32 nBatchSize;
} QOMX_VIDEO_BATCHSIZETYPE;
+typedef struct QOMX_VIDEO_CLIENT_EXTRADATA {
+ OMX_U32 nSize;
+ OMX_VERSIONTYPE nVersion;
+ OMX_U32 nPortIndex;
+ OMX_U32 nFd;
+ OMX_U32 nExtradataAllocSize;
+ OMX_U32 nExtradataSize;
+} QOMX_VIDEO_CLIENT_EXTRADATATYPE;
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
diff --git a/msmcobalt/mm-core/src/msm8953/registry_table.c b/msmcobalt/mm-core/src/msm8953/registry_table.c
index e6a394f..3f7f3ca 100644
--- a/msmcobalt/mm-core/src/msm8953/registry_table.c
+++ b/msmcobalt/mm-core/src/msm8953/registry_table.c
@@ -547,6 +547,19 @@
}
},
{
+ "OMX.qcom.audio.encoder.amrwb",
+ NULL, // Create instance function
+ // Unique instance handle
+ {
+ NULL
+ },
+ NULL, // Shared object library handle
+ "libOmxAmrEnc.so",
+ {
+ "audio_encoder.amrwb"
+ }
+ },
+ {
"OMX.qcom.audio.encoder.g711mlaw",
NULL, // Create instance function
// Unique instance handle
diff --git a/msmcobalt/mm-core/src/msm8953/registry_table_android.c b/msmcobalt/mm-core/src/msm8953/registry_table_android.c
index 8de929a..988a460 100644
--- a/msmcobalt/mm-core/src/msm8953/registry_table_android.c
+++ b/msmcobalt/mm-core/src/msm8953/registry_table_android.c
@@ -612,6 +612,19 @@
}
},
{
+ "OMX.qcom.audio.encoder.amrwb",
+ NULL, // Create instance function
+ // Unique instance handle
+ {
+ NULL
+ },
+ NULL, // Shared object library handle
+ "libOmxAmrEnc.so",
+ {
+ "audio_encoder.amrwb"
+ }
+ },
+{
"OMX.qcom.audio.encoder.g711mlaw",
NULL, // Create instance function
// Unique instance handle
diff --git a/msmcobalt/mm-video-v4l2/vidc/common/inc/vidc_debug.h b/msmcobalt/mm-video-v4l2/vidc/common/inc/vidc_debug.h
index 6355188..3d5bbb5 100644
--- a/msmcobalt/mm-video-v4l2/vidc/common/inc/vidc_debug.h
+++ b/msmcobalt/mm-video-v4l2/vidc/common/inc/vidc_debug.h
@@ -32,6 +32,7 @@
#ifdef _ANDROID_
#include <cstdio>
#include <pthread.h>
+#include <sys/mman.h>
enum {
PRIO_ERROR=0x1,
@@ -93,4 +94,20 @@
pthread_mutex_t &mLock;
};
+class AutoUnmap {
+ void *vaddr;
+ int size;
+
+ public:
+ AutoUnmap(void *vaddr, int size) {
+ this->vaddr = vaddr;
+ this->size = size;
+ }
+
+ ~AutoUnmap() {
+ if (vaddr)
+ munmap(vaddr, size);
+ }
+};
+
#endif
diff --git a/msmcobalt/mm-video-v4l2/vidc/vdec/inc/omx_vdec.h b/msmcobalt/mm-video-v4l2/vidc/vdec/inc/omx_vdec.h
index b9083dd..a0201ef 100644
--- a/msmcobalt/mm-video-v4l2/vidc/vdec/inc/omx_vdec.h
+++ b/msmcobalt/mm-video-v4l2/vidc/vdec/inc/omx_vdec.h
@@ -1177,6 +1177,59 @@
static OMX_ERRORTYPE describeColorFormat(OMX_PTR params);
void prefetchNewBuffers();
+ class client_extradata_info {
+ private:
+ int fd;
+ OMX_U32 total_size;
+ OMX_U32 size;
+ void *vaddr;
+ public:
+ client_extradata_info() {
+ fd = -1;
+ size = 0;
+ total_size = 0;
+ vaddr = NULL;
+ }
+
+ void reset() {
+ if (vaddr) {
+ munmap(vaddr, total_size);
+ vaddr = NULL;
+ }
+ if (fd != -1) {
+ close(fd);
+ fd = -1;
+ }
+ }
+
+ ~client_extradata_info() {
+ reset();
+ }
+
+ bool set_extradata_info(int fd, OMX_U32 total_size, OMX_U32 size) {
+ reset();
+ this->fd = fd;
+ this->size = size;
+ this->total_size = total_size;
+ vaddr = (OMX_U8*)mmap(0, total_size,
+ PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+ if (vaddr == MAP_FAILED) {
+ vaddr = NULL;
+ reset();
+ return false;
+ }
+ return true;
+ }
+
+ OMX_U8 *getBase() const {
+ return (OMX_U8 *)vaddr;
+ }
+
+ OMX_U32 getSize() const {
+ return size;
+ }
+ };
+ client_extradata_info m_client_extradata_info;
};
#ifdef _MSM8974_
diff --git a/msmcobalt/mm-video-v4l2/vidc/vdec/src/omx_vdec_v4l2.cpp b/msmcobalt/mm-video-v4l2/vidc/vdec/src/omx_vdec_v4l2.cpp
index 7632b38..b737726 100644
--- a/msmcobalt/mm-video-v4l2/vidc/vdec/src/omx_vdec_v4l2.cpp
+++ b/msmcobalt/mm-video-v4l2/vidc/vdec/src/omx_vdec_v4l2.cpp
@@ -1028,11 +1028,10 @@
//Restore the capture format again here, because
//in switching between different DPB-OPB modes, the pixelformat
- //on capture port may be changed.
+ //on capture port may be changed. Don't change resolutions.
memset(&fmt, 0x0, sizeof(struct v4l2_format));
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height;
- fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width;
+ rc = ioctl(drv_ctx.video_driver_fd, VIDIOC_G_FMT, &fmt);
fmt.fmt.pix_mp.pixelformat = capture_capability;
rc = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt);
if (rc) {
@@ -1099,6 +1098,7 @@
int rc = 0;
struct v4l2_format fmt;
enum color_fmts color_format;
+ OMX_U32 width, height;
if (!m_downscalar_width || !m_downscalar_height) {
DEBUG_PRINT_LOW("%s: downscalar not supported", __func__);
@@ -1119,10 +1119,13 @@
return rc;
}
+ height = fmt.fmt.pix_mp.height;
+ width = fmt.fmt.pix_mp.width;
+
DEBUG_PRINT_HIGH("%s: driver wxh = %dx%d, downscalar wxh = %dx%d m_is_display_session = %d", __func__,
fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height, m_downscalar_width, m_downscalar_height, m_is_display_session);
- if ((fmt.fmt.pix_mp.width * fmt.fmt.pix_mp.height > m_downscalar_width * m_downscalar_height) &&
+ if ((fmt.fmt.pix_mp.width * fmt.fmt.pix_mp.height >= m_downscalar_width * m_downscalar_height) &&
m_is_display_session) {
rc = enable_downscalar();
if (rc < 0) {
@@ -1130,9 +1133,9 @@
return rc;
}
- OMX_U32 width = m_downscalar_width > fmt.fmt.pix_mp.width ?
+ width = m_downscalar_width > fmt.fmt.pix_mp.width ?
fmt.fmt.pix_mp.width : m_downscalar_width;
- OMX_U32 height = m_downscalar_height > fmt.fmt.pix_mp.height ?
+ height = m_downscalar_height > fmt.fmt.pix_mp.height ?
fmt.fmt.pix_mp.height : m_downscalar_height;
switch (capture_capability) {
case V4L2_PIX_FMT_NV12:
@@ -1149,13 +1152,6 @@
rc = OMX_ErrorUndefined;
return rc;
}
-
- rc = update_resolution(width, height,
- VENUS_Y_STRIDE(color_format, width), VENUS_Y_SCANLINES(color_format, height));
- if (rc < 0) {
- DEBUG_PRINT_ERROR("%s: update_resolution WxH %dx%d failed \n", __func__, width, height);
- return rc;
- }
} else {
rc = disable_downscalar();
@@ -1163,20 +1159,12 @@
DEBUG_PRINT_ERROR("%s: disable_downscalar failed\n", __func__);
return rc;
}
-
- rc = update_resolution(fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height,
- fmt.fmt.pix_mp.plane_fmt[0].bytesperline, fmt.fmt.pix_mp.plane_fmt[0].reserved[0]);
- if (rc < 0) {
- DEBUG_PRINT_ERROR("%s: update_resolution WxH %dx%d failed\n", __func__, fmt.fmt.pix_mp.width,
- fmt.fmt.pix_mp.height);
- return rc;
- }
}
memset(&fmt, 0x0, sizeof(struct v4l2_format));
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height;
- fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width;
+ fmt.fmt.pix_mp.height = height;
+ fmt.fmt.pix_mp.width = width;
fmt.fmt.pix_mp.pixelformat = capture_capability;
rc = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt);
if (rc) {
@@ -3814,6 +3802,17 @@
break;
}
+ case OMX_QTIIndexParamVideoClientExtradata:
+ {
+ VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_CLIENT_EXTRADATATYPE);
+ DEBUG_PRINT_LOW("get_parameter: OMX_QTIIndexParamVideoClientExtradata");
+ QOMX_VIDEO_CLIENT_EXTRADATATYPE *pParam =
+ (QOMX_VIDEO_CLIENT_EXTRADATATYPE *)paramData;
+ pParam->nExtradataSize = VENUS_EXTRADATA_SIZE(4096, 2160);
+ pParam->nExtradataAllocSize = pParam->nExtradataSize * MAX_NUM_INPUT_OUTPUT_BUFFERS;
+ eRet = OMX_ErrorNone;
+ break;
+ }
default: {
DEBUG_PRINT_ERROR("get_parameter: unknown param %08x", paramIndex);
eRet =OMX_ErrorUnsupportedIndex;
@@ -3962,10 +3961,6 @@
(portDefn->format.video.nFrameWidth != (unsigned int)fmt.fmt.pix_mp.width)) {
port_format_changed = true;
}
- update_resolution(portDefn->format.video.nFrameWidth,
- portDefn->format.video.nFrameHeight,
- portDefn->format.video.nFrameWidth,
- portDefn->format.video.nFrameHeight);
/* set crop info */
rectangle.nLeft = 0;
@@ -3978,8 +3973,8 @@
break;
memset(&fmt, 0x0, sizeof(struct v4l2_format));
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height;
- fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width;
+ fmt.fmt.pix_mp.height = (unsigned int)portDefn->format.video.nFrameHeight;
+ fmt.fmt.pix_mp.width = (unsigned int)portDefn->format.video.nFrameWidth;
fmt.fmt.pix_mp.pixelformat = capture_capability;
DEBUG_PRINT_LOW("fmt.fmt.pix_mp.height = %d , fmt.fmt.pix_mp.width = %d",
fmt.fmt.pix_mp.height, fmt.fmt.pix_mp.width);
@@ -4137,13 +4132,28 @@
eRet = is_video_session_supported();
if (eRet)
break;
- memset(&fmt, 0x0, sizeof(struct v4l2_format));
- fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height;
- fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width;
- fmt.fmt.pix_mp.pixelformat = output_capability;
- DEBUG_PRINT_LOW("fmt.fmt.pix_mp.height = %d , fmt.fmt.pix_mp.width = %d",fmt.fmt.pix_mp.height,fmt.fmt.pix_mp.width);
- ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt);
+ if (is_down_scalar_enabled) {
+ memset(&fmt, 0x0, sizeof(struct v4l2_format));
+ fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+ fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height;
+ fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width;
+ fmt.fmt.pix_mp.pixelformat = output_capability;
+ DEBUG_PRINT_LOW("DS Enabled : height = %d , width = %d",
+ fmt.fmt.pix_mp.height,fmt.fmt.pix_mp.width);
+ ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt);
+ } else {
+ memset(&fmt, 0x0, sizeof(struct v4l2_format));
+ fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+ fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height;
+ fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width;
+ fmt.fmt.pix_mp.pixelformat = output_capability;
+ DEBUG_PRINT_LOW("DS Disabled : height = %d , width = %d",
+ fmt.fmt.pix_mp.height,fmt.fmt.pix_mp.width);
+ ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt);
+ fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+ fmt.fmt.pix_mp.pixelformat = capture_capability;
+ ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt);
+ }
if (ret) {
DEBUG_PRINT_ERROR("Set Resolution failed");
eRet = OMX_ErrorUnsupportedSetting;
@@ -4207,24 +4217,27 @@
memset(&fmt, 0x0, sizeof(struct v4l2_format));
if (1 == portFmt->nPortIndex) {
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height;
- fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width;
+ ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_G_FMT, &fmt);
+ if (ret < 0) {
+ DEBUG_PRINT_ERROR("%s: Failed to get format on capture mplane", __func__);
+ return OMX_ErrorBadParameter;
+ }
enum vdec_output_fromat op_format;
if (portFmt->eColorFormat == (OMX_COLOR_FORMATTYPE)
- QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m ||
+ QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m ||
portFmt->eColorFormat == (OMX_COLOR_FORMATTYPE)
- QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mMultiView ||
+ QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mMultiView ||
portFmt->eColorFormat == OMX_COLOR_FormatYUV420Planar ||
portFmt->eColorFormat == OMX_COLOR_FormatYUV420SemiPlanar) {
op_format = (enum vdec_output_fromat)VDEC_YUV_FORMAT_NV12;
} else if (portFmt->eColorFormat == (OMX_COLOR_FORMATTYPE)
- QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed) {
+ QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed) {
op_format = (enum vdec_output_fromat)VDEC_YUV_FORMAT_NV12_UBWC;
} else
eRet = OMX_ErrorBadParameter;
if (portFmt->eColorFormat == (OMX_COLOR_FORMATTYPE)
- QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed) {
+ QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed) {
fmt.fmt.pix_mp.pixelformat = capture_capability = V4L2_PIX_FMT_NV12_UBWC;
} else {
fmt.fmt.pix_mp.pixelformat = capture_capability = V4L2_PIX_FMT_NV12;
@@ -4904,6 +4917,28 @@
DEBUG_PRINT_LOW("set_parameter: UBWC %s for OPB", pParam->bEnable ? "disabled" : "enabled");
break;
}
+ case OMX_QTIIndexParamVideoClientExtradata:
+ {
+ VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_CLIENT_EXTRADATATYPE);
+ DEBUG_PRINT_LOW("set_parameter: OMX_QTIIndexParamVideoClientExtradata");
+ QOMX_VIDEO_CLIENT_EXTRADATATYPE *pParam =
+ (QOMX_VIDEO_CLIENT_EXTRADATATYPE *)paramData;
+ OMX_U32 extradata_size = VENUS_EXTRADATA_SIZE(4096, 2160);
+ if (pParam->nExtradataSize < extradata_size ||
+ pParam->nExtradataAllocSize < (extradata_size * MAX_NUM_INPUT_OUTPUT_BUFFERS) ||
+ pParam->nExtradataAllocSize < (pParam->nExtradataSize * MAX_NUM_INPUT_OUTPUT_BUFFERS)) {
+ DEBUG_PRINT_ERROR("set_parameter: Incorrect buffer size for client extradata");
+ eRet = OMX_ErrorBadParameter;
+ break;
+ }
+ if (!m_client_extradata_info.set_extradata_info(dup(pParam->nFd),
+ pParam->nExtradataAllocSize, pParam->nExtradataSize)) {
+ DEBUG_PRINT_ERROR("set_parameter: Setting client extradata failed.");
+ eRet = OMX_ErrorBadParameter;
+ break;
+ }
+ break;
+ }
default: {
DEBUG_PRINT_ERROR("Setparameter: unknown param %d", paramIndex);
@@ -5346,6 +5381,8 @@
*indexType = (OMX_INDEXTYPE)OMX_QTIIndexParamForceUnCompressedForOPB;
} else if (extn_equals(paramName, "OMX.QTI.index.param.video.LowLatency")) {
*indexType = (OMX_INDEXTYPE)OMX_QTIIndexParamLowLatencyMode;
+ } else if (extn_equals(paramName, OMX_QTI_INDEX_PARAM_VIDEO_CLIENT_EXTRADATA)) {
+ *indexType = (OMX_INDEXTYPE)OMX_QTIIndexParamVideoClientExtradata;
} else {
DEBUG_PRINT_ERROR("Extension: %s not implemented", paramName);
return OMX_ErrorNotImplemented;
@@ -9584,15 +9621,8 @@
DEBUG_PRINT_LOW("GetBufReq IN: ActCnt(%d) Size(%u)",
buffer_prop->actualcount, (unsigned int)buffer_prop->buffer_size);
- fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height;
- fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width;
-
ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_G_FMT, &fmt);
- update_resolution(fmt.fmt.pix_mp.width,
- fmt.fmt.pix_mp.height,
- fmt.fmt.pix_mp.plane_fmt[0].bytesperline,
- fmt.fmt.pix_mp.plane_fmt[0].reserved[0]);
if (fmt.type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
drv_ctx.num_planes = fmt.fmt.pix_mp.num_planes;
DEBUG_PRINT_HIGH("Buffer Size = %d",fmt.fmt.pix_mp.plane_fmt[0].sizeimage);
@@ -9630,8 +9660,6 @@
drv_ctx.extradata_info.size = buffer_prop->actualcount * final_extra_data_size;
drv_ctx.extradata_info.count = buffer_prop->actualcount;
drv_ctx.extradata_info.buffer_size = final_extra_data_size;
- if (!secure_mode)
- buf_size += final_extra_data_size;
buf_size = (buf_size + buffer_prop->alignment - 1)&(~(buffer_prop->alignment - 1));
DEBUG_PRINT_LOW("GetBufReq UPDATE: ActCnt(%d) Size(%u) BufSize(%d)",
buffer_prop->actualcount, (unsigned int)buffer_prop->buffer_size, buf_size);
@@ -9655,9 +9683,9 @@
{
OMX_ERRORTYPE eRet = OMX_ErrorNone;
unsigned buf_size = 0;
- struct v4l2_format fmt;
+ struct v4l2_format fmt, c_fmt;
struct v4l2_requestbuffers bufreq;
- int ret;
+ int ret = 0;
DEBUG_PRINT_LOW("SetBufReq IN: ActCnt(%d) Size(%u)",
buffer_prop->actualcount, (unsigned int)buffer_prop->buffer_size);
buf_size = (buffer_prop->buffer_size + buffer_prop->alignment - 1)&(~(buffer_prop->alignment - 1));
@@ -9667,6 +9695,7 @@
eRet = OMX_ErrorBadParameter;
} else {
memset(&fmt, 0x0, sizeof(struct v4l2_format));
+ memset(&c_fmt, 0x0, sizeof(struct v4l2_format));
fmt.fmt.pix_mp.height = drv_ctx.video_resolution.frame_height;
fmt.fmt.pix_mp.width = drv_ctx.video_resolution.frame_width;
fmt.fmt.pix_mp.plane_fmt[0].sizeimage = buf_size;
@@ -9674,14 +9703,17 @@
if (buffer_prop->buffer_type == VDEC_BUFFER_TYPE_INPUT) {
fmt.type =V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
fmt.fmt.pix_mp.pixelformat = output_capability;
+ ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt);
} else if (buffer_prop->buffer_type == VDEC_BUFFER_TYPE_OUTPUT) {
- fmt.type =V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- fmt.fmt.pix_mp.pixelformat = capture_capability;
+ c_fmt.type =V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+ c_fmt.fmt.pix_mp.pixelformat = capture_capability;
+ ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_G_FMT, &c_fmt);
+ c_fmt.fmt.pix_mp.plane_fmt[0].sizeimage = buf_size;
+ ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &c_fmt);
} else {
eRet = OMX_ErrorBadParameter;
}
- ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt);
if (ret) {
/*TODO: How to handle this case */
DEBUG_PRINT_ERROR("Setting buffer requirements (format) failed %d", ret);
@@ -9758,10 +9790,18 @@
fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
fmt.fmt.pix_mp.pixelformat = output_capability;
+ ioctl(drv_ctx.video_driver_fd, VIDIOC_G_FMT, &fmt);
} else if (1 == portDefn->nPortIndex) {
unsigned int buf_size = 0;
int ret = 0;
- memset(&fmt, 0x0, sizeof(struct v4l2_format));
+ if (!is_down_scalar_enabled) {
+ fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+ ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_G_FMT, &fmt);
+ fmt.fmt.pix_mp.pixelformat = capture_capability;
+ fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+ ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_S_FMT, &fmt);
+ }
+
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
fmt.fmt.pix_mp.pixelformat = capture_capability;
ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_G_FMT, &fmt);
@@ -9770,8 +9810,6 @@
return OMX_ErrorHardware;
}
drv_ctx.op_buf.buffer_size = fmt.fmt.pix_mp.plane_fmt[0].sizeimage;
- drv_ctx.op_buf.buffer_size += drv_ctx.extradata_info.buffer_size;
- drv_ctx.op_buf.buffer_size = (drv_ctx.op_buf.buffer_size + drv_ctx.op_buf.alignment - 1)&(~(drv_ctx.op_buf.alignment - 1));
if (!client_buffers.update_buffer_req()) {
DEBUG_PRINT_ERROR("client_buffers.update_buffer_req Failed");
return OMX_ErrorHardware;
@@ -9800,24 +9838,13 @@
(int)portDefn->nPortIndex);
eRet = OMX_ErrorBadPortIndex;
}
- if (is_down_scalar_enabled) {
- int ret = 0;
- ret = ioctl(drv_ctx.video_driver_fd, VIDIOC_G_FMT, &fmt);
- if (ret) {
- DEBUG_PRINT_ERROR("update_portdef : Error in getting port resolution");
- return OMX_ErrorHardware;
- } else {
- portDefn->format.video.nFrameWidth = fmt.fmt.pix_mp.width;
- portDefn->format.video.nFrameHeight = fmt.fmt.pix_mp.height;
- portDefn->format.video.nStride = fmt.fmt.pix_mp.plane_fmt[0].bytesperline;
- portDefn->format.video.nSliceHeight = fmt.fmt.pix_mp.plane_fmt[0].reserved[0];
- }
- } else {
+ update_resolution(fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height,
+ fmt.fmt.pix_mp.plane_fmt[0].bytesperline, fmt.fmt.pix_mp.plane_fmt[0].reserved[0]);
+
portDefn->format.video.nFrameHeight = drv_ctx.video_resolution.frame_height;
portDefn->format.video.nFrameWidth = drv_ctx.video_resolution.frame_width;
portDefn->format.video.nStride = drv_ctx.video_resolution.stride;
portDefn->format.video.nSliceHeight = drv_ctx.video_resolution.scan_lines;
- }
if ((portDefn->format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar) ||
(portDefn->format.video.eColorFormat == OMX_COLOR_FormatYUV420SemiPlanar)) {
@@ -10119,7 +10146,8 @@
void omx_vdec::handle_extradata(OMX_BUFFERHEADERTYPE *p_buf_hdr)
{
- OMX_OTHER_EXTRADATATYPE *p_extra = NULL, *p_sei = NULL, *p_vui = NULL;
+ OMX_OTHER_EXTRADATATYPE *p_extra = NULL, *p_sei = NULL, *p_vui = NULL, *p_client_extra = NULL;
+ OMX_U8 *pBuffer = NULL;
OMX_U32 num_conceal_MB = 0;
OMX_TICKS time_stamp = 0;
OMX_U32 frame_rate = 0;
@@ -10144,9 +10172,6 @@
return;
}
- OMX_U8 *pBuffer = (OMX_U8 *)(drv_ctx.ptr_outputbuffer[buf_index].bufferaddr) +
- p_buf_hdr->nOffset;
-
if (!drv_ctx.extradata_info.uaddr) {
DEBUG_PRINT_HIGH("NULL drv_ctx.extradata_info.uaddr");
return;
@@ -10156,11 +10181,25 @@
p_extra = NULL;
return;
}
- if (!secure_mode)
+ if (!secure_mode) {
+ pBuffer = (OMX_U8*)mmap(0, drv_ctx.ptr_outputbuffer[buf_index].buffer_len,
+ PROT_READ|PROT_WRITE, MAP_SHARED, drv_ctx.ptr_outputbuffer[buf_index].pmem_fd, 0);
+ if (pBuffer == MAP_FAILED) {
+ DEBUG_PRINT_ERROR("handle_extradata output buffer mmap failed - errno: %d", errno);
+ return;
+ }
p_extra = (OMX_OTHER_EXTRADATATYPE *)
((unsigned long)(pBuffer + p_buf_hdr->nOffset + p_buf_hdr->nFilledLen + 3)&(~3));
- else
+ } else
p_extra = m_other_extradata;
+
+ AutoUnmap autounmap(pBuffer, drv_ctx.ptr_outputbuffer[buf_index].buffer_len);
+ if (m_client_extradata_info.getBase() &&
+ m_client_extradata_info.getSize() >= drv_ctx.extradata_info.buffer_size) {
+ p_client_extra = (OMX_OTHER_EXTRADATATYPE *) (m_client_extradata_info.getBase() +
+ buf_index * m_client_extradata_info.getSize());
+ }
+
char *p_extradata = drv_ctx.extradata_info.uaddr + buf_index * drv_ctx.extradata_info.buffer_size;
if (!secure_mode && ((OMX_U8*)p_extra > (pBuffer + p_buf_hdr->nAllocLen))) {
@@ -10238,7 +10277,12 @@
}
if (client_extradata & OMX_INTERLACE_EXTRADATA) {
append_interlace_extradata(p_extra, payload->format);
- p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + p_extra->nSize);
+ p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + ALIGN(p_extra->nSize, 4));
+ if (p_client_extra) {
+ append_interlace_extradata(p_client_extra, payload->format);
+ p_client_extra = (OMX_OTHER_EXTRADATATYPE *)
+ (((OMX_U8 *)p_client_extra) + ALIGN(p_client_extra->nSize, 4));
+ }
}
break;
case MSM_VIDC_EXTRADATA_FRAME_RATE:
@@ -10339,7 +10383,11 @@
s3d_frame_packing_payload->fpa_type, s3d_frame_packing_payload->content_interprtation_type, stereo_output_mode);
if (client_extradata & OMX_FRAMEPACK_EXTRADATA) {
append_framepack_extradata(p_extra, s3d_frame_packing_payload);
- p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + p_extra->nSize);
+ p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + ALIGN(p_extra->nSize, 4));
+ if (p_client_extra) {
+ append_framepack_extradata(p_client_extra, s3d_frame_packing_payload);
+ p_client_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_client_extra) + ALIGN(p_client_extra->nSize, 4));
+ }
}
break;
case MSM_VIDC_EXTRADATA_FRAME_QP:
@@ -10347,7 +10395,11 @@
qp_payload = (struct msm_vidc_frame_qp_payload*)(void *)data->data;
if (client_extradata & OMX_QP_EXTRADATA) {
append_qp_extradata(p_extra, qp_payload);
- p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + p_extra->nSize);
+ p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + ALIGN(p_extra->nSize, 4));
+ if (p_client_extra) {
+ append_qp_extradata(p_client_extra, qp_payload);
+ p_client_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_client_extra) + ALIGN(p_client_extra->nSize, 4));
+ }
}
break;
case MSM_VIDC_EXTRADATA_FRAME_BITS_INFO:
@@ -10355,13 +10407,21 @@
bits_info_payload = (struct msm_vidc_frame_bits_info_payload*)(void *)data->data;
if (client_extradata & OMX_BITSINFO_EXTRADATA) {
append_bitsinfo_extradata(p_extra, bits_info_payload);
- p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + p_extra->nSize);
+ p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + ALIGN(p_extra->nSize, 4));
+ if (p_client_extra) {
+ append_bitsinfo_extradata(p_client_extra, bits_info_payload);
+ p_client_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_client_extra) + ALIGN(p_client_extra->nSize, 4));
+ }
}
break;
case MSM_VIDC_EXTRADATA_STREAM_USERDATA:
if (client_extradata & OMX_EXTNUSER_EXTRADATA) {
append_user_extradata(p_extra, data);
- p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + p_extra->nSize);
+ p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + ALIGN(p_extra->nSize, 4));
+ if (p_client_extra) {
+ append_user_extradata(p_client_extra, data);
+ p_client_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_client_extra) + ALIGN(p_client_extra->nSize, 4));
+ }
}
break;
case MSM_VIDC_EXTRADATA_VQZIP_SEI:
@@ -10370,7 +10430,11 @@
if (client_extradata & OMX_VQZIPSEI_EXTRADATA) {
p_buf_hdr->nFlags |= OMX_BUFFERFLAG_EXTRADATA;
append_vqzip_extradata(p_extra, vqzip_payload);
- p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + p_extra->nSize);
+ p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + ALIGN(p_extra->nSize, 4));
+ if (p_client_extra) {
+ append_vqzip_extradata(p_client_extra, vqzip_payload);
+ p_client_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_client_extra) + ALIGN(p_client_extra->nSize, 4));
+ }
}
break;
default:
@@ -10386,17 +10450,31 @@
num_conceal_MB, ((struct vdec_output_frameinfo *)p_buf_hdr->pOutputPortPrivate)->pic_type, frame_rate,
time_stamp, panscan_payload,&((struct vdec_output_frameinfo *)
p_buf_hdr->pOutputPortPrivate)->aspect_ratio_info);
- p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + p_extra->nSize);
+ p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + ALIGN(p_extra->nSize, 4));
+ if (p_client_extra) {
+ append_frame_info_extradata(p_client_extra,
+ num_conceal_MB, ((struct vdec_output_frameinfo *)p_buf_hdr->pOutputPortPrivate)->pic_type, frame_rate,
+ time_stamp, panscan_payload,&((struct vdec_output_frameinfo *)
+ p_buf_hdr->pOutputPortPrivate)->aspect_ratio_info);
+ p_client_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_client_extra) + ALIGN(p_client_extra->nSize, 4));
+ }
}
if (client_extradata & OMX_FRAMEDIMENSION_EXTRADATA) {
append_frame_dimension_extradata(p_extra);
- p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + p_extra->nSize);
+ p_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_extra) + ALIGN(p_extra->nSize, 4));
+ if (p_client_extra) {
+ append_frame_dimension_extradata(p_client_extra);
+ p_client_extra = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) p_client_extra) + ALIGN(p_client_extra->nSize, 4));
+ }
}
}
unrecognized_extradata:
if (client_extradata && p_extra) {
p_buf_hdr->nFlags |= OMX_BUFFERFLAG_EXTRADATA;
append_terminator_extradata(p_extra);
+ if (p_client_extra) {
+ append_terminator_extradata(p_client_extra);
+ }
}
if (secure_mode && p_extradata && m_other_extradata) {
struct vdec_output_frameinfo *ptr_extradatabuff = NULL;
@@ -11192,7 +11270,10 @@
{
bool status = true;
unsigned int src_size = 0, destination_size = 0;
+ unsigned int height, width;
+ struct v4l2_format fmt;
OMX_COLOR_FORMATTYPE drv_color_format;
+
if (!omx) {
DEBUG_PRINT_ERROR("Invalid client in color convert");
return false;
@@ -11203,8 +11284,15 @@
}
pthread_mutex_lock(&omx->c_lock);
- bool resolution_upgrade = (omx->drv_ctx.video_resolution.frame_height > m_c2d_height ||
- omx->drv_ctx.video_resolution.frame_width > m_c2d_width);
+ memset(&fmt, 0x0, sizeof(struct v4l2_format));
+ fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+ fmt.fmt.pix_mp.pixelformat = omx->capture_capability;
+ ioctl(omx->drv_ctx.video_driver_fd, VIDIOC_G_FMT, &fmt);
+ width = fmt.fmt.pix_mp.width;
+ height = fmt.fmt.pix_mp.height;
+
+ bool resolution_upgrade = (height > m_c2d_height ||
+ width > m_c2d_width);
if (resolution_upgrade) {
// resolution upgraded ? ensure we are yet to allocate;
// failing which, c2d buffers will never be reallocated and bad things will happen
@@ -11223,8 +11311,8 @@
goto fail_update_buf_req;
}
c2d.close();
- status = c2d.open(omx->drv_ctx.video_resolution.frame_height,
- omx->drv_ctx.video_resolution.frame_width,
+ status = c2d.open(height,
+ width,
NV12_128m,dest_format);
if (status) {
status = c2d.get_buffer_size(C2D_INPUT,src_size);
@@ -11245,8 +11333,8 @@
// smaller than what C2D needs !!
} else {
buffer_size_req = destination_size;
- m_c2d_height = omx->drv_ctx.video_resolution.frame_height;
- m_c2d_width = omx->drv_ctx.video_resolution.frame_width;
+ m_c2d_height = height;
+ m_c2d_width = width;
}
}
fail_update_buf_req:
diff --git a/msmcobalt/mm-video-v4l2/vidc/venc/inc/omx_video_base.h b/msmcobalt/mm-video-v4l2/vidc/venc/inc/omx_video_base.h
index 311e28e..7ee28d8 100644
--- a/msmcobalt/mm-video-v4l2/vidc/venc/inc/omx_video_base.h
+++ b/msmcobalt/mm-video-v4l2/vidc/venc/inc/omx_video_base.h
@@ -162,6 +162,11 @@
VENC_EXTRADATA_ROI = 0x04000000,
};
+struct output_metabuffer {
+ OMX_U32 type;
+ native_handle_t *nh;
+};
+
// OMX video class
class omx_video: public qc_omx_component
{
@@ -625,6 +630,7 @@
OMX_CONFIG_INTRAREFRESHVOPTYPE m_sConfigIntraRefreshVOP;
OMX_VIDEO_PARAM_QUANTIZATIONTYPE m_sSessionQuantization;
OMX_QCOM_VIDEO_PARAM_QPRANGETYPE m_sSessionQPRange;
+ OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE m_sSessionIPBQPRange;
OMX_VIDEO_PARAM_AVCSLICEFMO m_sAVCSliceFMO;
QOMX_VIDEO_INTRAPERIODTYPE m_sIntraperiod;
OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE m_sErrorCorrection;
diff --git a/msmcobalt/mm-video-v4l2/vidc/venc/inc/video_encoder_device_v4l2.h b/msmcobalt/mm-video-v4l2/vidc/venc/inc/video_encoder_device_v4l2.h
index 4731e49..a7a2083 100644
--- a/msmcobalt/mm-video-v4l2/vidc/venc/inc/video_encoder_device_v4l2.h
+++ b/msmcobalt/mm-video-v4l2/vidc/venc/inc/video_encoder_device_v4l2.h
@@ -105,6 +105,16 @@
unsigned long maxqp;
unsigned long minqp;
};
+
+struct msm_venc_ipb_qprange {
+ unsigned long max_i_qp;
+ unsigned long min_i_qp;
+ unsigned long max_p_qp;
+ unsigned long min_p_qp;
+ unsigned long max_b_qp;
+ unsigned long min_b_qp;
+};
+
struct msm_venc_intraperiod {
unsigned long num_pframes;
unsigned long num_bframes;
@@ -252,6 +262,7 @@
enum v4l2_ports port_index;
#ifdef USE_ION
struct venc_ion ion;
+ unsigned int m_ion_dev;
#endif
bool vqzip_sei_found;
};
@@ -267,8 +278,10 @@
RC_VBR_CFR = BIT(1),
RC_CBR_VFR = BIT(2),
RC_CBR_CFR = BIT(3),
+ RC_MBR_CFR = BIT(4),
+ RC_MBR_VFR = BIT(5),
RC_ALL = (RC_VBR_VFR | RC_VBR_CFR
- | RC_CBR_VFR | RC_CBR_CFR)
+ | RC_CBR_VFR | RC_CBR_CFR | RC_MBR_CFR | RC_MBR_VFR)
};
class venc_dev
@@ -302,6 +315,7 @@
OMX_U32 *,OMX_U32);
bool venc_set_param(void *,OMX_INDEXTYPE);
bool venc_set_config(void *configData, OMX_INDEXTYPE index);
+ bool venc_h264_transform_8x8(OMX_BOOL enable);
bool venc_get_profile_level(OMX_U32 *eProfile,OMX_U32 *eLevel);
bool venc_get_seq_hdr(void *, unsigned, unsigned *);
bool venc_loaded_start(void);
@@ -403,6 +417,7 @@
struct msm_venc_initqp init_qp;
struct msm_venc_qprange session_qp_range;
struct msm_venc_qprange session_qp_values;
+ struct msm_venc_ipb_qprange session_ipb_qp_values;
struct msm_venc_multiclicecfg multislice;
struct msm_venc_entropycfg entropy;
struct msm_venc_dbcfg dbkfilter;
@@ -430,6 +445,7 @@
bool venc_set_ratectrl_cfg(OMX_VIDEO_CONTROLRATETYPE eControlRate);
bool venc_set_session_qp(OMX_U32 i_frame_qp, OMX_U32 p_frame_qp,OMX_U32 b_frame_qp);
bool venc_set_session_qp_range(OMX_U32 min_qp, OMX_U32 max_qp);
+ bool venc_set_session_qp_range_packed(OMX_U32 min_qp, OMX_U32 max_qp);
bool venc_set_encode_framerate(OMX_U32 encode_framerate, OMX_U32 config);
bool venc_set_intra_vop_refresh(OMX_BOOL intra_vop_refresh);
bool venc_set_color_format(OMX_COLOR_FORMATTYPE color_format);
@@ -466,7 +482,7 @@
bool venc_set_batch_size(OMX_U32 size);
bool venc_calibrate_gop();
bool venc_set_vqzip_defaults();
- int venc_get_index_from_fd(OMX_U32 fd);
+ int venc_get_index_from_fd(OMX_U32 ion_fd, OMX_U32 buffer_fd);
bool venc_validate_hybridhp_params(OMX_U32 layers, OMX_U32 bFrames, OMX_U32 count, int mode);
bool venc_set_hierp_layers(OMX_U32 hierp_layers);
bool venc_set_baselayerid(OMX_U32 baseid);
diff --git a/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_swvenc_mpeg4.cpp b/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_swvenc_mpeg4.cpp
index ecf9772..3afc147 100644
--- a/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_swvenc_mpeg4.cpp
+++ b/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_swvenc_mpeg4.cpp
@@ -1799,6 +1799,8 @@
SWVENC_IPBUFFER ipbuffer;
OMX_BUFFERHEADERTYPE *bufhdr = (OMX_BUFFERHEADERTYPE *)buffer;
unsigned int size = 0, filled_length, offset = 0;
+ SWVENC_COLOR_FORMAT color_format;
+ SWVENC_PROPERTY prop;
(void)pmem_data_buf;
(void)index;
@@ -1829,9 +1831,44 @@
VideoGrallocMetadata *meta_buf = (VideoGrallocMetadata *)bufhdr->pBuffer;
private_handle_t *handle = (private_handle_t *)meta_buf->pHandle;
size = handle->size;
+ if(!format_set)
+ {
+ format_set = true;
+ DEBUG_PRINT_LOW("color format = 0x%x",handle->format);
+ if (((OMX_COLOR_FORMATTYPE)handle->format) != m_sInPortFormat.eColorFormat)
+ {
+ if(handle->format == HAL_PIXEL_FORMAT_NV12_ENCODEABLE)
+ {
+ m_sInPortFormat.eColorFormat = (OMX_COLOR_FORMATTYPE)
+ QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m;
+ color_format = SWVENC_COLOR_FORMAT_NV12;
+ m_sInPortDef.format.video.eColorFormat = m_sInPortFormat.eColorFormat;
+ prop.id = SWVENC_PROPERTY_ID_COLOR_FORMAT;
+ prop.info.color_format = color_format;
+ Ret = swvenc_setproperty(m_hSwVenc, &prop);
+ if (Ret != SWVENC_S_SUCCESS)
+ {
+ DEBUG_PRINT_ERROR("%s, swvenc_setproperty failed (%d)",
+ __FUNCTION__, Ret);
+ RETURN(OMX_ErrorUnsupportedSetting);
+ }
+ }
+ else
+ {
+ DEBUG_PRINT_ERROR("%s: OMX_IndexParamVideoPortFormat 0x%x invalid",
+ __FUNCTION__,handle->format);
+ RETURN(OMX_ErrorBadParameter);
+ }
+ }
+ }
}
}
ipbuffer.p_buffer = (unsigned char *)mmap(NULL, size, PROT_READ|PROT_WRITE,MAP_SHARED, fd, offset);
+ if (ipbuffer.p_buffer == MAP_FAILED)
+ {
+ DEBUG_PRINT_ERROR("mmap() failed for fd %d of size %d",fd,size);
+ RETURN(OMX_ErrorBadParameter);
+ }
ipbuffer.size = size;
ipbuffer.filled_length = size;
}
diff --git a/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_video_base.cpp b/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_video_base.cpp
index f37babe..87a3d5c 100644
--- a/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_video_base.cpp
+++ b/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_video_base.cpp
@@ -80,7 +80,7 @@
#define SZ_4K 0x1000
#define SZ_1M 0x100000
-#define SECURE_BUFPTR 0xDEADBEEF
+#define ALIGN(x, to_align) ((((unsigned long) x) + (to_align - 1)) & ~(to_align - 1))
#ifndef ION_FLAG_CP_BITSTREAM
#define ION_FLAG_CP_BITSTREAM 0
@@ -1800,6 +1800,14 @@
break;
}
+ case OMX_QcomIndexParamVideoIPBQPRange:
+ {
+ OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE *qp_range = (OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE*) paramData;
+ DEBUG_PRINT_LOW("get_parameter: OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE");
+ memcpy(qp_range, &m_sSessionIPBQPRange, sizeof(m_sSessionIPBQPRange));
+ break;
+ }
+
case OMX_IndexParamVideoErrorCorrection:
{
VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE);
@@ -2580,7 +2588,7 @@
m_pInput_pmem[i].size = m_sInPortDef.nBufferSize;
m_pInput_pmem[i].offset = 0;
- m_pInput_pmem[i].buffer = (OMX_U8 *)SECURE_BUFPTR;
+ m_pInput_pmem[i].buffer = NULL;
if(!secure_session) {
m_pInput_pmem[i].buffer = (unsigned char *)mmap(
NULL,m_pInput_pmem[i].size,PROT_READ|PROT_WRITE,
@@ -2588,6 +2596,7 @@
if (m_pInput_pmem[i].buffer == MAP_FAILED) {
DEBUG_PRINT_ERROR("ERROR: mmap() Failed");
+ m_pInput_pmem[i].buffer = NULL;
close(m_pInput_pmem[i].fd);
#ifdef USE_ION
free_ion_memory(&m_pInput_ion[i]);
@@ -2772,7 +2781,7 @@
m_pOutput_pmem[i].size = m_sOutPortDef.nBufferSize;
m_pOutput_pmem[i].offset = 0;
- m_pOutput_pmem[i].buffer = (OMX_U8 *)SECURE_BUFPTR;
+ m_pOutput_pmem[i].buffer = NULL;
if(!secure_session) {
#ifdef _MSM8974_
m_pOutput_pmem[i].buffer = (unsigned char *)mmap(NULL,
@@ -2785,6 +2794,7 @@
#endif
if (m_pOutput_pmem[i].buffer == MAP_FAILED) {
DEBUG_PRINT_ERROR("ERROR: mmap() Failed");
+ m_pOutput_pmem[i].buffer = NULL;
close(m_pOutput_pmem[i].fd);
#ifdef USE_ION
free_ion_memory(&m_pOutput_ion[i]);
@@ -3187,13 +3197,14 @@
m_pInput_pmem[i].size = m_sInPortDef.nBufferSize;
m_pInput_pmem[i].offset = 0;
- m_pInput_pmem[i].buffer = (OMX_U8 *)SECURE_BUFPTR;
+ m_pInput_pmem[i].buffer = NULL;
if(!secure_session) {
m_pInput_pmem[i].buffer = (unsigned char *)mmap(NULL,
m_pInput_pmem[i].size,PROT_READ|PROT_WRITE,
MAP_SHARED,m_pInput_pmem[i].fd,0);
if (m_pInput_pmem[i].buffer == MAP_FAILED) {
DEBUG_PRINT_ERROR("ERROR: mmap FAILED= %d", errno);
+ m_pInput_pmem[i].buffer = NULL;
close(m_pInput_pmem[i].fd);
#ifdef USE_ION
free_ion_memory(&m_pInput_ion[i]);
@@ -3204,6 +3215,11 @@
//This should only be used for passing reference to source type and
//secure handle fd struct native_handle_t*
m_pInput_pmem[i].buffer = malloc(sizeof(OMX_U32) + sizeof(native_handle_t*));
+ if (m_pInput_pmem[i].buffer == NULL) {
+ DEBUG_PRINT_ERROR("%s: failed to allocate native-handle", __func__);
+ return OMX_ErrorInsufficientResources;
+ }
+ (*bufferHdr)->nAllocLen = sizeof(OMX_U32) + sizeof(native_handle_t*);
}
(*bufferHdr)->pBuffer = (OMX_U8 *)m_pInput_pmem[i].buffer;
@@ -3319,7 +3335,7 @@
if (i < m_sOutPortDef.nBufferCountActual) {
#ifdef USE_ION
#ifdef _MSM8974_
- align_size = ((m_sOutPortDef.nBufferSize + 4095)/4096) * 4096;
+ align_size = ALIGN(m_sOutPortDef.nBufferSize, 4096);
m_pOutput_ion[i].ion_device_fd = alloc_map_ion_memory(align_size,
&m_pOutput_ion[i].ion_alloc_data,
&m_pOutput_ion[i].fd_ion_data,
@@ -3349,7 +3365,9 @@
m_pOutput_pmem[i].size = m_sOutPortDef.nBufferSize;
m_pOutput_pmem[i].offset = 0;
- m_pOutput_pmem[i].buffer = (OMX_U8 *)SECURE_BUFPTR;
+ m_pOutput_pmem[i].buffer = NULL;
+ *bufferHdr = (m_out_mem_ptr + i );
+
if(!secure_session) {
#ifdef _MSM8974_
m_pOutput_pmem[i].buffer = (unsigned char *)mmap(NULL,
@@ -3362,6 +3380,7 @@
#endif
if (m_pOutput_pmem[i].buffer == MAP_FAILED) {
DEBUG_PRINT_ERROR("ERROR: MMAP_FAILED in o/p alloc buffer");
+ m_pOutput_pmem[i].buffer = NULL;
close (m_pOutput_pmem[i].fd);
#ifdef USE_ION
free_ion_memory(&m_pOutput_ion[i]);
@@ -3372,20 +3391,26 @@
else {
//This should only be used for passing reference to source type and
//secure handle fd struct native_handle_t*
- m_pOutput_pmem[i].buffer = malloc(sizeof(OMX_U32) + sizeof(native_handle_t*));
- native_handle_t *handle = native_handle_create(1, 0);
+ native_handle_t *handle = native_handle_create(1, 3); //fd, offset, size, alloc length
if (!handle) {
DEBUG_PRINT_ERROR("ERROR: native handle creation failed");
return OMX_ErrorInsufficientResources;
}
+ m_pOutput_pmem[i].buffer = malloc(sizeof(output_metabuffer));
+ if (m_pOutput_pmem[i].buffer == NULL) {
+ DEBUG_PRINT_ERROR("%s: Failed to allocate meta buffer", __func__);
+ return OMX_ErrorInsufficientResources;
+ }
+ (*bufferHdr)->nAllocLen = sizeof(output_metabuffer);
handle->data[0] = m_pOutput_pmem[i].fd;
- char *data = (char*) m_pOutput_pmem[i].buffer;
- OMX_U32 type = 1;
- memcpy(data, &type, sizeof(OMX_U32));
- memcpy(data + sizeof(OMX_U32), &handle, sizeof(native_handle_t*));
+ handle->data[1] = 0;
+ handle->data[2] = 0;
+ handle->data[3] = ALIGN(m_sOutPortDef.nBufferSize, 4096);
+ output_metabuffer *buffer = (output_metabuffer*) m_pOutput_pmem[i].buffer;
+ buffer->type = 1;
+ buffer->nh = handle;
}
- *bufferHdr = (m_out_mem_ptr + i );
(*bufferHdr)->pBuffer = (OMX_U8 *)m_pOutput_pmem[i].buffer;
(*bufferHdr)->pAppPrivate = appData;
@@ -3846,9 +3871,9 @@
post_event ((unsigned long)buffer,0,OMX_COMPONENT_GENERATE_EBD);
return OMX_ErrorBadParameter;
}
- } else if (input_use_buffer && !m_use_input_pmem)
+ } else if (input_use_buffer && !m_use_input_pmem && m_pInput_pmem[nBufIndex].buffer)
#else
- if (input_use_buffer && !m_use_input_pmem)
+ if (input_use_buffer && !m_use_input_pmem && m_pInput_pmem[nBufIndex].buffer)
#endif
{
DEBUG_PRINT_LOW("Heap UseBuffer case, so memcpy the data");
@@ -4387,6 +4412,12 @@
pending_output_buffers--;
+ if (secure_session && m_pCallbacks.FillBufferDone) {
+ if (buffer->nFilledLen > 0)
+ m_fbd_count++;
+ m_pCallbacks.FillBufferDone (hComp,m_app_data,buffer);
+ return OMX_ErrorNone;
+ }
if(!secure_session) {
extra_data_handle.create_extra_data(buffer);
#ifndef _MSM8974_
diff --git a/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp b/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp
index 2443cd3..716d985 100644
--- a/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp
+++ b/msmcobalt/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp
@@ -308,13 +308,21 @@
m_sSessionQuantization.nQpB = 2;
OMX_INIT_STRUCT(&m_sSessionQPRange, OMX_QCOM_VIDEO_PARAM_QPRANGETYPE);
+ OMX_INIT_STRUCT(&m_sSessionIPBQPRange, OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE);
m_sSessionQPRange.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
+ m_sSessionIPBQPRange.nPortIndex = (OMX_U32)PORT_INDEX_OUT;
m_sSessionQPRange.minQP = 2;
- if (codec_type == OMX_VIDEO_CodingAVC)
+ if (codec_type == OMX_VIDEO_CodingAVC) {
m_sSessionQPRange.maxQP = 51;
- else
+ } else {
m_sSessionQPRange.maxQP = 31;
-
+ }
+ m_sSessionIPBQPRange.minIQP =
+ m_sSessionIPBQPRange.minPQP =
+ m_sSessionIPBQPRange.minBQP = m_sSessionQPRange.minQP;
+ m_sSessionIPBQPRange.maxIQP =
+ m_sSessionIPBQPRange.maxPQP =
+ m_sSessionIPBQPRange.maxBQP = m_sSessionQPRange.maxQP;
OMX_INIT_STRUCT(&m_sAVCSliceFMO, OMX_VIDEO_PARAM_AVCSLICEFMO);
m_sAVCSliceFMO.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
m_sAVCSliceFMO.eSliceMode = OMX_VIDEO_SLICEMODE_AVCDefault;
@@ -1160,6 +1168,28 @@
break;
}
+ case OMX_QcomIndexParamVideoIPBQPRange:
+ {
+ DEBUG_PRINT_LOW("set_parameter: OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE");
+ OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE *qp_range = (OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE*) paramData;
+ if (qp_range->nPortIndex == PORT_INDEX_OUT) {
+ if (handle->venc_set_param(paramData,
+ (OMX_INDEXTYPE)OMX_QcomIndexParamVideoIPBQPRange) != true) {
+ return OMX_ErrorUnsupportedSetting;
+ }
+ m_sSessionIPBQPRange.minIQP = qp_range->minIQP;
+ m_sSessionIPBQPRange.maxIQP = qp_range->maxIQP;
+ m_sSessionIPBQPRange.minPQP = qp_range->minPQP;
+ m_sSessionIPBQPRange.maxPQP = qp_range->maxPQP;
+ m_sSessionIPBQPRange.minBQP = qp_range->minBQP;
+ m_sSessionIPBQPRange.maxBQP = qp_range->maxBQP;
+ } else {
+ DEBUG_PRINT_ERROR("Unsupported port Index for IPB QP range setting");
+ eRet = OMX_ErrorBadPortIndex;
+ }
+ break;
+ }
+
case OMX_QcomIndexPortDefn:
{
VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_PARAM_PORTDEFINITIONTYPE);
@@ -2122,6 +2152,14 @@
memcpy(&m_blurInfo, pParam, sizeof(m_blurInfo));
break;
}
+ case OMX_QcomIndexConfigH264Transform8x8:
+ {
+ if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_QcomIndexConfigH264Transform8x8)) {
+ DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigH264Transform8x8 failed");
+ return OMX_ErrorUnsupportedSetting;
+ }
+ break;
+ }
default:
DEBUG_PRINT_ERROR("ERROR: unsupported index %d", (int) configIndex);
break;
@@ -2431,6 +2469,7 @@
struct venc_msg *m_sVenc_msg = NULL;
OMX_BUFFERHEADERTYPE* omxhdr = NULL;
struct venc_buffer *temp_buff = NULL;
+ native_handle_t *nh = NULL;
if (context == NULL || message == NULL) {
DEBUG_PRINT_ERROR("ERROR: omx_venc::async_message_process invalid i/p params");
@@ -2502,7 +2541,7 @@
if ( (omxhdr != NULL) &&
((OMX_U32)(omxhdr - omx->m_out_mem_ptr) < omx->m_sOutPortDef.nBufferCountActual)) {
- if (m_sVenc_msg->buf.len <= omxhdr->nAllocLen) {
+ if (!omx->is_secure_session() && (m_sVenc_msg->buf.len <= omxhdr->nAllocLen)) {
omxhdr->nFilledLen = m_sVenc_msg->buf.len;
omxhdr->nOffset = m_sVenc_msg->buf.offset;
omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp;
@@ -2510,12 +2549,20 @@
omxhdr->nFlags = m_sVenc_msg->buf.flags;
/*Use buffer case*/
- if (omx->output_use_buffer && !omx->m_use_output_pmem) {
+ if (omx->output_use_buffer && !omx->m_use_output_pmem && !omx->is_secure_session()) {
DEBUG_PRINT_LOW("memcpy() for o/p Heap UseBuffer");
memcpy(omxhdr->pBuffer,
(m_sVenc_msg->buf.ptrbuffer),
m_sVenc_msg->buf.len);
}
+ } else if (omx->is_secure_session()) {
+ output_metabuffer *meta_buf = (output_metabuffer *)(omxhdr->pBuffer);
+ native_handle_t *nh = meta_buf->nh;
+ nh->data[1] = m_sVenc_msg->buf.offset;
+ nh->data[2] = m_sVenc_msg->buf.len;
+ omxhdr->nFilledLen = sizeof(output_metabuffer);
+ omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp;
+ omxhdr->nFlags = m_sVenc_msg->buf.flags;
} else {
omxhdr->nFilledLen = 0;
}
diff --git a/msmcobalt/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp b/msmcobalt/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp
index 958165d..5f2a48c 100644
--- a/msmcobalt/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp
+++ b/msmcobalt/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp
@@ -270,6 +270,7 @@
color_format = 0;
hw_overload = false;
mBatchSize = 0;
+ deinterlace_enabled = false;
pthread_mutex_init(&pause_resume_mlock, NULL);
pthread_cond_init(&pause_resume_cond, NULL);
memset(&input_extradata_info, 0, sizeof(input_extradata_info));
@@ -287,6 +288,7 @@
memset(&m_sInput_buff_property, 0, sizeof(m_sInput_buff_property));
memset(&m_sOutput_buff_property, 0, sizeof(m_sOutput_buff_property));
memset(&session_qp, 0, sizeof(session_qp));
+ memset(&session_ipb_qp_values, 0, sizeof(session_ipb_qp_values));
memset(&entropy, 0, sizeof(entropy));
memset(&dbkfilter, 0, sizeof(dbkfilter));
memset(&intra_refresh, 0, sizeof(intra_refresh));
@@ -660,7 +662,7 @@
height = ALIGN(m_sVenc_cfg.input_height, 32);
width = ALIGN(m_sVenc_cfg.input_width, 32);
- index = venc_get_index_from_fd(fd);
+ index = venc_get_index_from_fd(input_extradata_info.m_ion_dev,fd);
unsigned char *pVirt;
int size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height);
@@ -900,6 +902,7 @@
venc_handle->free_ion_memory(&extradata_info->ion);
return OMX_ErrorInsufficientResources;
}
+ extradata_info->m_ion_dev = open("/dev/ion", O_RDONLY);
}
#endif
@@ -916,6 +919,8 @@
close(output_extradata_info.ion.fd_ion_data.fd);
venc_handle->free_ion_memory(&output_extradata_info.ion);
}
+ if (output_extradata_info.m_ion_dev)
+ close(output_extradata_info.m_ion_dev);
memset(&output_extradata_info, 0, sizeof(output_extradata_info));
output_extradata_info.ion.fd_ion_data.fd = -1;
@@ -926,6 +931,9 @@
venc_handle->free_ion_memory(&input_extradata_info.ion);
}
+ if (input_extradata_info.m_ion_dev)
+ close(output_extradata_info.m_ion_dev);
+
memset(&input_extradata_info, 0, sizeof(input_extradata_info));
input_extradata_info.ion.fd_ion_data.fd = -1;
@@ -939,6 +947,11 @@
int venc_dev::venc_output_log_buffers(const char *buffer_addr, int buffer_len)
{
+ if (venc_handle->is_secure_session()) {
+ DEBUG_PRINT_ERROR("logging secure output buffers is not allowed!");
+ return -1;
+ }
+
if (!m_debug.outfile) {
int size = 0;
if(m_sVenc_cfg.codectype == V4L2_PIX_FMT_MPEG4) {
@@ -1023,6 +1036,11 @@
int venc_dev::venc_input_log_buffers(OMX_BUFFERHEADERTYPE *pbuffer, int fd, int plane_offset,
unsigned long inputformat) {
+ if (venc_handle->is_secure_session()) {
+ DEBUG_PRINT_ERROR("logging secure input buffers is not allowed!");
+ return -1;
+ }
+
if (!m_debug.infile) {
int size = snprintf(m_debug.infile_name, PROPERTY_VALUE_MAX, "%s/input_enc_%lu_%lu_%p.yuv",
m_debug.log_loc, m_sVenc_cfg.input_width, m_sVenc_cfg.input_height, this);
@@ -1194,6 +1212,12 @@
}
session_qp_values.minqp = session_qp_range.minqp;
session_qp_values.maxqp = session_qp_range.maxqp;
+ session_ipb_qp_values.min_i_qp = session_qp_range.minqp;
+ session_ipb_qp_values.max_i_qp = session_qp_range.maxqp;
+ session_ipb_qp_values.min_p_qp = session_qp_range.minqp;
+ session_ipb_qp_values.max_p_qp = session_qp_range.maxqp;
+ session_ipb_qp_values.min_b_qp = session_qp_range.minqp;
+ session_ipb_qp_values.max_b_qp = session_qp_range.maxqp;
int ret;
ret = subscribe_to_events(m_nDriver_fd);
@@ -1363,6 +1387,7 @@
input_extradata_info.port_index = OUTPUT_PORT;
output_extradata_info.port_index = CAPTURE_PORT;
+
return true;
}
@@ -1938,7 +1963,7 @@
DEBUG_PRINT_ERROR("ERROR: Failed to set vpx error resilience");
return false;
}
- if(!venc_set_ltrmode(1, 1)) {
+ if(!venc_set_ltrmode(1, ltrinfo.count)) {
DEBUG_PRINT_ERROR("ERROR: Failed to enable ltrmode");
return false;
}
@@ -2082,6 +2107,48 @@
break;
}
+ case OMX_QcomIndexParamVideoIPBQPRange:
+ {
+ DEBUG_PRINT_LOW("venc_set_param:OMX_QcomIndexParamVideoIPBQPRange");
+ OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE *qp =
+ (OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE *)paramData;
+ OMX_U32 min_IPB_packed_QP = 0;
+ OMX_U32 max_IPB_packed_QP = 0;
+ if (((qp->minIQP >= session_qp_range.minqp) && (qp->maxIQP <= session_qp_range.maxqp)) &&
+ ((qp->minPQP >= session_qp_range.minqp) && (qp->maxPQP <= session_qp_range.maxqp)) &&
+ ((qp->minBQP >= session_qp_range.minqp) && (qp->maxBQP <= session_qp_range.maxqp))) {
+
+ /* When creating the packet, pack the qp value as
+ * 0xbbppii, where ii = qp range for I-frames,
+ * pp = qp range for P-frames, etc. */
+ min_IPB_packed_QP = qp->minIQP | qp->minPQP << 8 | qp->minBQP << 16;
+ max_IPB_packed_QP = qp->maxIQP | qp->maxPQP << 8 | qp->maxBQP << 16;
+
+ if (qp->nPortIndex == (OMX_U32)PORT_INDEX_OUT) {
+ if (venc_set_session_qp_range_packed(min_IPB_packed_QP,
+ max_IPB_packed_QP) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Setting IPB QP Range[%d %d] failed",
+ min_IPB_packed_QP, max_IPB_packed_QP);
+ return false;
+ } else {
+ session_ipb_qp_values.min_i_qp = qp->minIQP;
+ session_ipb_qp_values.max_i_qp = qp->maxIQP;
+ session_ipb_qp_values.min_p_qp = qp->minPQP;
+ session_ipb_qp_values.max_p_qp = qp->maxPQP;
+ session_ipb_qp_values.min_b_qp = qp->minBQP;
+ session_ipb_qp_values.max_b_qp = qp->maxBQP;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_QcomIndexParamVideoIPBQPRange");
+ }
+ } else {
+ DEBUG_PRINT_ERROR("Wrong qp values: IQP range[%u %u], PQP range[%u,%u], BQP[%u,%u] range allowed range[%u %u]",
+ (unsigned int)qp->minIQP, (unsigned int)qp->maxIQP , (unsigned int)qp->minPQP,
+ (unsigned int)qp->maxPQP, (unsigned int)qp->minBQP, (unsigned int)qp->maxBQP,
+ (unsigned int)session_qp_range.minqp, (unsigned int)session_qp_range.maxqp);
+ }
+ break;
+ }
case OMX_QcomIndexEnableSliceDeliveryMode:
{
QOMX_EXTNINDEX_PARAMTYPE* pParam =
@@ -2212,7 +2279,7 @@
// Disable ltr if hier-p is enabled.
if (m_codec == OMX_VIDEO_CodingVP8) {
DEBUG_PRINT_LOW("Disable LTR as HIER-P is being set");
- if(!venc_set_ltrmode(0, 1)) {
+ if(!venc_set_ltrmode(0, 0)) {
DEBUG_PRINT_ERROR("ERROR: Failed to disable ltrmode");
}
}
@@ -2479,11 +2546,12 @@
DEBUG_PRINT_ERROR("ERROR: Rotation is not supported with deinterlacing");
return false;
}
- DEBUG_PRINT_HIGH("venc_set_config: updating the new Dims");
- nFrameWidth = m_sVenc_cfg.dvs_width;
- m_sVenc_cfg.dvs_width = m_sVenc_cfg.dvs_height;
- m_sVenc_cfg.dvs_height = nFrameWidth;
-
+ if (config_rotation->nRotation == 90 || config_rotation->nRotation == 270) {
+ DEBUG_PRINT_HIGH("venc_set_config: updating the new Dims");
+ nFrameWidth = m_sVenc_cfg.dvs_width;
+ m_sVenc_cfg.dvs_width = m_sVenc_cfg.dvs_height;
+ m_sVenc_cfg.dvs_height = nFrameWidth;
+ }
if(venc_set_vpe_rotation(config_rotation->nRotation) == false) {
DEBUG_PRINT_ERROR("ERROR: Dimension Change for Rotation failed");
return false;
@@ -2683,6 +2751,16 @@
}
break;
}
+ case OMX_QcomIndexConfigH264Transform8x8:
+ {
+ OMX_CONFIG_BOOLEANTYPE *pEnable = (OMX_CONFIG_BOOLEANTYPE *) configData;
+ DEBUG_PRINT_LOW("venc_set_config: OMX_QcomIndexConfigH264Transform8x8");
+ if (venc_h264_transform_8x8(pEnable->bEnabled) == false) {
+ DEBUG_PRINT_ERROR("Failed to set OMX_QcomIndexConfigH264Transform8x8");
+ return false;
+ }
+ break;
+ }
default:
DEBUG_PRINT_ERROR("Unsupported config index = %u", index);
break;
@@ -3108,7 +3186,7 @@
buf.length = num_input_planes;
if (extra_idx && (extra_idx < VIDEO_MAX_PLANES)) {
- extradata_index = venc_get_index_from_fd(pmem_tmp->fd);
+ extradata_index = venc_get_index_from_fd(input_extradata_info.m_ion_dev, pmem_tmp->fd);
if (extradata_index < 0 ) {
DEBUG_PRINT_ERROR("Extradata index calculation went wrong for fd = %d", pmem_tmp->fd);
return OMX_ErrorBadParameter;
@@ -3491,7 +3569,7 @@
extra_idx = EXTRADATA_IDX(num_input_planes);
if (extra_idx && (extra_idx < VIDEO_MAX_PLANES)) {
- int extradata_index = venc_get_index_from_fd(fd);
+ int extradata_index = venc_get_index_from_fd(input_extradata_info.m_ion_dev,fd);
if (extradata_index < 0 ) {
DEBUG_PRINT_ERROR("Extradata index calculation went wrong for fd = %d", fd);
return OMX_ErrorBadParameter;
@@ -3718,6 +3796,12 @@
buf.length = num_output_planes;
buf.flags = 0;
+ if (venc_handle->is_secure_session()) {
+ output_metabuffer *meta_buf = (output_metabuffer *)(bufhdr->pBuffer);
+ native_handle_t *handle_t = meta_buf->nh;
+ plane[0].length = handle_t->data[3];
+ }
+
if (mBatchSize) {
// Should always mark first buffer as DEFER, since 0 % anything is 0, just offset by 1
// This results in the first batch being of size mBatchSize + 1, but thats good because
@@ -3809,21 +3893,29 @@
return true;
}
-int venc_dev::venc_get_index_from_fd(OMX_U32 fd)
+int venc_dev::venc_get_index_from_fd(OMX_U32 ion_fd, OMX_U32 buffer_fd)
{
- unsigned int i = 0;
- for (;i < 64; i++) {
- if (fd_list[i] == fd) {
+ unsigned int cookie = buffer_fd;
+ struct ion_fd_data fdData;
+
+ memset(&fdData, 0, sizeof(fdData));
+ fdData.fd = buffer_fd;
+ if (ion_fd && !ioctl(ion_fd, ION_IOC_IMPORT, &fdData)) {
+ cookie = fdData.handle;
+ }
+
+ for (int i = 0; i < 64; i++) {
+ if (fd_list[i] == cookie) {
DEBUG_PRINT_HIGH("FD is present at index = %d", i);
return i;
}
}
- for (i = 0;i < 64; i++)
+ for (int i = 0; i < 64; i++)
if (fd_list[i] == 0) {
DEBUG_PRINT_HIGH("FD added at index = %d", i);
- fd_list[i] = fd;
+ fd_list[i] = cookie;
return i;
- }
+ }
return -EINVAL;
}
@@ -4153,6 +4245,36 @@
return true;
}
+bool venc_dev::venc_set_session_qp_range_packed(OMX_U32 min_qp, OMX_U32 max_qp)
+{
+ int rc;
+ struct v4l2_control control;
+
+ control.id = V4L2_CID_MPEG_VIDEO_MIN_QP_PACKED;
+ control.value = min_qp;
+
+ DEBUG_PRINT_LOW("Calling IOCTL set MIN_QP_PACKED control id=%d, val=%d",
+ control.id, control.value);
+ rc = ioctl(m_nDriver_fd, VIDIOC_S_CTRL, &control);
+ if (rc) {
+ DEBUG_PRINT_ERROR("Failed to set control");
+ return false;
+ }
+
+ control.id = V4L2_CID_MPEG_VIDEO_MAX_QP_PACKED;
+ control.value = max_qp;
+
+ DEBUG_PRINT_LOW("Calling IOCTL set MAX_QP_PACKED control id=%d, val=%d",
+ control.id, control.value);
+ rc = ioctl(m_nDriver_fd, VIDIOC_S_CTRL, &control);
+ if (rc) {
+ DEBUG_PRINT_ERROR("Failed to set control");
+ return false;
+ }
+
+ return true;
+}
+
bool venc_dev::venc_set_profile_level(OMX_U32 eProfile,OMX_U32 eLevel)
{
struct venc_profile requested_profile = {0};
@@ -5649,7 +5771,7 @@
int rc = 0;
control.id = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL;
- switch (eControlRate) {
+ switch ((OMX_U32)eControlRate) {
case OMX_Video_ControlRateDisable:
control.value = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_OFF;
break;
@@ -5673,6 +5795,16 @@
control.value = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_CBR_CFR :
status = false;
break;
+ case QOMX_Video_ControlRateMaxBitrate:
+ (supported_rc_modes & RC_MBR_CFR) ?
+ control.value = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_MBR_CFR:
+ status = false;
+ break;
+ case QOMX_Video_ControlRateMaxBitrateSkipFrames:
+ (supported_rc_modes & RC_MBR_VFR) ?
+ control.value = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_MBR_VFR:
+ status = false;
+ break;
default:
status = false;
break;
@@ -6054,6 +6186,25 @@
}
+bool venc_dev::venc_h264_transform_8x8(OMX_BOOL enable)
+{
+ struct v4l2_control control;
+
+ control.id = V4L2_CID_MPEG_VIDC_VIDEO_H264_TRANSFORM_8x8;
+ if (enable)
+ control.value = V4L2_MPEG_VIDC_VIDEO_H264_TRANSFORM_8x8_ENABLE;
+ else
+ control.value = V4L2_MPEG_VIDC_VIDEO_H264_TRANSFORM_8x8_DISABLE;
+
+ DEBUG_PRINT_LOW("Set h264_transform_8x8 mode: %d", control.value);
+ if (ioctl(m_nDriver_fd, VIDIOC_S_CTRL, &control)) {
+ DEBUG_PRINT_ERROR("set control: H264 transform 8x8 failed");
+ return false;
+ }
+
+ return true;
+}
+
bool venc_dev::venc_get_profile_level(OMX_U32 *eProfile,OMX_U32 *eLevel)
{
bool status = true;
