summaryrefslogtreecommitdiff
path: root/msmcobalt/mm-video-v4l2/vidc/venc/src/video_encoder_device.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'msmcobalt/mm-video-v4l2/vidc/venc/src/video_encoder_device.cpp')
-rw-r--r--msmcobalt/mm-video-v4l2/vidc/venc/src/video_encoder_device.cpp3149
1 files changed, 3149 insertions, 0 deletions
diff --git a/msmcobalt/mm-video-v4l2/vidc/venc/src/video_encoder_device.cpp b/msmcobalt/mm-video-v4l2/vidc/venc/src/video_encoder_device.cpp
new file mode 100644
index 0000000..855c79f
--- /dev/null
+++ b/msmcobalt/mm-video-v4l2/vidc/venc/src/video_encoder_device.cpp
@@ -0,0 +1,3149 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of The Linux Foundation nor
+ the names of its contributors may be used to endorse or promote
+ products derived from this software without specific prior written
+ permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+#include<string.h>
+#include <sys/ioctl.h>
+#include <sys/prctl.h>
+#include<unistd.h>
+#include <fcntl.h>
+#include "video_encoder_device.h"
+#include "omx_video_encoder.h"
+#include <linux/android_pmem.h>
+#ifdef USE_ION
+#include <linux/msm_ion.h>
+#endif
+
+#define MPEG4_SP_START 0
+#define MPEG4_ASP_START (MPEG4_SP_START + 8)
+#define MPEG4_720P_LEVEL 6
+#define H263_BP_START 0
+#define H264_BP_START 0
+#define H264_HP_START (H264_BP_START + 13)
+#define H264_MP_START (H264_BP_START + 26)
+
+/* MPEG4 profile and level table*/
+static const unsigned int mpeg4_profile_level_table[][5]= {
+ /*max mb per frame, max mb per sec, max bitrate, level, profile*/
+ {99,1485,64000,OMX_VIDEO_MPEG4Level0,OMX_VIDEO_MPEG4ProfileSimple},
+ {99,1485,64000,OMX_VIDEO_MPEG4Level1,OMX_VIDEO_MPEG4ProfileSimple},
+ {396,5940,128000,OMX_VIDEO_MPEG4Level2,OMX_VIDEO_MPEG4ProfileSimple},
+ {396,11880,384000,OMX_VIDEO_MPEG4Level3,OMX_VIDEO_MPEG4ProfileSimple},
+ {1200,36000,4000000,OMX_VIDEO_MPEG4Level4a,OMX_VIDEO_MPEG4ProfileSimple},
+ {1620,40500,8000000,OMX_VIDEO_MPEG4Level5,OMX_VIDEO_MPEG4ProfileSimple},
+ {3600,108000,12000000,OMX_VIDEO_MPEG4Level5,OMX_VIDEO_MPEG4ProfileSimple},
+ {0,0,0,0,0},
+
+ {99,1485,128000,OMX_VIDEO_MPEG4Level0,OMX_VIDEO_MPEG4ProfileAdvancedSimple},
+ {99,1485,128000,OMX_VIDEO_MPEG4Level1,OMX_VIDEO_MPEG4ProfileAdvancedSimple},
+ {396,5940,384000,OMX_VIDEO_MPEG4Level2,OMX_VIDEO_MPEG4ProfileAdvancedSimple},
+ {396,11880,768000,OMX_VIDEO_MPEG4Level3,OMX_VIDEO_MPEG4ProfileAdvancedSimple},
+ {792,23760,3000000,OMX_VIDEO_MPEG4Level4,OMX_VIDEO_MPEG4ProfileAdvancedSimple},
+ {1620,48600,8000000,OMX_VIDEO_MPEG4Level5,OMX_VIDEO_MPEG4ProfileAdvancedSimple},
+ {0,0,0,0,0},
+};
+
+/* H264 profile and level table*/
+static const unsigned int h264_profile_level_table[][5]= {
+ /*max mb per frame, max mb per sec, max bitrate, level, profile*/
+ {99,1485,64000,OMX_VIDEO_AVCLevel1,OMX_VIDEO_AVCProfileBaseline},
+ {99,1485,128000,OMX_VIDEO_AVCLevel1b,OMX_VIDEO_AVCProfileBaseline},
+ {396,3000,192000,OMX_VIDEO_AVCLevel11,OMX_VIDEO_AVCProfileBaseline},
+ {396,6000,384000,OMX_VIDEO_AVCLevel12,OMX_VIDEO_AVCProfileBaseline},
+ {396,11880,768000,OMX_VIDEO_AVCLevel13,OMX_VIDEO_AVCProfileBaseline},
+ {396,11880,2000000,OMX_VIDEO_AVCLevel2,OMX_VIDEO_AVCProfileBaseline},
+ {792,19800,4000000,OMX_VIDEO_AVCLevel21,OMX_VIDEO_AVCProfileBaseline},
+ {1620,20250,4000000,OMX_VIDEO_AVCLevel22,OMX_VIDEO_AVCProfileBaseline},
+ {1620,40500,10000000,OMX_VIDEO_AVCLevel3,OMX_VIDEO_AVCProfileBaseline},
+ {3600,108000,14000000,OMX_VIDEO_AVCLevel31,OMX_VIDEO_AVCProfileBaseline},
+ {5120,216000,20000000,OMX_VIDEO_AVCLevel32,OMX_VIDEO_AVCProfileBaseline},
+ {8192,245760,20000000,OMX_VIDEO_AVCLevel4,OMX_VIDEO_AVCProfileBaseline},
+ {0,0,0,0,0},
+
+ {99,1485,64000,OMX_VIDEO_AVCLevel1,OMX_VIDEO_AVCProfileHigh},
+ {99,1485,160000,OMX_VIDEO_AVCLevel1b,OMX_VIDEO_AVCProfileHigh},
+ {396,3000,240000,OMX_VIDEO_AVCLevel11,OMX_VIDEO_AVCProfileHigh},
+ {396,6000,480000,OMX_VIDEO_AVCLevel12,OMX_VIDEO_AVCProfileHigh},
+ {396,11880,960000,OMX_VIDEO_AVCLevel13,OMX_VIDEO_AVCProfileHigh},
+ {396,11880,2500000,OMX_VIDEO_AVCLevel2,OMX_VIDEO_AVCProfileHigh},
+ {792,19800,5000000,OMX_VIDEO_AVCLevel21,OMX_VIDEO_AVCProfileHigh},
+ {1620,20250,5000000,OMX_VIDEO_AVCLevel22,OMX_VIDEO_AVCProfileHigh},
+ {1620,40500,12500000,OMX_VIDEO_AVCLevel3,OMX_VIDEO_AVCProfileHigh},
+ {3600,108000,17500000,OMX_VIDEO_AVCLevel31,OMX_VIDEO_AVCProfileHigh},
+ {5120,216000,25000000,OMX_VIDEO_AVCLevel32,OMX_VIDEO_AVCProfileHigh},
+ {8192,245760,25000000,OMX_VIDEO_AVCLevel4,OMX_VIDEO_AVCProfileHigh},
+ {0,0,0,0,0},
+
+ {99,1485,64000,OMX_VIDEO_AVCLevel1,OMX_VIDEO_AVCProfileMain},
+ {99,1485,128000,OMX_VIDEO_AVCLevel1b,OMX_VIDEO_AVCProfileMain},
+ {396,3000,192000,OMX_VIDEO_AVCLevel11,OMX_VIDEO_AVCProfileMain},
+ {396,6000,384000,OMX_VIDEO_AVCLevel12,OMX_VIDEO_AVCProfileMain},
+ {396,11880,768000,OMX_VIDEO_AVCLevel13,OMX_VIDEO_AVCProfileMain},
+ {396,11880,2000000,OMX_VIDEO_AVCLevel2,OMX_VIDEO_AVCProfileMain},
+ {792,19800,4000000,OMX_VIDEO_AVCLevel21,OMX_VIDEO_AVCProfileMain},
+ {1620,20250,4000000,OMX_VIDEO_AVCLevel22,OMX_VIDEO_AVCProfileMain},
+ {1620,40500,10000000,OMX_VIDEO_AVCLevel3,OMX_VIDEO_AVCProfileMain},
+ {3600,108000,14000000,OMX_VIDEO_AVCLevel31,OMX_VIDEO_AVCProfileMain},
+ {5120,216000,20000000,OMX_VIDEO_AVCLevel32,OMX_VIDEO_AVCProfileMain},
+ {8192,245760,20000000,OMX_VIDEO_AVCLevel4,OMX_VIDEO_AVCProfileMain},
+ {0,0,0,0,0}
+
+};
+
+/* H263 profile and level table*/
+static const unsigned int h263_profile_level_table[][5]= {
+ /*max mb per frame, max mb per sec, max bitrate, level, profile*/
+ {99,1485,64000,OMX_VIDEO_H263Level10,OMX_VIDEO_H263ProfileBaseline},
+ {396,5940,128000,OMX_VIDEO_H263Level20,OMX_VIDEO_H263ProfileBaseline},
+ {396,11880,384000,OMX_VIDEO_H263Level30,OMX_VIDEO_H263ProfileBaseline},
+ {396,11880,2048000,OMX_VIDEO_H263Level40,OMX_VIDEO_H263ProfileBaseline},
+ {99,1485,128000,OMX_VIDEO_H263Level45,OMX_VIDEO_H263ProfileBaseline},
+ {396,19800,4096000,OMX_VIDEO_H263Level50,OMX_VIDEO_H263ProfileBaseline},
+ {810,40500,8192000,OMX_VIDEO_H263Level60,OMX_VIDEO_H263ProfileBaseline},
+ {1620,81000,16384000,OMX_VIDEO_H263Level70,OMX_VIDEO_H263ProfileBaseline},
+ {0,0,0,0,0}
+};
+
+#define Log2(number, power) { OMX_U32 temp = number; power = 0; while( (0 == (temp & 0x1)) && power < 16) { temp >>=0x1; power++; } }
+#define Q16ToFraction(q,num,den) { OMX_U32 power; Log2(q,power); num = q >> power; den = 0x1 << (16 - power); }
+
+#define BUFFER_LOG_LOC "/data/misc/media"
+
+//constructor
+venc_dev::venc_dev(class omx_venc *venc_class)
+{
+ m_max_allowed_bitrate_check = false;
+ m_eLevel = 0;
+ m_eProfile = 0;
+ pthread_mutex_init(&loaded_start_stop_mlock, NULL);
+ pthread_cond_init (&loaded_start_stop_cond, NULL);
+ memset(&m_debug,0,sizeof(m_debug));
+
+ char property_value[PROPERTY_VALUE_MAX] = {0};
+ property_value[0] = '\0';
+ property_get("vidc.enc.log.in", property_value, "0");
+ m_debug.in_buffer_log = atoi(property_value);
+
+ property_value[0] = '\0';
+ property_get("vidc.enc.log.out", property_value, "0");
+ m_debug.out_buffer_log = atoi(property_value);
+ snprintf(m_debug.log_loc, PROPERTY_VAL_MAX,
+ "%s", BUFFER_LOG_LOC);
+
+ DEBUG_PRINT_LOW("venc_dev constructor");
+}
+
+venc_dev::~venc_dev()
+{
+ pthread_cond_destroy(&loaded_start_stop_cond);
+ pthread_mutex_destroy(&loaded_start_stop_mlock);
+ DEBUG_PRINT_LOW("venc_dev distructor");
+}
+
+void* async_venc_message_thread (void *input)
+{
+ struct venc_ioctl_msg ioctl_msg ={NULL,NULL};
+ struct venc_timeout timeout;
+ struct venc_msg venc_msg;
+ int error_code = 0;
+ omx_venc *omx = reinterpret_cast<omx_venc*>(input);
+
+ prctl(PR_SET_NAME, (unsigned long)"VideoEncCallBackThread", 0, 0, 0);
+ timeout.millisec = VEN_TIMEOUT_INFINITE;
+
+ while (1) {
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = (void*)&venc_msg;
+
+ /*Wait for a message from the video decoder driver*/
+ error_code = ioctl(omx->handle->m_nDriver_fd,VEN_IOCTL_CMD_READ_NEXT_MSG,(void *)&ioctl_msg);
+
+ if (error_code == -512) { // ERESTARTSYS
+ DEBUG_PRINT_ERROR("ERESTARTSYS received in ioctl read next msg!");
+ } else if (error_code <0) {
+ DEBUG_PRINT_LOW("ioctl VEN_IOCTL_CMD_READ_NEXT_MSG failed");
+ break;
+ } else if (omx->async_message_process(input,&venc_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Wrong ioctl message");
+ break;
+ }
+ }
+ DEBUG_PRINT_HIGH("omx_venc: Async Thread exit");
+ return NULL;
+}
+
+int venc_dev::venc_extradata_log_buffers(char *buffer_addr)
+{
+ return OMX_ErrorUnsupportedSetting;
+}
+
+int venc_dev::venc_output_log_buffers(const char *buffer_addr, int buffer_len)
+{
+ if (m_debug.out_buffer_log && !m_debug.outfile) {
+ int size = 0;
+ if(m_sVenc_cfg.codectype == VEN_CODEC_MPEG4) {
+ size = snprintf(m_debug.outfile_name, PROPERTY_VALUE_MAX, "%s/output_enc_%d_%d_%p.m4v",
+ m_debug.log_loc, m_sVenc_cfg.input_width, m_sVenc_cfg.input_height, this);
+ } else if(m_sVenc_cfg.codectype == VEN_CODEC_H264) {
+ size = snprintf(m_debug.outfile_name, PROPERTY_VALUE_MAX, "%s/output_enc_%d_%d_%p.264",
+ m_debug.log_loc, m_sVenc_cfg.input_width, m_sVenc_cfg.input_height, this);
+ } else if(m_sVenc_cfg.codectype == VENC_CODEC_H263) {
+ size = snprintf(m_debug.outfile_name, PROPERTY_VALUE_MAX, "%s/output_enc_%d_%d_%p.263",
+ m_debug.log_loc, m_sVenc_cfg.input_width, m_sVenc_cfg.input_height, this);
+ } else if(m_sVenc_cfg.codectype == VENC_CODEC_VP8) {
+ size = snprintf(m_debug.outfile_name, PROPERTY_VALUE_MAX, "%s/output_enc_%d_%d_%p.ivf",
+ m_debug.log_loc, m_sVenc_cfg.input_width, m_sVenc_cfg.input_height, this);
+ }
+ if ((size > PROPERTY_VALUE_MAX) || (size < 0)) {
+ DEBUG_PRINT_ERROR("Failed to open output file: %s for logging as size:%d",
+ m_debug.outfile_name, size);
+ return -1;
+ }
+ m_debug.outfile = fopen(m_debug.outfile_name, "ab");
+ if (!m_debug.outfile) {
+ DEBUG_PRINT_ERROR("Failed to open output file: %s for logging errno:%d",
+ m_debug.outfile_name, errno);
+ m_debug.outfile_name[0] = '\0';
+ return -1;
+ }
+ }
+ if (m_debug.outfile && buffer_len) {
+ DEBUG_PRINT_LOW("%s buffer_len:%d", __func__, buffer_len);
+ fwrite(buffer_addr, buffer_len, 1, m_debug.outfile);
+ }
+ return 0;
+}
+
+bool venc_dev::venc_get_output_log_flag()
+{
+ return (m_debug.out_buffer_log == 1);
+}
+
+int venc_dev::venc_input_log_buffers(OMX_BUFFERHEADERTYPE *pbuffer, void *pmem_data_buf, int framelen) {
+ if (!m_debug.infile) {
+ int size = snprintf(m_debug.infile_name, PROPERTY_VALUE_MAX, "%s/input_enc_%d_%d_%p.yuv",
+ m_debug.log_loc, m_sVenc_cfg.input_width,
+ m_sVenc_cfg.input_height, this);
+ if ((size > PROPERTY_VALUE_MAX) || (size < 0)) {
+ DEBUG_PRINT_ERROR("Failed to open input file: %s for logging size:%d",
+ m_debug.infile_name, size);
+ return -1;
+ }
+ m_debug.infile = fopen (m_debug.infile_name, "ab");
+ if (!m_debug.infile) {
+ DEBUG_PRINT_HIGH("Failed to open input file: %s for logging", m_debug.infile);
+ m_debug.infile_name[0] = '\0';
+ return -1;
+ }
+ }
+ if (m_debug.infile && pbuffer && pbuffer->nFilledLen) {
+#ifdef MAX_RES_1080P
+ int y_size = 0;
+ int c_offset = 0;
+ unsigned char *buf_addr = NULL;
+
+ y_size = m_sVenc_cfg.input_width * m_sVenc_cfg.input_height;
+ //chroma offset is y_size aligned to the 2k boundary
+ c_offset= (y_size + 2047) & (~(2047));
+
+ if (pmem_data_buf) {
+ DEBUG_PRINT_LOW("Internal PMEM addr for i/p Heap UseBuf: %p", pmem_data_buf);
+ buf_addr = (OMX_U8 *)pmem_data_buf;
+ } else {
+ DEBUG_PRINT_LOW("Shared PMEM addr for i/p PMEM UseBuf/AllocateBuf: %p", bufhdr->pBuffer);
+ buf_addr = (unsigned char *)mmap(NULL,
+ ((encoder_media_buffer_type *)pbuffer->pBuffer)->meta_handle->data[2],
+ PROT_READ|PROT_WRITE, MAP_SHARED,
+ ((encoder_media_buffer_type *)pbuffer->pBuffer)->meta_handle->data[0], 0);
+ }
+
+ if (m_debug.infile) {
+ fwrite((const char *)buf_addr, y_size, 1, m_debug.infile);
+ fwrite((const char *)(buf_addr + c_offset), (y_size>>1), 1, m_debug.infile);
+ }
+
+ if (!pmem_data_buf) {
+ munmap (buf_addr, ((encoder_media_buffer_type *)pbuffer->pBuffer)->meta_handle->data[2]);
+ }
+#else
+ if (m_debug.infile) {
+ OMX_U8* ptrbuffer = NULL;
+ if (pmem_data_buf) {
+ DEBUG_PRINT_LOW("Internal PMEM addr for i/p Heap UseBuf: %p", pmem_data_buf);
+ ptrbuffer = (OMX_U8 *)pmem_data_buf;
+ } else {
+ DEBUG_PRINT_LOW("Shared PMEM addr for i/p PMEM UseBuf/AllocateBuf: %p", bufhdr->pBuffer);
+ ptrbuffer = (OMX_U8 *)bufhdr->pBuffer;
+ }
+ fwrite((const char *)ptrbuffer, framelen, 1, m_debug.infile);
+ }
+
+#endif
+ }
+ return 0;
+}
+
+bool venc_dev::venc_open(OMX_U32 codec)
+{
+ struct venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ int r;
+ unsigned int alignment = 0,buffer_size = 0, temp =0;
+
+ m_nDriver_fd = open ("/dev/msm_vidc_enc",O_RDWR|O_NONBLOCK);
+
+ if (m_nDriver_fd == 0) {
+ DEBUG_PRINT_ERROR("ERROR: Got fd as 0 for msm_vidc_enc, Opening again");
+ m_nDriver_fd = open ("/dev/msm_vidc_enc",O_RDWR|O_NONBLOCK);
+ }
+
+ if ((int)m_nDriver_fd < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Omx_venc::Comp Init Returning failure");
+ return false;
+ }
+
+ DEBUG_PRINT_LOW("m_nDriver_fd = %d", m_nDriver_fd);
+#ifdef SINGLE_ENCODER_INSTANCE
+ OMX_U32 num_instances = 0;
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = &num_instances;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_GET_NUMBER_INSTANCES, (void*)&ioctl_msg) < 0 ) {
+ DEBUG_PRINT_ERROR("ERROR: Request number of encoder instances failed");
+ } else if (num_instances > 1) {
+ DEBUG_PRINT_ERROR("Second encoder instance rejected!");
+ venc_close();
+ return false;
+ }
+
+#endif
+ // set the basic configuration of the video encoder driver
+ m_sVenc_cfg.input_width = OMX_CORE_QCIF_WIDTH;
+ m_sVenc_cfg.input_height= OMX_CORE_QCIF_HEIGHT;
+ m_sVenc_cfg.dvs_width = OMX_CORE_QCIF_WIDTH;
+ m_sVenc_cfg.dvs_height = OMX_CORE_QCIF_HEIGHT;
+ m_sVenc_cfg.fps_num = 30;
+ m_sVenc_cfg.fps_den = 1;
+ m_sVenc_cfg.targetbitrate = 64000;
+#ifdef MAX_RES_1080P
+ m_sVenc_cfg.inputformat= VEN_INPUTFMT_NV12_16M2KA;
+#else
+ m_sVenc_cfg.inputformat= VEN_INPUTFMT_NV12;
+#endif
+ // initializing QP range parameters
+ qp_range.minqp = 2;
+
+ if (codec == OMX_VIDEO_CodingAVC)
+ qp_range.maxqp = 51;
+ else
+ qp_range.maxqp = 31;
+
+ if (codec == OMX_VIDEO_CodingMPEG4) {
+ m_sVenc_cfg.codectype = VEN_CODEC_MPEG4;
+ codec_profile.profile = VEN_PROFILE_MPEG4_SP;
+ profile_level.level = VEN_LEVEL_MPEG4_2;
+ } else if (codec == OMX_VIDEO_CodingH263) {
+ m_sVenc_cfg.codectype = VEN_CODEC_H263;
+ codec_profile.profile = VEN_PROFILE_H263_BASELINE;
+ profile_level.level = VEN_LEVEL_H263_20;
+ }
+
+ if (codec == OMX_VIDEO_CodingAVC) {
+ m_sVenc_cfg.codectype = VEN_CODEC_H264;
+ codec_profile.profile = VEN_PROFILE_H264_BASELINE;
+ profile_level.level = VEN_LEVEL_H264_1p1;
+ }
+
+ ioctl_msg.in = (void*)&m_sVenc_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_BASE_CFG,(void*)&ioctl_msg) < 0 ) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting base configuration failed");
+ return false;
+ }
+
+ // Get the I/P and O/P buffer requirements
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = (void*)&m_sInput_buff_property;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_GET_INPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for getting i/p buffer requirement failed");
+ return false;
+ }
+
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = (void*)&m_sOutput_buff_property;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_GET_OUTPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for getting o/p buffer requirement failed");
+ return false;
+ }
+
+ m_profile_set = false;
+ m_level_set = false;
+
+ if (venc_set_profile_level(0, 0)) {
+ DEBUG_PRINT_HIGH("%s(): Init Profile/Level setting success",
+ __func__);
+ }
+
+ recon_buffers_count = MAX_RECON_BUFFERS;
+ ltrmode.ltr_mode = 0;
+ ltrcount.ltr_count = 0;
+ ltrperiod.ltr_period = 0;
+
+ return true;
+}
+
+void venc_dev::venc_close()
+{
+ DEBUG_PRINT_LOW("venc_close: fd = %d", m_nDriver_fd);
+
+ if ((int)m_nDriver_fd >= 0) {
+ DEBUG_PRINT_HIGH("venc_close(): Calling VEN_IOCTL_CMD_STOP_READ_MSG");
+ (void)ioctl(m_nDriver_fd, VEN_IOCTL_CMD_STOP_READ_MSG,
+ NULL);
+ DEBUG_PRINT_LOW("Calling close()");
+ close(m_nDriver_fd);
+ m_nDriver_fd = -1;
+ }
+
+ if (m_debug.infile) {
+ fclose(m_debug.infile);
+ m_debug.infile = NULL;
+ }
+ if (m_debug.outfile) {
+ fclose(m_debug.outfile);
+ m_debug.outfile = NULL;
+ }
+
+}
+
+bool venc_dev::venc_set_buf_req(unsigned long *min_buff_count,
+ unsigned long *actual_buff_count,
+ unsigned long *buff_size,
+ unsigned long port)
+{
+ struct venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ unsigned long temp_count = 0;
+
+ if (port == 0) {
+ if (*actual_buff_count > m_sInput_buff_property.mincount) {
+ temp_count = m_sInput_buff_property.actualcount;
+ m_sInput_buff_property.actualcount = *actual_buff_count;
+ ioctl_msg.in = (void*)&m_sInput_buff_property;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_INPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting i/p buffer requirement failed");
+ m_sInput_buff_property.actualcount = temp_count;
+ return false;
+ }
+
+ DEBUG_PRINT_LOW("I/P Count set to %lu", *actual_buff_count);
+ }
+ } else {
+ if (*actual_buff_count > m_sOutput_buff_property.mincount) {
+ temp_count = m_sOutput_buff_property.actualcount;
+ m_sOutput_buff_property.actualcount = *actual_buff_count;
+ ioctl_msg.in = (void*)&m_sOutput_buff_property;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_OUTPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting o/p buffer requirement failed");
+ m_sOutput_buff_property.actualcount = temp_count;
+ return false;
+ }
+
+ DEBUG_PRINT_LOW("O/P Count set to %lu", *actual_buff_count);
+ }
+ }
+
+ return true;
+
+}
+
+bool venc_dev::venc_loaded_start()
+{
+ struct timespec ts;
+ int status = 0;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_CMD_START, NULL) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: VEN_IOCTL_CMD_START failed");
+ return false;
+ }
+
+ if (clock_gettime(CLOCK_REALTIME, &ts) < 0) {
+ DEBUG_PRINT_ERROR("%s: clock_gettime failed", __func__);
+ return false;
+ }
+
+ ts.tv_sec += 1;
+ pthread_mutex_lock(&loaded_start_stop_mlock);
+ DEBUG_PRINT_LOW("%s: wait on start done", __func__);
+ status = pthread_cond_timedwait(&loaded_start_stop_cond,
+ &loaded_start_stop_mlock, &ts);
+
+ if (status != 0) {
+ DEBUG_PRINT_ERROR("%s: error status = %d, %s", __func__,
+ status, strerror(status));
+ pthread_mutex_unlock(&loaded_start_stop_mlock);
+ return false;
+ }
+
+ DEBUG_PRINT_LOW("%s: wait over on start done", __func__);
+ pthread_mutex_unlock(&loaded_start_stop_mlock);
+ DEBUG_PRINT_LOW("%s: venc_loaded_start success", __func__);
+ return true;
+}
+
+bool venc_dev::venc_loaded_stop()
+{
+ struct timespec ts;
+ int status = 0;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_CMD_STOP, NULL) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: VEN_IOCTL_CMD_STOP failed");
+ return false;
+ }
+
+ if (clock_gettime(CLOCK_REALTIME, &ts) < 0) {
+ DEBUG_PRINT_ERROR("%s: clock_gettime failed", __func__);
+ return false;
+ }
+
+ ts.tv_sec += 1;
+ pthread_mutex_lock(&loaded_start_stop_mlock);
+ DEBUG_PRINT_LOW("%s: wait on stop done", __func__);
+ status = pthread_cond_timedwait(&loaded_start_stop_cond,
+ &loaded_start_stop_mlock, &ts);
+
+ if (status != 0) {
+ DEBUG_PRINT_ERROR("%s: error status = %d, %s", __func__,
+ status, strerror(status));
+ pthread_mutex_unlock(&loaded_start_stop_mlock);
+ return false;
+ }
+
+ DEBUG_PRINT_LOW("%s: wait over on stop done", __func__);
+ pthread_mutex_unlock(&loaded_start_stop_mlock);
+ DEBUG_PRINT_LOW("%s: venc_loaded_stop success", __func__);
+ return true;
+}
+
+bool venc_dev::venc_loaded_start_done()
+{
+ pthread_mutex_lock(&loaded_start_stop_mlock);
+ DEBUG_PRINT_LOW("%s: signal start done", __func__);
+ pthread_cond_signal(&loaded_start_stop_cond);
+ pthread_mutex_unlock(&loaded_start_stop_mlock);
+ return true;
+}
+
+bool venc_dev::venc_loaded_stop_done()
+{
+ pthread_mutex_lock(&loaded_start_stop_mlock);
+ DEBUG_PRINT_LOW("%s: signal stop done", __func__);
+ pthread_cond_signal(&loaded_start_stop_cond);
+ pthread_mutex_unlock(&loaded_start_stop_mlock);
+ return true;
+}
+
+bool venc_dev::venc_get_seq_hdr(void *buffer,
+ unsigned buffer_size, unsigned *header_len)
+{
+ struct venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ int i = 0;
+ DEBUG_PRINT_HIGH("venc_dev::venc_get_seq_hdr");
+ venc_seqheader seq_in, seq_out;
+ seq_in.hdrlen = 0;
+ seq_in.bufsize = buffer_size;
+ seq_in.hdrbufptr = (unsigned char*)buffer;
+
+ if (seq_in.hdrbufptr == NULL) {
+ DEBUG_PRINT_ERROR("ERROR: malloc for sequence header failed");
+ return false;
+ }
+
+ DEBUG_PRINT_LOW("seq_in: buf=%x, sz=%d, hdrlen=%d", seq_in.hdrbufptr,
+ seq_in.bufsize, seq_in.hdrlen);
+
+ ioctl_msg.in = (void*)&seq_in;
+ ioctl_msg.out = (void*)&seq_out;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_GET_SEQUENCE_HDR,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for getting sequence header failed");
+ return false;
+ }
+
+ if (seq_out.hdrlen == 0) {
+ DEBUG_PRINT_ERROR("ERROR: Seq header returned zero length header");
+ DEBUG_PRINT_ERROR("seq_out: buf=%x, sz=%d, hdrlen=%d", seq_out.hdrbufptr,
+ seq_out.bufsize, seq_out.hdrlen);
+ return false;
+ }
+
+ *header_len = seq_out.hdrlen;
+ DEBUG_PRINT_LOW("seq_out: buf=%x, sz=%d, hdrlen=%d", seq_out.hdrbufptr,
+ seq_out.bufsize, seq_out.hdrlen);
+
+ return true;
+}
+
+bool venc_dev::venc_get_capability_ltrcount(unsigned long *min,
+ unsigned long *max, unsigned long *step_size)
+{
+ struct venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ venc_range cap_ltr_count;
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = (void*)&cap_ltr_count;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_GET_CAPABILITY_LTRCOUNT,
+ (void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Get LTR Capability failed");
+ return false;
+ } else {
+ *min = cap_ltr_count.min;
+ *max = cap_ltr_count.max;
+ *step_size = cap_ltr_count.step_size;
+ DEBUG_PRINT_HIGH("LTR Capability: min=%x, max=%d, step_size=%d",
+ *min, *max, *step_size);
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_get_buf_req(unsigned long *min_buff_count,
+ unsigned long *actual_buff_count,
+ unsigned long *buff_size,
+ unsigned long port)
+{
+ struct venc_ioctl_msg ioctl_msg = {NULL,NULL};
+
+ if (port == 0) {
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = (void*)&m_sInput_buff_property;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_GET_INPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for getting i/p buffer requirement failed");
+ return false;
+ }
+
+ *min_buff_count = m_sInput_buff_property.mincount;
+ *actual_buff_count = m_sInput_buff_property.actualcount;
+#ifdef USE_ION
+ // For ION memory allocations of the allocated buffer size
+ // must be 4k aligned, hence aligning the input buffer
+ // size to 4k.
+ m_sInput_buff_property.datasize = (m_sInput_buff_property.datasize + 4095)
+ & (~4095);
+#endif
+ *buff_size = m_sInput_buff_property.datasize;
+ } else {
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = (void*)&m_sOutput_buff_property;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_GET_OUTPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for getting o/p buffer requirement failed");
+ return false;
+ }
+
+ *min_buff_count = m_sOutput_buff_property.mincount;
+ *actual_buff_count = m_sOutput_buff_property.actualcount;
+ *buff_size = m_sOutput_buff_property.datasize;
+ }
+
+ return true;
+
+}
+
+bool venc_dev::venc_set_param(void *paramData,OMX_INDEXTYPE index )
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ DEBUG_PRINT_LOW("venc_set_param:: venc-720p");
+
+ switch (index) {
+ case OMX_IndexParamPortDefinition:
+ {
+ OMX_PARAM_PORTDEFINITIONTYPE *portDefn;
+ portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData;
+ DEBUG_PRINT_HIGH("venc_set_param: OMX_IndexParamPortDefinition");
+
+ if (portDefn->nPortIndex == PORT_INDEX_IN) {
+
+ if (!venc_set_encode_framerate(portDefn->format.video.xFramerate, 0)) {
+ return false;
+ }
+
+ if (!venc_set_color_format(portDefn->format.video.eColorFormat)) {
+ return false;
+ }
+
+ DEBUG_PRINT_LOW("Basic parameter has changed");
+ m_sVenc_cfg.input_height = portDefn->format.video.nFrameHeight;
+ m_sVenc_cfg.input_width = portDefn->format.video.nFrameWidth;
+
+ ioctl_msg.in = (void*)&m_sVenc_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_BASE_CFG,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting base config failed");
+ return false;
+ }
+
+ DEBUG_PRINT_HIGH("WxH (%dx%d), codec (%d), fps(nr/dr) (%d/%d), bitrate (%d), "
+ "color_format (%d)", m_sVenc_cfg.input_width, m_sVenc_cfg.input_height,
+ m_sVenc_cfg.codectype, m_sVenc_cfg.fps_num, m_sVenc_cfg.fps_den,
+ m_sVenc_cfg.targetbitrate, m_sVenc_cfg.inputformat);
+
+ DEBUG_PRINT_LOW("Updating the buffer count/size for the new resolution");
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = (void*)&m_sInput_buff_property;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_GET_INPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for getting i/p bufreq failed");
+ return false;
+ }
+
+ DEBUG_PRINT_HIGH("Got updated m_sInput_buff_property values: "
+ "datasize = %u, maxcount = %u, actualcnt = %u, "
+ "mincount = %u", m_sInput_buff_property.datasize,
+ m_sInput_buff_property.maxcount, m_sInput_buff_property.actualcount,
+ m_sInput_buff_property.mincount);
+
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = (void*)&m_sOutput_buff_property;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_GET_OUTPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for getting o/p bufreq failed");
+ return false;
+ }
+
+ DEBUG_PRINT_HIGH("Got updated m_sOutput_buff_property values: "
+ "datasize = %u, maxcount = %u, actualcnt = %u, "
+ "mincount = %u", m_sOutput_buff_property.datasize,
+ m_sOutput_buff_property.maxcount, m_sOutput_buff_property.actualcount,
+ m_sOutput_buff_property.mincount);
+ ioctl_msg.in = (void*)&m_sOutput_buff_property;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_SET_OUTPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting o/p bufreq failed");
+ return false;
+ }
+
+ if ((portDefn->nBufferCountActual >= m_sInput_buff_property.mincount) &&
+ (portDefn->nBufferCountActual <= m_sInput_buff_property.maxcount)) {
+ m_sInput_buff_property.actualcount = portDefn->nBufferCountActual;
+ ioctl_msg.in = (void*)&m_sInput_buff_property;
+ ioctl_msg.out = NULL;
+
+ if (ioctl(m_nDriver_fd,VEN_IOCTL_SET_INPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting i/p buffer requirements failed");
+ return false;
+ }
+ }
+
+ if (m_sInput_buff_property.datasize != portDefn->nBufferSize) {
+ DEBUG_PRINT_ERROR("WARNING: Requested i/p bufsize[%u],"
+ "Driver's updated i/p bufsize = %u", portDefn->nBufferSize,
+ m_sInput_buff_property.datasize);
+ }
+
+ m_level_set = false;
+
+ if (venc_set_profile_level(0, 0)) {
+ DEBUG_PRINT_LOW("%s(): Profile/Level setting success", __func__);
+ }
+ } else if (portDefn->nPortIndex == PORT_INDEX_OUT) {
+ if (!venc_set_target_bitrate(portDefn->format.video.nBitrate, 0)) {
+ return false;
+ }
+
+ if ( (portDefn->nBufferCountActual >= m_sOutput_buff_property.mincount)
+ &&
+ (m_sOutput_buff_property.maxcount >= portDefn->nBufferCountActual)
+ &&
+ (m_sOutput_buff_property.datasize == portDefn->nBufferSize)
+ ) {
+ m_sOutput_buff_property.actualcount = portDefn->nBufferCountActual;
+ ioctl_msg.in = (void*)&m_sOutput_buff_property;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_OUTPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: ioctl VEN_IOCTL_SET_OUTPUT_BUFFER_REQ failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Setting Output buffer requirements failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexParamPortDefinition");
+ }
+
+ break;
+ }
+ case OMX_IndexParamVideoPortFormat:
+ {
+ OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt;
+ portFmt =(OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData;
+ DEBUG_PRINT_LOW("venc_set_param: OMX_IndexParamVideoPortFormat");
+
+ if (portFmt->nPortIndex == (OMX_U32) PORT_INDEX_IN) {
+ if (!venc_set_color_format(portFmt->eColorFormat)) {
+ return false;
+ }
+ } else if (portFmt->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ if (!venc_set_encode_framerate(portFmt->xFramerate, 0)) {
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexParamVideoPortFormat");
+ }
+
+ break;
+ }
+ case OMX_IndexParamVideoBitrate:
+ {
+ OMX_VIDEO_PARAM_BITRATETYPE* pParam;
+ pParam = (OMX_VIDEO_PARAM_BITRATETYPE*)paramData;
+ DEBUG_PRINT_LOW("venc_set_param: OMX_IndexParamVideoBitrate");
+
+ if (pParam->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ if (!venc_set_target_bitrate(pParam->nTargetBitrate, 0)) {
+ DEBUG_PRINT_ERROR("ERROR: Target Bit Rate setting failed");
+ return false;
+ }
+
+ if (!venc_set_ratectrl_cfg(pParam->eControlRate)) {
+ DEBUG_PRINT_ERROR("ERROR: Rate Control setting failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexParamVideoBitrate");
+ }
+
+ break;
+ }
+ case OMX_IndexParamVideoMpeg4:
+ {
+ OMX_VIDEO_PARAM_MPEG4TYPE* pParam;
+ OMX_U32 bFrames = 0;
+
+ pParam = (OMX_VIDEO_PARAM_MPEG4TYPE*)paramData;
+ DEBUG_PRINT_LOW("venc_set_param: OMX_IndexParamVideoMpeg4");
+
+ if (pParam->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ if (!venc_set_voptiming_cfg(pParam->nTimeIncRes)) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting vop_timing failed");
+ return false;
+ }
+
+ m_profile_set = false;
+ m_level_set = false;
+
+ if (!venc_set_profile_level (pParam->eProfile, pParam->eLevel)) {
+ DEBUG_PRINT_ERROR("ERROR: Unsuccessful in updating Profile and level");
+ return false;
+ }
+
+#ifdef MAX_RES_1080P
+ else {
+ if (pParam->eProfile == OMX_VIDEO_MPEG4ProfileAdvancedSimple) {
+ if (pParam->nBFrames) {
+ DEBUG_PRINT_HIGH("INFO: Only 1 Bframe is supported");
+ bFrames = 1;
+ }
+ } else {
+ if (pParam->nBFrames) {
+ DEBUG_PRINT_ERROR("Warning: B frames not supported");
+ bFrames = 0;
+ }
+ }
+ }
+
+#endif
+
+ if (!venc_set_intra_period (pParam->nPFrames,bFrames)) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting intra period failed");
+ return false;
+ }
+
+ if (!venc_set_multislice_cfg(OMX_IndexParamVideoMpeg4,pParam->nSliceHeaderSpacing)) {
+ DEBUG_PRINT_ERROR("ERROR: Unsuccessful in updating slice_config");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexParamVideoMpeg4");
+ }
+
+ break;
+ }
+ case OMX_IndexParamVideoH263:
+ {
+ OMX_VIDEO_PARAM_H263TYPE* pParam = (OMX_VIDEO_PARAM_H263TYPE*)paramData;
+ DEBUG_PRINT_LOW("venc_set_param: OMX_IndexParamVideoH263");
+ OMX_U32 bFrames = 0;
+
+ if (pParam->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ m_profile_set = false;
+ m_level_set = false;
+
+ if (!venc_set_profile_level (pParam->eProfile, pParam->eLevel)) {
+ DEBUG_PRINT_ERROR("ERROR: Unsuccessful in updating Profile and level");
+ return false;
+ }
+
+ if (pParam->nBFrames)
+ DEBUG_PRINT_ERROR("WARNING: B frame not supported for H.263");
+
+ if (venc_set_intra_period (pParam->nPFrames, bFrames) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting intra period failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexParamVideoH263");
+ }
+
+ break;
+ }
+ case OMX_IndexParamVideoAvc:
+ {
+ DEBUG_PRINT_LOW("venc_set_param:OMX_IndexParamVideoAvc");
+ OMX_VIDEO_PARAM_AVCTYPE* pParam = (OMX_VIDEO_PARAM_AVCTYPE*)paramData;
+ OMX_U32 bFrames = 0;
+
+ if (pParam->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ DEBUG_PRINT_LOW("pParam->eProfile :%d ,pParam->eLevel %d",
+ pParam->eProfile,pParam->eLevel);
+
+ m_profile_set = false;
+ m_level_set = false;
+
+ if (!venc_set_profile_level (pParam->eProfile,pParam->eLevel)) {
+ DEBUG_PRINT_ERROR("ERROR: Unsuccessful in updating Profile and level %d, %d",
+ pParam->eProfile, pParam->eLevel);
+ return false;
+ }
+
+#ifdef MAX_RES_1080P
+ else {
+ if (pParam->eProfile != OMX_VIDEO_AVCProfileBaseline) {
+ if (pParam->nBFrames) {
+ DEBUG_PRINT_HIGH("INFO: Only 1 Bframe is supported");
+ bFrames = 1;
+ }
+ } else {
+ if (pParam->nBFrames) {
+ DEBUG_PRINT_ERROR("Warning: B frames not supported");
+ bFrames = 0;
+ }
+ }
+ }
+
+#endif
+
+ if (!venc_set_intra_period (pParam->nPFrames, bFrames)) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting intra period failed");
+ return false;
+ }
+
+ if (!venc_set_entropy_config (pParam->bEntropyCodingCABAC, pParam->nCabacInitIdc)) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting Entropy failed");
+ return false;
+ }
+
+ if (!venc_set_inloop_filter (pParam->eLoopFilterMode)) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting Inloop filter failed");
+ return false;
+ }
+
+ if (!venc_set_multislice_cfg(OMX_IndexParamVideoAvc, pParam->nSliceHeaderSpacing)) {
+ DEBUG_PRINT_ERROR("WARNING: Unsuccessful in updating slice_config");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexParamVideoAvc");
+ }
+
+ //TBD, lot of other variables to be updated, yet to decide
+ break;
+ }
+ case OMX_IndexParamVideoIntraRefresh:
+ {
+ DEBUG_PRINT_LOW("venc_set_param:OMX_IndexParamVideoIntraRefresh");
+ OMX_VIDEO_PARAM_INTRAREFRESHTYPE *intra_refresh =
+ (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)paramData;
+
+ if (intra_refresh->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ if (venc_set_intra_refresh(intra_refresh->eRefreshMode, intra_refresh->nCirMBs) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Setting Intra refresh failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexParamVideoIntraRefresh");
+ }
+
+ break;
+ }
+ case OMX_IndexParamVideoErrorCorrection:
+ {
+ DEBUG_PRINT_LOW("venc_set_param:OMX_IndexParamVideoErrorCorrection");
+ OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *error_resilience =
+ (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)paramData;
+
+ if (error_resilience->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ if (venc_set_error_resilience(error_resilience) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Setting Intra refresh failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexParamVideoErrorCorrection");
+ }
+
+ break;
+ }
+ case OMX_IndexParamVideoProfileLevelCurrent:
+ {
+ DEBUG_PRINT_LOW("venc_set_param:OMX_IndexParamVideoProfileLevelCurrent");
+ OMX_VIDEO_PARAM_PROFILELEVELTYPE *profile_level =
+ (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)paramData;
+
+ if (profile_level->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ m_profile_set = false;
+ m_level_set = false;
+
+ if (!venc_set_profile_level (profile_level->eProfile,
+ profile_level->eLevel)) {
+ DEBUG_PRINT_ERROR("WARNING: Unsuccessful in updating Profile and level");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexParamVideoProfileLevelCurrent");
+ }
+
+ break;
+ }
+ case OMX_IndexParamVideoQuantization:
+ {
+ DEBUG_PRINT_LOW("venc_set_param:OMX_IndexParamVideoQuantization");
+ OMX_VIDEO_PARAM_QUANTIZATIONTYPE *session_qp =
+ (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)paramData;
+
+ if (session_qp->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ if (venc_set_session_qp (session_qp->nQpI,
+ session_qp->nQpP) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Setting Session QP failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexParamVideoQuantization");
+ }
+
+ break;
+ }
+
+ case OMX_QcomIndexParamVideoQPRange:
+ {
+ DEBUG_PRINT_LOW("venc_set_param:OMX_QcomIndexParamVideoQPRange");
+ OMX_QCOM_VIDEO_PARAM_QPRANGETYPE *qp_range =
+ (OMX_QCOM_VIDEO_PARAM_QPRANGETYPE *)paramData;
+
+ if (qp_range->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ if (venc_set_qp_range (qp_range->minQP,
+ qp_range->maxQP) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Setting QP Range failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_QcomIndexParamVideoQPRange");
+ }
+
+ break;
+ }
+
+ case OMX_ExtraDataVideoEncoderSliceInfo:
+ {
+ DEBUG_PRINT_LOW("venc_set_param: OMX_ExtraDataVideoEncoderSliceInfo");
+ OMX_U32 extra_data = *(OMX_U32 *)paramData;
+
+ if (venc_set_extradata(extra_data) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Setting "
+ "OMX_ExtraDataVideoEncoderSliceInfo failed");
+ return false;
+ }
+
+ break;
+ }
+ case OMX_ExtraDataVideoLTRInfo:
+ {
+ DEBUG_PRINT_LOW("venc_set_param: OMX_ExtraDataVideoLTRInfo");
+ OMX_U32 extra_data = *(OMX_U32 *)paramData;
+
+ if (venc_set_extradata(extra_data) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Setting "
+ "OMX_ExtraDataVideoLTRInfo failed");
+ return false;
+ }
+
+ break;
+ }
+ case OMX_QcomIndexEnableSliceDeliveryMode:
+ {
+ QOMX_EXTNINDEX_PARAMTYPE* pParam =
+ (QOMX_EXTNINDEX_PARAMTYPE*)paramData;
+
+ if (pParam->nPortIndex == PORT_INDEX_OUT) {
+ if (venc_set_slice_delivery_mode(pParam->bEnable) == false) {
+ DEBUG_PRINT_ERROR("Setting slice delivery mode failed");
+ return OMX_ErrorUnsupportedSetting;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("OMX_QcomIndexEnableSliceDeliveryMode "
+ "called on wrong port(%d)", pParam->nPortIndex);
+ return OMX_ErrorBadPortIndex;
+ }
+
+ break;
+ }
+ case OMX_QcomIndexEnableH263PlusPType:
+ {
+ QOMX_EXTNINDEX_PARAMTYPE* pParam =
+ (QOMX_EXTNINDEX_PARAMTYPE*)paramData;
+ DEBUG_PRINT_LOW("OMX_QcomIndexEnableH263PlusPType");
+
+ if (pParam->nPortIndex == PORT_INDEX_OUT) {
+ if (venc_set_plusptype(pParam->bEnable) == false) {
+ DEBUG_PRINT_ERROR("Setting PlusPType failed for H263");
+ return OMX_ErrorUnsupportedSetting;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("OMX_QcomIndexEnableH263PlusPType "
+ "called on wrong port(%d)", pParam->nPortIndex);
+ return OMX_ErrorBadPortIndex;
+ }
+
+ break;
+ }
+ case QOMX_IndexParamVideoLTRMode:
+ {
+ QOMX_VIDEO_PARAM_LTRMODE_TYPE* pParam =
+ (QOMX_VIDEO_PARAM_LTRMODE_TYPE*)paramData;
+
+ if (pParam->nPortIndex == PORT_INDEX_OUT) {
+ if (!venc_set_ltrmode(pParam->eLTRMode)) {
+ DEBUG_PRINT_ERROR("Setting ltr mode failed");
+ return OMX_ErrorUnsupportedSetting;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("QOMX_IndexParamVideoLTRMode "
+ "called on wrong port(%d)", pParam->nPortIndex);
+ return OMX_ErrorBadPortIndex;
+ }
+
+ break;
+ }
+ case QOMX_IndexParamVideoLTRCount:
+ {
+ QOMX_VIDEO_PARAM_LTRCOUNT_TYPE* pParam =
+ (QOMX_VIDEO_PARAM_LTRCOUNT_TYPE*)paramData;
+
+ if (pParam->nPortIndex == PORT_INDEX_OUT) {
+ if (!venc_set_ltrcount(pParam->nCount)) {
+ DEBUG_PRINT_ERROR("Setting ltr count failed");
+ return OMX_ErrorUnsupportedSetting;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("QOMX_IndexParamVideoLTRCount "
+ "called on wrong port(%d)", pParam->nPortIndex);
+ return OMX_ErrorBadPortIndex;
+ }
+
+ break;
+ }
+ case OMX_IndexParamVideoSliceFMO:
+ default:
+ DEBUG_PRINT_ERROR("venc_set_param: Unsupported index 0x%x", index);
+ break;
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_config(void *configData, OMX_INDEXTYPE index)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ DEBUG_PRINT_LOW("Inside venc_set_config");
+
+ switch (index) {
+ case OMX_IndexConfigVideoBitrate:
+ {
+ OMX_VIDEO_CONFIG_BITRATETYPE *bit_rate = (OMX_VIDEO_CONFIG_BITRATETYPE *)
+ configData;
+
+ if (m_max_allowed_bitrate_check &&
+ !venc_max_allowed_bitrate_check(bit_rate->nEncodeBitrate)) {
+ DEBUG_PRINT_ERROR("Max Allowed Bitrate Check failed");
+ return false;
+ }
+
+ DEBUG_PRINT_LOW("venc_set_config: OMX_IndexConfigVideoBitrate");
+
+ if (bit_rate->nPortIndex == (OMX_U32)PORT_INDEX_OUT) {
+ if (venc_set_target_bitrate(bit_rate->nEncodeBitrate, 1) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Setting Target Bit rate failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexConfigVideoBitrate");
+ }
+
+ break;
+ }
+ case OMX_IndexConfigVideoFramerate:
+ {
+ OMX_CONFIG_FRAMERATETYPE *frame_rate = (OMX_CONFIG_FRAMERATETYPE *)
+ configData;
+ DEBUG_PRINT_LOW("venc_set_config: OMX_IndexConfigVideoFramerate");
+
+ if (frame_rate->nPortIndex == (OMX_U32)PORT_INDEX_OUT) {
+ if (venc_set_encode_framerate(frame_rate->xEncodeFramerate, 1) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Setting Encode Framerate failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexConfigVideoFramerate");
+ }
+
+ break;
+ }
+ case QOMX_IndexConfigVideoIntraperiod:
+ {
+ DEBUG_PRINT_LOW("venc_set_param:QOMX_IndexConfigVideoIntraperiod");
+ QOMX_VIDEO_INTRAPERIODTYPE *intraperiod =
+ (QOMX_VIDEO_INTRAPERIODTYPE *)configData;
+
+ if (intraperiod->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+ if (venc_set_intra_period(intraperiod->nPFrames, intraperiod->nBFrames) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting intra period failed");
+ return false;
+ }
+ }
+
+ break;
+ }
+ case OMX_IndexConfigVideoIntraVOPRefresh:
+ {
+ OMX_CONFIG_INTRAREFRESHVOPTYPE *intra_vop_refresh = (OMX_CONFIG_INTRAREFRESHVOPTYPE *)
+ configData;
+ DEBUG_PRINT_LOW("venc_set_config: OMX_IndexConfigVideoIntraVOPRefresh");
+
+ if (intra_vop_refresh->nPortIndex == (OMX_U32)PORT_INDEX_OUT) {
+ if (venc_set_intra_vop_refresh(intra_vop_refresh->IntraRefreshVOP) == false) {
+ DEBUG_PRINT_ERROR("ERROR: Setting Encode Framerate failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_IndexConfigVideoFramerate");
+ }
+
+ break;
+ }
+ case OMX_IndexConfigCommonRotate:
+ {
+ OMX_CONFIG_ROTATIONTYPE *config_rotation =
+ reinterpret_cast<OMX_CONFIG_ROTATIONTYPE*>(configData);
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ OMX_U32 nFrameWidth;
+
+ DEBUG_PRINT_HIGH("venc_set_config: updating the new Dims");
+ nFrameWidth = m_sVenc_cfg.input_width;
+ m_sVenc_cfg.input_width = m_sVenc_cfg.input_height;
+ m_sVenc_cfg.input_height = nFrameWidth;
+ ioctl_msg.in = (void*)&m_sVenc_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_BASE_CFG,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Dimension Change for Rotation failed");
+ return false;
+ }
+
+ break;
+ }
+ case QOMX_IndexConfigVideoLTRPeriod:
+ {
+ QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE* pParam =
+ (QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE*)configData;
+
+ if (pParam->nPortIndex == PORT_INDEX_OUT) {
+ if (!venc_set_ltrperiod(pParam->nFrames)) {
+ DEBUG_PRINT_ERROR("Setting ltr period failed");
+ return OMX_ErrorUnsupportedSetting;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("QOMX_IndexConfigVideoLTRPeriod "
+ "called on wrong port(%d)", pParam->nPortIndex);
+ return OMX_ErrorBadPortIndex;
+ }
+
+ break;
+ }
+ case QOMX_IndexConfigVideoLTRUse:
+ {
+ QOMX_VIDEO_CONFIG_LTRUSE_TYPE* pParam =
+ (QOMX_VIDEO_CONFIG_LTRUSE_TYPE*)configData;
+
+ if (pParam->nPortIndex == PORT_INDEX_OUT) {
+ if (!venc_set_ltruse(pParam->nID, pParam->nFrames)) {
+ DEBUG_PRINT_ERROR("Setting ltr use failed");
+ return OMX_ErrorUnsupportedSetting;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("QOMX_IndexConfigVideoLTRUse "
+ "called on wrong port(%d)", pParam->nPortIndex);
+ return OMX_ErrorBadPortIndex;
+ }
+
+ break;
+ }
+ default:
+ DEBUG_PRINT_ERROR("venc_set_config: Unsupported index = 0x%x", index);
+ break;
+ }
+
+ return true;
+}
+
+unsigned venc_dev::venc_stop( void)
+{
+#ifdef MAX_RES_1080P
+ pmem_free();
+#endif
+ return ioctl(m_nDriver_fd,VEN_IOCTL_CMD_STOP,NULL);
+}
+
+unsigned venc_dev::venc_pause(void)
+{
+ return ioctl(m_nDriver_fd,VEN_IOCTL_CMD_PAUSE,NULL);
+}
+
+unsigned venc_dev::venc_resume(void)
+{
+ return ioctl(m_nDriver_fd,VEN_IOCTL_CMD_RESUME,NULL) ;
+}
+
+unsigned venc_dev::venc_start_done(void)
+{
+ return 0;
+}
+
+unsigned venc_dev::venc_set_message_thread_id(pthread_t)
+{
+ return 0;
+}
+
+unsigned venc_dev::venc_start(void)
+{
+ DEBUG_PRINT_HIGH("%s(): Check Profile/Level set in driver before start",
+ __func__);
+
+ if (!venc_set_profile_level(0, 0)) {
+ DEBUG_PRINT_ERROR("ERROR: %s(): Driver Profile/Level is NOT SET",
+ __func__);
+ } else {
+ DEBUG_PRINT_HIGH("%s(): Driver Profile[%lu]/Level[%lu] successfully SET",
+ __func__, codec_profile.profile, profile_level.level);
+ }
+
+ if (m_max_allowed_bitrate_check &&
+ !venc_max_allowed_bitrate_check(bitrate.target_bitrate)) {
+ DEBUG_PRINT_ERROR("Maximum Allowed Bitrate Check failed");
+ return -1;
+ }
+
+ venc_config_print();
+
+#ifdef MAX_RES_1080P
+
+ if ((codec_profile.profile == VEN_PROFILE_MPEG4_SP) ||
+ (codec_profile.profile == VEN_PROFILE_H264_BASELINE) ||
+ (codec_profile.profile == VEN_PROFILE_H263_BASELINE))
+ recon_buffers_count = MAX_RECON_BUFFERS - 2;
+ else
+ recon_buffers_count = MAX_RECON_BUFFERS;
+
+ if (ltrmode.ltr_mode == (unsigned long)QOMX_VIDEO_LTRMode_Auto) {
+ recon_buffers_count = MAX_RECON_BUFFERS;
+ DEBUG_PRINT_HIGH("ltr mode enabled, so set recon buffers "
+ "count to %d", recon_buffers_count);
+ }
+
+ if (!venc_allocate_recon_buffers())
+ return ioctl(m_nDriver_fd, VEN_IOCTL_CMD_START, NULL);
+ else {
+ DEBUG_PRINT_ERROR("Failed in creating Recon buffers");
+ return -1;
+ }
+
+#else
+ return ioctl(m_nDriver_fd, VEN_IOCTL_CMD_START, NULL);
+#endif
+}
+
+#ifdef MAX_RES_1080P
+OMX_U32 venc_dev::venc_allocate_recon_buffers()
+{
+ OMX_U32 yuv_size;
+ struct venc_ioctl_msg ioctl_msg;
+ struct venc_recon_buff_size recon_buff_size;
+
+ recon_buff_size.width = ((m_sVenc_cfg.input_width + 15) / 16) * 16;
+ recon_buff_size.height = ((m_sVenc_cfg.input_height + 15) / 16 ) * 16;
+
+ DEBUG_PRINT_LOW("Width %d, Height %d, w_round %d, h_round %d", m_sVenc_cfg.input_width,
+ m_sVenc_cfg.input_height, recon_buff_size.width, recon_buff_size.height);
+
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = (void*)&recon_buff_size;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_GET_RECON_BUFFER_SIZE, (void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("VEN_IOCTL_GET_RECON_BUFFER_SIZE Failed for width: %d, Height %d" ,
+ recon_buff_size.width, recon_buff_size.height);
+ return OMX_ErrorInsufficientResources;
+ }
+
+ DEBUG_PRINT_HIGH("Width %d, Height %d, w_round %d, h_round %d, yuv_size %d alignment %d count %d",
+ m_sVenc_cfg.input_width, m_sVenc_cfg.input_height, recon_buff_size.width,
+ recon_buff_size.height, recon_buff_size.size, recon_buff_size.alignment,
+ recon_buffers_count);
+
+ for (int i = 0; i < recon_buffers_count; i++) {
+ if (pmem_allocate(recon_buff_size.size, recon_buff_size.alignment,i)) {
+ DEBUG_PRINT_ERROR("Error returned in allocating recon buffers");
+ return -1;
+ }
+ }
+
+ return 0;
+}
+OMX_U32 venc_dev::pmem_allocate(OMX_U32 size, OMX_U32 alignment, OMX_U32 count)
+{
+ OMX_U32 pmem_fd = -1;
+ OMX_U32 width, height;
+ void *buf_addr = NULL;
+ struct venc_ioctl_msg ioctl_msg;
+ struct venc_recon_addr recon_addr;
+ int rc = 0;
+
+#ifdef USE_ION
+ recon_buff[count].ion_device_fd = open (MEM_DEVICE,O_RDONLY);
+
+ if (recon_buff[count].ion_device_fd < 0) {
+ DEBUG_PRINT_ERROR("ERROR: ION Device open() Failed");
+ return -1;
+ }
+
+ recon_buff[count].alloc_data.len = size;
+#ifdef MAX_RES_720P
+ recon_buff[count].alloc_data.heap_id_mask = ION_HEAP(MEM_HEAP_ID);
+#else
+ recon_buff[count].alloc_data.heap_id_mask = (ION_HEAP(MEM_HEAP_ID) |
+ ION_HEAP(ION_IOMMU_HEAP_ID));
+#endif
+ recon_buff[count].alloc_data.flags = ION_FLAG_CACHED;
+ recon_buff[count].alloc_data.align = clip2(alignment);
+
+ if (recon_buff[count].alloc_data.align != 8192)
+ recon_buff[count].alloc_data.align = 8192;
+
+ rc = ioctl(recon_buff[count].ion_device_fd,ION_IOC_ALLOC,&recon_buff[count].alloc_data);
+
+ if (rc || !recon_buff[count].alloc_data.handle) {
+ DEBUG_PRINT_ERROR("ION ALLOC memory failed ");
+ recon_buff[count].alloc_data.handle=NULL;
+ return -1;
+ }
+
+ recon_buff[count].ion_alloc_fd.handle = recon_buff[count].alloc_data.handle;
+ rc = ioctl(recon_buff[count].ion_device_fd,ION_IOC_MAP,&recon_buff[count].ion_alloc_fd);
+
+ if (rc) {
+ DEBUG_PRINT_ERROR("ION MAP failed ");
+ recon_buff[count].ion_alloc_fd.fd =-1;
+ recon_buff[count].ion_alloc_fd.fd =-1;
+ return -1;
+ }
+
+ pmem_fd = recon_buff[count].ion_alloc_fd.fd;
+#else
+ struct pmem_allocation allocation;
+ pmem_fd = open(MEM_DEVICE, O_RDWR);
+
+ if ((int)(pmem_fd) < 0) {
+ DEBUG_PRINT_ERROR("Failed to get an pmem handle");
+ return -1;
+ }
+
+ allocation.size = size;
+ allocation.align = clip2(alignment);
+
+ if (allocation.align != 8192)
+ allocation.align = 8192;
+
+ if (ioctl(pmem_fd, PMEM_ALLOCATE_ALIGNED, &allocation) < 0) {
+ DEBUG_PRINT_ERROR("Aligment(%u) failed with pmem driver Sz(%lu)",
+ allocation.align, allocation.size);
+ return -1;
+ }
+
+#endif
+ buf_addr = mmap(NULL, size,
+ PROT_READ | PROT_WRITE,
+ MAP_SHARED, pmem_fd, 0);
+
+ if (buf_addr == (void*) MAP_FAILED) {
+ close(pmem_fd);
+ pmem_fd = -1;
+ DEBUG_PRINT_ERROR("Error returned in allocating recon buffers buf_addr: %p",buf_addr);
+#ifdef USE_ION
+
+ if (ioctl(recon_buff[count].ion_device_fd,ION_IOC_FREE,
+ &recon_buff[count].alloc_data.handle)) {
+ DEBUG_PRINT_LOW("ion recon buffer free failed");
+ }
+
+ recon_buff[count].alloc_data.handle = NULL;
+ recon_buff[count].ion_alloc_fd.fd =-1;
+ close(recon_buff[count].ion_device_fd);
+ recon_buff[count].ion_device_fd =-1;
+#endif
+ return -1;
+ }
+
+ DEBUG_PRINT_HIGH("Allocated virt:%p, FD: %d of size %d", buf_addr, pmem_fd, size);
+
+ recon_addr.buffer_size = size;
+ recon_addr.pmem_fd = pmem_fd;
+ recon_addr.offset = 0;
+ recon_addr.pbuffer = (unsigned char *)buf_addr;
+
+ ioctl_msg.in = (void*)&recon_addr;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_RECON_BUFFER, (void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("Failed to set the Recon_buffers");
+ return -1;
+ }
+
+ recon_buff[count].virtual_address = (unsigned char *) buf_addr;
+ recon_buff[count].size = size;
+ recon_buff[count].offset = 0;
+ recon_buff[count].pmem_fd = pmem_fd;
+
+ DEBUG_PRINT_ERROR("Allocated virt:%p, FD: %d of size %d at index: %d", recon_buff[count].virtual_address,
+ recon_buff[count].pmem_fd, recon_buff[count].size, count);
+ return 0;
+}
+
+OMX_U32 venc_dev::pmem_free()
+{
+ int cnt = 0;
+ struct venc_ioctl_msg ioctl_msg;
+ struct venc_recon_addr recon_addr;
+
+ for (cnt = 0; cnt < recon_buffers_count; cnt++) {
+ if (recon_buff[cnt].pmem_fd) {
+ recon_addr.pbuffer = recon_buff[cnt].virtual_address;
+ recon_addr.offset = recon_buff[cnt].offset;
+ recon_addr.pmem_fd = recon_buff[cnt].pmem_fd;
+ recon_addr.buffer_size = recon_buff[cnt].size;
+ ioctl_msg.in = (void*)&recon_addr;
+ ioctl_msg.out = NULL;
+
+ if (ioctl(m_nDriver_fd, VEN_IOCTL_FREE_RECON_BUFFER ,&ioctl_msg) < 0)
+ DEBUG_PRINT_ERROR("VEN_IOCTL_FREE_RECON_BUFFER failed");
+
+ munmap(recon_buff[cnt].virtual_address, recon_buff[cnt].size);
+ close(recon_buff[cnt].pmem_fd);
+#ifdef USE_ION
+
+ if (ioctl(recon_buff[cnt].ion_device_fd,ION_IOC_FREE,
+ &recon_buff[cnt].alloc_data.handle)) {
+ DEBUG_PRINT_LOW("ion recon buffer free failed");
+ }
+
+ recon_buff[cnt].alloc_data.handle = NULL;
+ recon_buff[cnt].ion_alloc_fd.fd =-1;
+ close(recon_buff[cnt].ion_device_fd);
+ recon_buff[cnt].ion_device_fd =-1;
+#endif
+ DEBUG_PRINT_LOW("cleaning Index %d of size %d",cnt,recon_buff[cnt].size);
+ recon_buff[cnt].pmem_fd = -1;
+ recon_buff[cnt].virtual_address = NULL;
+ recon_buff[cnt].offset = 0;
+ recon_buff[cnt].alignment = 0;
+ recon_buff[cnt].size = 0;
+ }
+ }
+
+ return 0;
+}
+#endif
+
+void venc_dev::venc_config_print()
+{
+
+ DEBUG_PRINT_HIGH("ENC_CONFIG: Codec: %d, Profile %d, level : %d",
+ m_sVenc_cfg.codectype, codec_profile.profile, profile_level.level);
+
+ DEBUG_PRINT_HIGH("ENC_CONFIG: Width: %d, Height:%d, Fps: %d",
+ m_sVenc_cfg.input_width, m_sVenc_cfg.input_height,
+ m_sVenc_cfg.fps_num/m_sVenc_cfg.fps_den);
+
+ DEBUG_PRINT_HIGH("ENC_CONFIG: Bitrate: %d, RC: %d, I-Period: %d",
+ bitrate.target_bitrate, rate_ctrl.rcmode, intra_period.num_pframes);
+
+ DEBUG_PRINT_HIGH("ENC_CONFIG: qpI: %d, qpP: %d, qpb: 0",
+ session_qp.iframeqp, session_qp.pframqp);
+
+ DEBUG_PRINT_HIGH("ENC_CONFIG: minQP: %d, maxQP: %d",
+ qp_range.minqp, qp_range.maxqp);
+
+ DEBUG_PRINT_HIGH("ENC_CONFIG: VOP_Resolution: %d, Slice-Mode: %d, Slize_Size: %d",
+ voptimecfg.voptime_resolution, multislice.mslice_mode,
+ multislice.mslice_size);
+
+ DEBUG_PRINT_HIGH("ENC_CONFIG: EntropyMode: %d, CabacModel: %d",
+ entropy.longentropysel, entropy.cabacmodel);
+
+ DEBUG_PRINT_HIGH("ENC_CONFIG: DB-Mode: %d, alpha: %d, Beta: %d",
+ dbkfilter.db_mode, dbkfilter.slicealpha_offset,
+ dbkfilter.slicebeta_offset);
+
+ DEBUG_PRINT_HIGH("ENC_CONFIG: IntraMB/Frame: %d, HEC: %d",
+ intra_refresh.mbcount, hec.header_extension);
+}
+
+unsigned venc_dev::venc_flush( unsigned port)
+{
+ struct venc_ioctl_msg ioctl_msg;
+ struct venc_bufferflush buffer_index;
+
+ if (port == PORT_INDEX_IN) {
+ DEBUG_PRINT_HIGH("Calling Input Flush");
+ buffer_index.flush_mode = VEN_FLUSH_INPUT;
+ ioctl_msg.in = (void*)&buffer_index;
+ ioctl_msg.out = NULL;
+
+ return ioctl (m_nDriver_fd,VEN_IOCTL_CMD_FLUSH,(void*)&ioctl_msg);
+ } else if (port == PORT_INDEX_OUT) {
+ DEBUG_PRINT_HIGH("Calling Output Flush");
+ buffer_index.flush_mode = VEN_FLUSH_OUTPUT;
+ ioctl_msg.in = (void*)&buffer_index;
+ ioctl_msg.out = NULL;
+ return ioctl (m_nDriver_fd,VEN_IOCTL_CMD_FLUSH,(void*)&ioctl_msg);
+ } else {
+ return -1;
+ }
+}
+
+//allocating I/P memory from pmem and register with the device
+
+
+bool venc_dev::venc_use_buf(void *buf_addr, unsigned port,unsigned)
+{
+ struct venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct pmem *pmem_tmp;
+ struct venc_bufferpayload dev_buffer = {0};
+ struct venc_allocatorproperty buff_alloc_property = {0};
+
+ pmem_tmp = (struct pmem *)buf_addr;
+
+ DEBUG_PRINT_LOW("venc_use_buf:: pmem_tmp = %p", pmem_tmp);
+
+ if (port == PORT_INDEX_IN) {
+ dev_buffer.pbuffer = (OMX_U8 *)pmem_tmp->buffer;
+ dev_buffer.fd = pmem_tmp->fd;
+ dev_buffer.maped_size = pmem_tmp->size;
+ dev_buffer.sz = pmem_tmp->size;
+ dev_buffer.offset = pmem_tmp->offset;
+
+ if ((m_sVenc_cfg.input_height %16 !=0) || (m_sVenc_cfg.input_width%16 != 0)) {
+ unsigned long ht = m_sVenc_cfg.input_height;
+ unsigned long wd = m_sVenc_cfg.input_width;
+ unsigned int luma_size, luma_size_2k;
+
+ ht = (ht + 15) & ~15;
+ wd = (wd + 15) & ~15;
+
+ luma_size = ht * wd;
+ luma_size_2k = (luma_size + 2047) & ~2047;
+
+ dev_buffer.sz = luma_size_2k + ((luma_size/2 + 2047) & ~2047);
+#ifdef USE_ION
+ ioctl_msg.in = NULL;
+ ioctl_msg.out = (void*)&buff_alloc_property;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_GET_INPUT_BUFFER_REQ,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: venc_use_buf:get input buffer failed ");
+ return false;
+ }
+
+ if (buff_alloc_property.alignment < 4096) {
+ dev_buffer.sz = ((dev_buffer.sz + 4095) & ~4095);
+ } else {
+ dev_buffer.sz = ((dev_buffer.sz + (buff_alloc_property.alignment - 1)) &
+ ~(buff_alloc_property.alignment - 1));
+ }
+
+#endif
+ dev_buffer.maped_size = dev_buffer.sz;
+ }
+
+ ioctl_msg.in = (void*)&dev_buffer;
+ ioctl_msg.out = NULL;
+
+ DEBUG_PRINT_LOW("venc_use_buf:pbuffer = %x,fd = %x, offset = %d, maped_size = %d", \
+ dev_buffer.pbuffer, \
+ dev_buffer.fd, \
+ dev_buffer.offset, \
+ dev_buffer.maped_size);
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_INPUT_BUFFER,&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: venc_use_buf:set input buffer failed ");
+ return false;
+ }
+ } else if (port == PORT_INDEX_OUT) {
+ dev_buffer.pbuffer = (OMX_U8 *)pmem_tmp->buffer;
+ dev_buffer.fd = pmem_tmp->fd;
+ dev_buffer.sz = pmem_tmp->size;
+ dev_buffer.maped_size = pmem_tmp->size;
+ dev_buffer.offset = pmem_tmp->offset;
+ ioctl_msg.in = (void*)&dev_buffer;
+ ioctl_msg.out = NULL;
+
+ DEBUG_PRINT_LOW("venc_use_buf:pbuffer = %x,fd = %x, offset = %d, maped_size = %d", \
+ dev_buffer.pbuffer, \
+ dev_buffer.fd, \
+ dev_buffer.offset, \
+ dev_buffer.maped_size);
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_OUTPUT_BUFFER,&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: venc_use_buf:set output buffer failed ");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: venc_use_buf:Invalid Port Index ");
+ return false;
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_free_buf(void *buf_addr, unsigned port)
+{
+ struct venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct pmem *pmem_tmp;
+ struct venc_bufferpayload dev_buffer = {0};
+
+ pmem_tmp = (struct pmem *)buf_addr;
+
+ DEBUG_PRINT_LOW("venc_use_buf:: pmem_tmp = %p", pmem_tmp);
+
+ if (port == PORT_INDEX_IN) {
+ dev_buffer.pbuffer = (OMX_U8 *)pmem_tmp->buffer;
+ dev_buffer.fd = pmem_tmp->fd;
+ dev_buffer.maped_size = pmem_tmp->size;
+ dev_buffer.sz = pmem_tmp->size;
+ dev_buffer.offset = pmem_tmp->offset;
+ ioctl_msg.in = (void*)&dev_buffer;
+ ioctl_msg.out = NULL;
+
+ DEBUG_PRINT_LOW("venc_free_buf:pbuffer = %x,fd = %x, offset = %d, maped_size = %d", \
+ dev_buffer.pbuffer, \
+ dev_buffer.fd, \
+ dev_buffer.offset, \
+ dev_buffer.maped_size);
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_CMD_FREE_INPUT_BUFFER,&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: venc_free_buf: free input buffer failed ");
+ return false;
+ }
+ } else if (port == PORT_INDEX_OUT) {
+ dev_buffer.pbuffer = (OMX_U8 *)pmem_tmp->buffer;
+ dev_buffer.fd = pmem_tmp->fd;
+ dev_buffer.sz = pmem_tmp->size;
+ dev_buffer.maped_size = pmem_tmp->size;
+ dev_buffer.offset = pmem_tmp->offset;
+ ioctl_msg.in = (void*)&dev_buffer;
+ ioctl_msg.out = NULL;
+
+ DEBUG_PRINT_LOW("venc_free_buf:pbuffer = %x,fd = %x, offset = %d, maped_size = %d", \
+ dev_buffer.pbuffer, \
+ dev_buffer.fd, \
+ dev_buffer.offset, \
+ dev_buffer.maped_size);
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_CMD_FREE_OUTPUT_BUFFER,&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: venc_free_buf: free output buffer failed ");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: venc_free_buf:Invalid Port Index ");
+ return false;
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_color_align(OMX_BUFFERHEADERTYPE *buffer,
+ OMX_U32 width, OMX_U32 height)
+{
+ DEBUG_PRINT_ERROR("%s not implemented!", __func__);
+ return OMX_ErrorUnsupportedSetting;
+}
+
+bool venc_dev::venc_empty_buf(void *buffer, void *pmem_data_buf,unsigned,unsigned)
+{
+ struct venc_buffer frameinfo;
+ struct pmem *temp_buffer;
+ struct venc_ioctl_msg ioctl_msg;
+ struct OMX_BUFFERHEADERTYPE *bufhdr;
+
+ if (buffer == NULL) {
+ DEBUG_PRINT_ERROR("ERROR: venc_etb: buffer is NULL");
+ return false;
+ }
+
+ bufhdr = (OMX_BUFFERHEADERTYPE *)buffer;
+
+ DEBUG_PRINT_LOW("Input buffer length %d",bufhdr->nFilledLen);
+
+ if (pmem_data_buf) {
+ DEBUG_PRINT_LOW("Internal PMEM addr for i/p Heap UseBuf: %p", pmem_data_buf);
+ frameinfo.ptrbuffer = (OMX_U8 *)pmem_data_buf;
+ } else {
+ DEBUG_PRINT_LOW("Shared PMEM addr for i/p PMEM UseBuf/AllocateBuf: %p", bufhdr->pBuffer);
+ frameinfo.ptrbuffer = (OMX_U8 *)bufhdr->pBuffer;
+ }
+
+ frameinfo.clientdata = (void *) buffer;
+ frameinfo.sz = bufhdr->nFilledLen;
+ frameinfo.len = bufhdr->nFilledLen;
+ frameinfo.flags = bufhdr->nFlags;
+ frameinfo.offset = bufhdr->nOffset;
+ frameinfo.timestamp = bufhdr->nTimeStamp;
+ DEBUG_PRINT_LOW("i/p TS = %u", (OMX_U32)frameinfo.timestamp);
+ ioctl_msg.in = &frameinfo;
+ ioctl_msg.out = NULL;
+
+ DEBUG_PRINT_LOW("DBG: i/p frameinfo: bufhdr->pBuffer = %p, ptrbuffer = %p, offset = %u, len = %u",
+ bufhdr->pBuffer, frameinfo.ptrbuffer, frameinfo.offset, frameinfo.len);
+
+ if (ioctl(m_nDriver_fd,VEN_IOCTL_CMD_ENCODE_FRAME,&ioctl_msg) < 0) {
+ /*Generate an async error and move to invalid state*/
+ return false;
+ }
+
+ if (m_debug.in_buffer_log) {
+ venc_input_log_buffers(bufhdr, pmem_data_bufr, frameinfo.len);
+ }
+
+ return true;
+}
+bool venc_dev::venc_fill_buf(void *buffer, void *pmem_data_buf,unsigned,unsigned)
+{
+ struct venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct pmem *temp_buffer = NULL;
+ struct venc_buffer frameinfo;
+ struct OMX_BUFFERHEADERTYPE *bufhdr;
+
+ if (buffer == NULL) {
+ return false;
+ }
+
+ bufhdr = (OMX_BUFFERHEADERTYPE *)buffer;
+
+ if (pmem_data_buf) {
+ DEBUG_PRINT_LOW("Internal PMEM addr for o/p Heap UseBuf: %p", pmem_data_buf);
+ frameinfo.ptrbuffer = (OMX_U8 *)pmem_data_buf;
+ } else {
+ DEBUG_PRINT_LOW("Shared PMEM addr for o/p PMEM UseBuf/AllocateBuf: %p", bufhdr->pBuffer);
+ frameinfo.ptrbuffer = (OMX_U8 *)bufhdr->pBuffer;
+ }
+
+ frameinfo.clientdata = buffer;
+ frameinfo.sz = bufhdr->nAllocLen;
+ frameinfo.flags = bufhdr->nFlags;
+ frameinfo.offset = bufhdr->nOffset;
+
+ ioctl_msg.in = &frameinfo;
+ ioctl_msg.out = NULL;
+ DEBUG_PRINT_LOW("DBG: o/p frameinfo: bufhdr->pBuffer = %p, ptrbuffer = %p, offset = %u, len = %u",
+ bufhdr->pBuffer, frameinfo.ptrbuffer, frameinfo.offset, frameinfo.len);
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_CMD_FILL_OUTPUT_BUFFER,&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: ioctl VEN_IOCTL_CMD_FILL_OUTPUT_BUFFER failed");
+ return false;
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_slice_delivery_mode(OMX_BOOL enable)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ DEBUG_PRINT_HIGH("Set slice_delivery_mode: %d", enable);
+
+ if (multislice.mslice_mode == VEN_MSLICE_CNT_MB) {
+ if (ioctl(m_nDriver_fd, VEN_IOCTL_SET_SLICE_DELIVERY_MODE) < 0) {
+ DEBUG_PRINT_ERROR("Request for setting slice delivery mode failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("WARNING: slice_mode[%d] is not VEN_MSLICE_CNT_MB to set "
+ "slice delivery mode to the driver.", multislice.mslice_mode);
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_plusptype(OMX_BOOL enable)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct venc_plusptype plusptype = {0};
+ DEBUG_PRINT_LOW("Set plusptype: %d", enable);
+ plusptype.plusptype_enable = enable;
+ ioctl_msg.in = (void*)&plusptype;
+ ioctl_msg.out = NULL;
+
+ if (ioctl(m_nDriver_fd, VEN_IOCTL_SET_H263_PLUSPTYPE,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("Request for setting plusptype for h263 failed");
+ return false;
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_ltrmode(QOMX_VIDEO_LTRMODETYPE mode)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ venc_ltrmode ltr_mode;
+ ltr_mode.ltr_mode = (unsigned long)mode;
+ DEBUG_PRINT_HIGH("Set ltr mode: %d", mode);
+ ioctl_msg.in = (void*)&ltr_mode;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_SET_LTRMODE, (void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Setting ltrmode failed");
+ return false;
+ }
+
+ ltrmode.ltr_mode = (unsigned long)mode;
+ return true;
+}
+
+bool venc_dev::venc_set_ltrcount(OMX_U32 count)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ venc_ltrcount ltr_count;
+ ltr_count.ltr_count = (unsigned long)count;
+ DEBUG_PRINT_HIGH("Set ltr count: %d", count);
+ ioctl_msg.in = (void*)&ltr_count;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_SET_LTRCOUNT, (void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Setting ltrcount failed");
+ return false;
+ }
+
+ ltrcount.ltr_count = (unsigned long)count;
+ return true;
+}
+
+bool venc_dev::venc_set_ltrperiod(OMX_U32 period)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ venc_ltrperiod ltr_period;
+ ltr_period.ltr_period = (unsigned long)period;
+ DEBUG_PRINT_HIGH("Set ltr period: %d", period);
+ ioctl_msg.in = (void*)&ltr_period;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_SET_LTRPERIOD, (void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Setting ltrperiod failed");
+ return false;
+ }
+
+ ltrperiod.ltr_period = (unsigned long)period;
+ return true;
+}
+
+bool venc_dev::venc_set_ltruse(OMX_U32 id, OMX_U32 frames)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ venc_ltruse ltr_use;
+ ltr_use.ltr_id = (unsigned long)id;
+ ltr_use.ltr_frames = (unsigned long)frames;
+ DEBUG_PRINT_HIGH("Set ltr use: id = %d, ltr_frames = %d", id, frames);
+ ioctl_msg.in = (void*)&ltr_use;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_SET_LTRUSE, (void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Setting ltruse failed");
+ return false;
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_extradata(OMX_U32 extra_data)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ DEBUG_PRINT_HIGH("venc_set_extradata:: %x", extra_data);
+ ioctl_msg.in = (void*)&extra_data;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_SET_EXTRADATA, (void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting extradata failed");
+ return false;
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_session_qp(OMX_U32 i_frame_qp, OMX_U32 p_frame_qp)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct venc_sessionqp qp = {0, 0};
+ DEBUG_PRINT_HIGH("venc_set_session_qp:: i_frame_qp = %d, p_frame_qp = %d", i_frame_qp,
+ p_frame_qp);
+
+ qp.iframeqp = i_frame_qp;
+ qp.pframqp = p_frame_qp;
+
+ ioctl_msg.in = (void*)&qp;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_SESSION_QP,(void*)&ioctl_msg)< 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting session qp failed");
+ return false;
+ }
+
+ session_qp.iframeqp = i_frame_qp;
+ session_qp.pframqp = p_frame_qp;
+
+ return true;
+}
+
+bool venc_dev::venc_set_qp_range(OMX_U32 min_qp, OMX_U32 max_qp)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct venc_qprange qp = {0, 0};
+ DEBUG_PRINT_LOW("venc_set_qp_range:: min_qp = %d, max_qp = %d", min_qp,
+ max_qp);
+
+ qp.minqp = min_qp;
+ qp.maxqp = max_qp;
+
+ ioctl_msg.in = (void*)&qp;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_QP_RANGE,(void*)&ioctl_msg)< 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting qp range failed");
+ return false;
+ }
+
+ qp_range.minqp= min_qp;
+ qp_range.maxqp= max_qp;
+
+ return true;
+}
+
+bool venc_dev::venc_set_profile_level(OMX_U32 eProfile,OMX_U32 eLevel)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct venc_profile requested_profile;
+ struct ven_profilelevel requested_level;
+ unsigned const int *profile_tbl = NULL;
+ unsigned long mb_per_frame = 0, mb_per_sec = 0;
+ DEBUG_PRINT_HIGH("venc_set_profile_level:: eProfile = %d, Level = %d",
+ eProfile, eLevel);
+ mb_per_frame = ((m_sVenc_cfg.input_height + 15) >> 4)*
+ ((m_sVenc_cfg.input_width + 15) >> 4);
+
+ if ((eProfile == 0) && (eLevel == 0) && m_profile_set && m_level_set) {
+ DEBUG_PRINT_HIGH("Set profile/level was done already");
+ return true;
+ }
+
+ if (eProfile && eLevel) {
+ /* non-zero values will be set by user, saving the same*/
+ m_eProfile = eProfile;
+ m_eLevel = eLevel;
+ DEBUG_PRINT_HIGH("Save profile/level (%d/%d) for max allowed bitrate check",
+ m_eProfile, m_eLevel);
+ }
+
+ DEBUG_PRINT_LOW("Validating Profile/Level from table");
+
+ if (!venc_validate_profile_level(&eProfile, &eLevel)) {
+ DEBUG_PRINT_LOW("ERROR: Profile/Level validation failed");
+ return false;
+ }
+
+ if (m_sVenc_cfg.codectype == VEN_CODEC_MPEG4) {
+ DEBUG_PRINT_LOW("eProfile = %d, OMX_VIDEO_MPEG4ProfileSimple = %d and "
+ "OMX_VIDEO_MPEG4ProfileAdvancedSimple = %d", eProfile,
+ OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4ProfileAdvancedSimple);
+
+ if (eProfile == OMX_VIDEO_MPEG4ProfileSimple) {
+ requested_profile.profile = VEN_PROFILE_MPEG4_SP;
+ profile_tbl = (unsigned int const *)
+ (&mpeg4_profile_level_table[MPEG4_SP_START]);
+ profile_tbl += MPEG4_720P_LEVEL*5;
+ } else if (eProfile == OMX_VIDEO_MPEG4ProfileAdvancedSimple) {
+ requested_profile.profile = VEN_PROFILE_MPEG4_ASP;
+ profile_tbl = (unsigned int const *)
+ (&mpeg4_profile_level_table[MPEG4_ASP_START]);
+ profile_tbl += MPEG4_720P_LEVEL*5;
+ } else {
+ DEBUG_PRINT_LOW("ERROR: Unsupported MPEG4 profile = %u",
+ eProfile);
+ return false;
+ }
+
+ DEBUG_PRINT_LOW("eLevel = %d, OMX_VIDEO_MPEG4Level0 = %d, OMX_VIDEO_MPEG4Level1 = %d,"
+ "OMX_VIDEO_MPEG4Level2 = %d, OMX_VIDEO_MPEG4Level3 = %d, OMX_VIDEO_MPEG4Level4 = %d,"
+ "OMX_VIDEO_MPEG4Level5 = %d", eLevel, OMX_VIDEO_MPEG4Level0, OMX_VIDEO_MPEG4Level1,
+ OMX_VIDEO_MPEG4Level2, OMX_VIDEO_MPEG4Level3, OMX_VIDEO_MPEG4Level4, OMX_VIDEO_MPEG4Level5);
+
+ if (mb_per_frame >= 3600) {
+ if (requested_profile.profile == VEN_PROFILE_MPEG4_ASP)
+ requested_level.level = VEN_LEVEL_MPEG4_5;
+
+ if (requested_profile.profile == VEN_PROFILE_MPEG4_SP)
+ requested_level.level = VEN_LEVEL_MPEG4_6;
+ } else {
+ switch (eLevel) {
+ case OMX_VIDEO_MPEG4Level0:
+ requested_level.level = VEN_LEVEL_MPEG4_0;
+ break;
+ case OMX_VIDEO_MPEG4Level1:
+ requested_level.level = VEN_LEVEL_MPEG4_1;
+ break;
+ case OMX_VIDEO_MPEG4Level2:
+ requested_level.level = VEN_LEVEL_MPEG4_2;
+ break;
+ case OMX_VIDEO_MPEG4Level3:
+ requested_level.level = VEN_LEVEL_MPEG4_3;
+ break;
+ case OMX_VIDEO_MPEG4Level4a:
+ requested_level.level = VEN_LEVEL_MPEG4_4;
+ break;
+ case OMX_VIDEO_MPEG4Level5:
+ mb_per_sec = mb_per_frame * (m_sVenc_cfg.fps_num / m_sVenc_cfg.fps_den);
+
+ if ((requested_profile.profile == VEN_PROFILE_MPEG4_SP) && (mb_per_frame >= profile_tbl[0]) &&
+ (mb_per_sec >= profile_tbl[1])) {
+ DEBUG_PRINT_LOW("MPEG4 Level 6 is set for 720p resolution");
+ requested_level.level = VEN_LEVEL_MPEG4_6;
+ } else {
+ DEBUG_PRINT_LOW("MPEG4 Level 5 is set for non-720p resolution");
+ requested_level.level = VEN_LEVEL_MPEG4_5;
+ }
+
+ break;
+ default:
+ return false;
+ // TODO update corresponding levels for MPEG4_LEVEL_3b,MPEG4_LEVEL_6
+ break;
+ }
+ }
+ } else if (m_sVenc_cfg.codectype == VEN_CODEC_H263) {
+ if (eProfile == OMX_VIDEO_H263ProfileBaseline) {
+ requested_profile.profile = VEN_PROFILE_H263_BASELINE;
+ } else {
+ DEBUG_PRINT_LOW("ERROR: Unsupported H.263 profile = %u",
+ requested_profile.profile);
+ return false;
+ }
+
+ //profile level
+ switch (eLevel) {
+ case OMX_VIDEO_H263Level10:
+ requested_level.level = VEN_LEVEL_H263_10;
+ break;
+ case OMX_VIDEO_H263Level20:
+ requested_level.level = VEN_LEVEL_H263_20;
+ break;
+ case OMX_VIDEO_H263Level30:
+ requested_level.level = VEN_LEVEL_H263_30;
+ break;
+ case OMX_VIDEO_H263Level40:
+ requested_level.level = VEN_LEVEL_H263_40;
+ break;
+ case OMX_VIDEO_H263Level45:
+ requested_level.level = VEN_LEVEL_H263_45;
+ break;
+ case OMX_VIDEO_H263Level50:
+ requested_level.level = VEN_LEVEL_H263_50;
+ break;
+ case OMX_VIDEO_H263Level60:
+ requested_level.level = VEN_LEVEL_H263_60;
+ break;
+ case OMX_VIDEO_H263Level70:
+ requested_level.level = VEN_LEVEL_H263_70;
+ break;
+ default:
+ return false;
+ break;
+ }
+ } else if (m_sVenc_cfg.codectype == VEN_CODEC_H264) {
+ if (eProfile == OMX_VIDEO_AVCProfileBaseline) {
+ requested_profile.profile = VEN_PROFILE_H264_BASELINE;
+ } else if (eProfile == OMX_VIDEO_AVCProfileMain) {
+ requested_profile.profile = VEN_PROFILE_H264_MAIN;
+ } else if (eProfile == OMX_VIDEO_AVCProfileHigh) {
+ requested_profile.profile = VEN_PROFILE_H264_HIGH;
+ } else {
+ DEBUG_PRINT_LOW("ERROR: Unsupported H.264 profile = %u",
+ requested_profile.profile);
+ return false;
+ }
+
+ //profile level
+ switch (eLevel) {
+ case OMX_VIDEO_AVCLevel1:
+ requested_level.level = VEN_LEVEL_H264_1;
+ break;
+ case OMX_VIDEO_AVCLevel1b:
+ requested_level.level = VEN_LEVEL_H264_1b;
+ break;
+ case OMX_VIDEO_AVCLevel11:
+ requested_level.level = VEN_LEVEL_H264_1p1;
+ break;
+ case OMX_VIDEO_AVCLevel12:
+ requested_level.level = VEN_LEVEL_H264_1p2;
+ break;
+ case OMX_VIDEO_AVCLevel13:
+ requested_level.level = VEN_LEVEL_H264_1p3;
+ break;
+ case OMX_VIDEO_AVCLevel2:
+ requested_level.level = VEN_LEVEL_H264_2;
+ break;
+ case OMX_VIDEO_AVCLevel21:
+ requested_level.level = VEN_LEVEL_H264_2p1;
+ break;
+ case OMX_VIDEO_AVCLevel22:
+ requested_level.level = VEN_LEVEL_H264_2p2;
+ break;
+ case OMX_VIDEO_AVCLevel3:
+ requested_level.level = VEN_LEVEL_H264_3;
+ break;
+ case OMX_VIDEO_AVCLevel31:
+ requested_level.level = VEN_LEVEL_H264_3p1;
+ break;
+ case OMX_VIDEO_AVCLevel32:
+ requested_level.level = VEN_LEVEL_H264_3p2;
+ break;
+ case OMX_VIDEO_AVCLevel4:
+ requested_level.level = VEN_LEVEL_H264_4;
+ break;
+ default :
+ DEBUG_PRINT_ERROR("ERROR: Unsupported H.264 level= %u",
+ requested_level.level);
+ return false;
+ break;
+ }
+ }
+
+ if (!m_profile_set) {
+ ioctl_msg.in = (void*)&requested_profile;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_CODEC_PROFILE,(void*)&ioctl_msg)< 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting profile failed");
+ return false;
+ }
+
+ codec_profile.profile = requested_profile.profile;
+ m_profile_set = true;
+ DEBUG_PRINT_HIGH("Set codec profile = 0x%x", codec_profile.profile);
+ }
+
+ if (!m_level_set) {
+ ioctl_msg.in = (void*)&requested_level;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_PROFILE_LEVEL,(void*)&ioctl_msg)< 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting profile level failed");
+ return false;
+ }
+
+ profile_level.level = requested_level.level;
+ m_level_set = true;
+ DEBUG_PRINT_HIGH("Set codec level = 0x%x", profile_level.level);
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_voptiming_cfg( OMX_U32 TimeIncRes)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct venc_voptimingcfg vop_timing_cfg;
+
+ DEBUG_PRINT_HIGH("venc_set_voptiming_cfg: TimeRes = %u",
+ TimeIncRes);
+
+ vop_timing_cfg.voptime_resolution = TimeIncRes;
+
+ ioctl_msg.in = (void*)&vop_timing_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_VOP_TIMING_CFG,(void*)&ioctl_msg)< 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting Vop Timing failed");
+ return false;
+ }
+
+ voptimecfg.voptime_resolution = vop_timing_cfg.voptime_resolution;
+ return true;
+}
+
+bool venc_dev::venc_set_intra_period(OMX_U32 nPFrames, OMX_U32 nBFrames)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct venc_intraperiod intraperiod_cfg;
+
+ DEBUG_PRINT_LOW("venc_set_intra_period: nPFrames = %u",
+ nPFrames);
+ intraperiod_cfg.num_pframes = nPFrames;
+
+ if ((codec_profile.profile == VEN_PROFILE_MPEG4_ASP) ||
+ (codec_profile.profile == VEN_PROFILE_H264_MAIN) ||
+ (codec_profile.profile == VEN_PROFILE_H264_HIGH)) {
+#ifdef MAX_RES_1080P
+
+ if (nBFrames) {
+ DEBUG_PRINT_HIGH("INFO: Only 1 Bframe is supported");
+ intraperiod_cfg.num_bframes = 1;
+ } else
+ intraperiod_cfg.num_bframes = 0;
+
+#else
+
+ if (nBFrames) {
+ DEBUG_PRINT_ERROR("B frames not supported");
+ intraperiod_cfg.num_bframes = 0;
+ } else {
+ DEBUG_PRINT_ERROR("B frames not supported");
+ intraperiod_cfg.num_bframes = 0;
+ }
+
+#endif
+ } else
+ intraperiod_cfg.num_bframes = 0;
+
+ DEBUG_PRINT_HIGH("venc_set_intra_period: nPFrames = %u nBFrames = %u",
+ intraperiod_cfg.num_pframes, intraperiod_cfg.num_bframes);
+ ioctl_msg.in = (void*)&intraperiod_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_INTRA_PERIOD,(void*)&ioctl_msg)< 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting intra period failed");
+ return false;
+ }
+
+ intra_period.num_pframes = intraperiod_cfg.num_pframes;
+ intra_period.num_bframes = intraperiod_cfg.num_bframes;
+ return true;
+}
+
+bool venc_dev::venc_set_entropy_config(OMX_BOOL enable, OMX_U32 i_cabac_level)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct venc_entropycfg entropy_cfg;
+
+ memset(&entropy_cfg,0,sizeof(entropy_cfg));
+ DEBUG_PRINT_LOW("venc_set_entropy_config: CABAC = %u level: %u", enable, i_cabac_level);
+
+ if (enable &&(codec_profile.profile != VEN_PROFILE_H264_BASELINE)) {
+ entropy_cfg.longentropysel = VEN_ENTROPY_MODEL_CABAC;
+
+ if (i_cabac_level == 0) {
+ entropy_cfg.cabacmodel = VEN_CABAC_MODEL_0;
+ }
+
+#ifdef MAX_RES_1080P
+ else {
+ DEBUG_PRINT_HIGH("Invalid model set (%d) defaulting to model 0",i_cabac_level);
+ entropy_cfg.cabacmodel = VEN_CABAC_MODEL_0;
+ }
+
+#else
+ else if (i_cabac_level == 1) {
+ entropy_cfg.cabacmodel = VEN_CABAC_MODEL_1;
+ } else if (i_cabac_level == 2) {
+ entropy_cfg.cabacmodel = VEN_CABAC_MODEL_2;
+ }
+
+#endif
+ } else if (!enable) {
+ entropy_cfg.longentropysel = VEN_ENTROPY_MODEL_CAVLC;
+ } else {
+ DEBUG_PRINT_ERROR("Invalid Entropy mode for Baseline Profile");
+ return false;
+ }
+
+ ioctl_msg.in = (void*)&entropy_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_ENTROPY_CFG,(void*)&ioctl_msg)< 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting entropy config failed");
+ return false;
+ }
+
+ entropy.longentropysel = entropy_cfg.longentropysel;
+ entropy.cabacmodel = entropy_cfg.cabacmodel;
+ return true;
+}
+
+bool venc_dev::venc_set_multislice_cfg(OMX_INDEXTYPE Codec, OMX_U32 nSlicesize) // MB
+{
+ venc_ioctl_msg ioctl_msg = {NULL, NULL};
+ bool status = true;
+ struct venc_multiclicecfg multislice_cfg;
+
+ if ((Codec != OMX_IndexParamVideoH263) && (nSlicesize)) {
+ multislice_cfg.mslice_mode = VEN_MSLICE_CNT_MB;
+ multislice_cfg.mslice_size = nSlicesize;
+ } else {
+ multislice_cfg.mslice_mode = VEN_MSLICE_OFF;
+ multislice_cfg.mslice_size = 0;
+ }
+
+ DEBUG_PRINT_LOW("%s(): mode = %u, size = %u", __func__, multislice_cfg.mslice_mode,
+ multislice_cfg.mslice_size);
+
+ ioctl_msg.in = (void*)&multislice_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd, VEN_IOCTL_SET_MULTI_SLICE_CFG,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting multi-slice cfg failed");
+ status = false;
+ } else {
+ multislice.mslice_mode = multislice_cfg.mslice_mode;
+ multislice.mslice_size = nSlicesize;
+ }
+
+ return status;
+}
+
+bool venc_dev::venc_set_intra_refresh(OMX_VIDEO_INTRAREFRESHTYPE ir_mode, OMX_U32 irMBs)
+{
+ venc_ioctl_msg ioctl_msg = {NULL, NULL};
+ bool status = true;
+ struct venc_intrarefresh intraRefresh_cfg;
+
+ // There is no disabled mode. Disabled mode is indicated by a 0 count.
+ if (irMBs == 0 || ir_mode == OMX_VIDEO_IntraRefreshMax) {
+ intraRefresh_cfg.irmode = VEN_IR_OFF;
+ intraRefresh_cfg.mbcount = 0;
+ } else if ((ir_mode == OMX_VIDEO_IntraRefreshCyclic) &&
+ (irMBs < ((m_sVenc_cfg.input_width * m_sVenc_cfg.input_height)>>8))) {
+ intraRefresh_cfg.irmode = VEN_IR_CYCLIC;
+ intraRefresh_cfg.mbcount = irMBs;
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: Invalid IntraRefresh Parameters:"
+ "mb count: %d, mb mode:%d", irMBs, ir_mode);
+ return false;
+ }
+
+ ioctl_msg.in = (void*)&intraRefresh_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_INTRA_REFRESH,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting Intra Refresh failed");
+ status = false;
+ } else {
+ intra_refresh.irmode = intraRefresh_cfg.irmode;
+ intra_refresh.mbcount = intraRefresh_cfg.mbcount;
+ }
+
+ return status;
+}
+
+bool venc_dev::venc_set_error_resilience(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE* error_resilience)
+{
+ venc_ioctl_msg ioctl_msg = {NULL, NULL};
+ bool status = true;
+ struct venc_headerextension hec_cfg;
+ struct venc_multiclicecfg multislice_cfg;
+
+ if (m_sVenc_cfg.codectype == OMX_VIDEO_CodingMPEG4) {
+ if (error_resilience->bEnableHEC) {
+ hec_cfg.header_extension = 1;
+ } else {
+ hec_cfg.header_extension = 0;
+ }
+
+ ioctl_msg.in = (void*)&hec_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_HEC,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting HEader Error correction failed");
+ return false;
+ }
+
+ hec.header_extension = error_resilience->bEnableHEC;
+ }
+
+ if (error_resilience->bEnableRVLC) {
+ DEBUG_PRINT_ERROR("RVLC is not Supported");
+ return false;
+ }
+
+ if (( m_sVenc_cfg.codectype != OMX_VIDEO_CodingH263) &&
+ (error_resilience->bEnableDataPartitioning)) {
+ DEBUG_PRINT_ERROR("DataPartioning are not Supported for MPEG4/H264");
+ return false;
+ }
+
+ if (( m_sVenc_cfg.codectype != OMX_VIDEO_CodingH263) &&
+ (error_resilience->nResynchMarkerSpacing)) {
+ multislice_cfg.mslice_mode = VEN_MSLICE_CNT_BYTE;
+ multislice_cfg.mslice_size = error_resilience->nResynchMarkerSpacing;
+ } else if (m_sVenc_cfg.codectype == OMX_VIDEO_CodingH263 &&
+ error_resilience->bEnableDataPartitioning) {
+ multislice_cfg.mslice_mode = VEN_MSLICE_GOB;
+ multislice_cfg.mslice_size = 0;
+ } else {
+ multislice_cfg.mslice_mode = VEN_MSLICE_OFF;
+ multislice_cfg.mslice_size = 0;
+ }
+
+ DEBUG_PRINT_LOW("%s(): mode = %u, size = %u", __func__, multislice_cfg.mslice_mode,
+ multislice_cfg.mslice_size);
+ ioctl_msg.in = (void*)&multislice_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_MULTI_SLICE_CFG,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting multi-slice cfg failed");
+ status = false;
+ } else {
+ multislice.mslice_mode = multislice_cfg.mslice_mode ;
+ multislice.mslice_size = multislice_cfg.mslice_size;
+
+ }
+
+ return status;
+}
+
+bool venc_dev::venc_set_inloop_filter(OMX_VIDEO_AVCLOOPFILTERTYPE loopfilter)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ struct venc_dbcfg filter_cfg;
+
+ memset(&filter_cfg, 0, sizeof(filter_cfg));
+ DEBUG_PRINT_LOW("venc_set_inloop_filter: %u",loopfilter);
+
+ if (loopfilter == OMX_VIDEO_AVCLoopFilterEnable) {
+ filter_cfg.db_mode = VEN_DB_ALL_BLKG_BNDRY;
+ } else if (loopfilter == OMX_VIDEO_AVCLoopFilterDisable) {
+ filter_cfg.db_mode = VEN_DB_DISABLE;
+ } else if (loopfilter == OMX_VIDEO_AVCLoopFilterDisableSliceBoundary) {
+ filter_cfg.db_mode = VEN_DB_SKIP_SLICE_BNDRY;
+ }
+
+ filter_cfg.slicealpha_offset = filter_cfg.slicebeta_offset = 0;
+
+ ioctl_msg.in = (void*)&filter_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_DEBLOCKING_CFG,(void*)&ioctl_msg)< 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting inloop filter failed");
+ return false;
+ }
+
+ dbkfilter.db_mode = filter_cfg.db_mode;
+ dbkfilter.slicealpha_offset = dbkfilter.slicebeta_offset = 0;
+ return true;
+}
+
+bool venc_dev::venc_set_target_bitrate(OMX_U32 nTargetBitrate, OMX_U32 config)
+{
+ venc_ioctl_msg ioctl_msg = {NULL, NULL};
+ struct venc_targetbitrate bitrate_cfg;
+
+ DEBUG_PRINT_HIGH("venc_set_target_bitrate: bitrate = %u",
+ nTargetBitrate);
+ bitrate_cfg.target_bitrate = nTargetBitrate ;
+ ioctl_msg.in = (void*)&bitrate_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_TARGET_BITRATE,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting bit rate failed");
+ return false;
+ }
+
+ m_sVenc_cfg.targetbitrate = nTargetBitrate;
+ bitrate.target_bitrate = nTargetBitrate;
+
+ if (!config) {
+ m_level_set = false;
+
+ if (venc_set_profile_level(0, 0)) {
+ DEBUG_PRINT_LOW("Calling set level (Bitrate) with %d",profile_level.level);
+ }
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_encode_framerate(OMX_U32 encode_framerate, OMX_U32 config)
+{
+ venc_ioctl_msg ioctl_msg = {NULL, NULL};
+ struct venc_framerate frame_rate_cfg;
+
+ Q16ToFraction(encode_framerate,frame_rate_cfg.fps_numerator,frame_rate_cfg.fps_denominator);
+
+ DEBUG_PRINT_HIGH("venc_set_encode_framerate: framerate(Q16) = %u, NR: %d, DR: %d",
+ encode_framerate,frame_rate_cfg.fps_numerator,frame_rate_cfg.fps_denominator);
+
+ ioctl_msg.in = (void*)&frame_rate_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl(m_nDriver_fd, VEN_IOCTL_SET_FRAME_RATE,
+ (void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting framerate failed");
+ return false;
+ }
+
+ m_sVenc_cfg.fps_den = frame_rate_cfg.fps_denominator;
+ m_sVenc_cfg.fps_num = frame_rate_cfg.fps_numerator;
+
+ if (!config) {
+ m_level_set = false;
+
+ if (venc_set_profile_level(0, 0)) {
+ DEBUG_PRINT_LOW("Calling set level (Framerate) with %d",profile_level.level);
+ }
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_color_format(OMX_COLOR_FORMATTYPE color_format)
+{
+ venc_ioctl_msg ioctl_msg = {NULL, NULL};
+
+ if (color_format == OMX_COLOR_FormatYUV420SemiPlanar) {
+#ifdef MAX_RES_1080P
+ m_sVenc_cfg.inputformat= VEN_INPUTFMT_NV12_16M2KA;
+#else
+ m_sVenc_cfg.inputformat = VEN_INPUTFMT_NV12;
+#endif
+ } else {
+ DEBUG_PRINT_ERROR("WARNING: Unsupported Color format [%d]", color_format);
+#ifdef MAX_RES_1080P
+ m_sVenc_cfg.inputformat= VEN_INPUTFMT_NV12_16M2KA;
+#else
+ m_sVenc_cfg.inputformat = VEN_INPUTFMT_NV12;
+#endif
+ DEBUG_PRINT_HIGH("Default color format YUV420SemiPlanar is set");
+ }
+
+ ioctl_msg.in = (void*)&m_sVenc_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl(m_nDriver_fd, VEN_IOCTL_SET_BASE_CFG, (void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting color format failed");
+ return false;
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_intra_vop_refresh(OMX_BOOL intra_vop_refresh)
+{
+ DEBUG_PRINT_LOW("venc_set_intra_vop_refresh: intra_vop = %uc", intra_vop_refresh);
+
+ if (intra_vop_refresh == OMX_TRUE) {
+ if (ioctl(m_nDriver_fd, VEN_IOCTL_CMD_REQUEST_IFRAME, NULL) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting Intra VOP Refresh failed");
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_ERROR("ERROR: VOP Refresh is False, no effect");
+ }
+
+ return true;
+}
+
+bool venc_dev::venc_set_ratectrl_cfg(OMX_VIDEO_CONTROLRATETYPE eControlRate)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ bool status = true;
+ struct venc_ratectrlcfg ratectrl_cfg;
+
+ //rate control
+ switch (eControlRate) {
+ case OMX_Video_ControlRateDisable:
+ ratectrl_cfg.rcmode = VEN_RC_OFF;
+ break;
+ case OMX_Video_ControlRateVariableSkipFrames:
+ ratectrl_cfg.rcmode = VEN_RC_VBR_VFR;
+ break;
+ case OMX_Video_ControlRateVariable:
+ ratectrl_cfg.rcmode = VEN_RC_VBR_CFR;
+ break;
+ case OMX_Video_ControlRateConstantSkipFrames:
+ ratectrl_cfg.rcmode = VEN_RC_CBR_VFR;
+ break;
+ case OMX_Video_ControlRateConstant:
+ ratectrl_cfg.rcmode = VEN_RC_CBR_CFR;
+ break;
+ default:
+ status = false;
+ break;
+ }
+
+ if (status) {
+ ioctl_msg.in = (void*)&ratectrl_cfg;
+ ioctl_msg.out = NULL;
+
+ if (ioctl (m_nDriver_fd,VEN_IOCTL_SET_RATE_CTRL_CFG,(void*)&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR("ERROR: Request for setting rate control failed");
+ status = false;
+ } else
+ rate_ctrl.rcmode = ratectrl_cfg.rcmode;
+ }
+
+ return status;
+}
+
+bool venc_dev::venc_get_profile_level(OMX_U32 *eProfile,OMX_U32 *eLevel)
+{
+ bool status = true;
+
+ if (eProfile == NULL || eLevel == NULL) {
+ return false;
+ }
+
+ if (m_sVenc_cfg.codectype == VEN_CODEC_MPEG4) {
+ switch (codec_profile.profile) {
+ case VEN_PROFILE_MPEG4_SP:
+ *eProfile = OMX_VIDEO_MPEG4ProfileSimple;
+ break;
+ case VEN_PROFILE_MPEG4_ASP:
+ *eProfile = OMX_VIDEO_MPEG4ProfileAdvancedSimple;
+ break;
+ default:
+ *eProfile = OMX_VIDEO_MPEG4ProfileMax;
+ status = false;
+ break;
+ }
+
+ if (!status) {
+ return status;
+ }
+
+ //profile level
+ switch (profile_level.level) {
+ case VEN_LEVEL_MPEG4_0:
+ *eLevel = OMX_VIDEO_MPEG4Level0;
+ break;
+ case VEN_LEVEL_MPEG4_1:
+ *eLevel = OMX_VIDEO_MPEG4Level1;
+ break;
+ case VEN_LEVEL_MPEG4_2:
+ *eLevel = OMX_VIDEO_MPEG4Level2;
+ break;
+ case VEN_LEVEL_MPEG4_3:
+ *eLevel = OMX_VIDEO_MPEG4Level3;
+ break;
+ case VEN_LEVEL_MPEG4_4:
+ *eLevel = OMX_VIDEO_MPEG4Level4a;
+ break;
+ case VEN_LEVEL_MPEG4_5:
+ case VEN_LEVEL_MPEG4_6:
+ *eLevel = OMX_VIDEO_MPEG4Level5;
+ break;
+ default:
+ *eLevel = OMX_VIDEO_MPEG4LevelMax;
+ status = false;
+ break;
+ }
+ } else if (m_sVenc_cfg.codectype == VEN_CODEC_H263) {
+ if (codec_profile.profile == VEN_PROFILE_H263_BASELINE) {
+ *eProfile = OMX_VIDEO_H263ProfileBaseline;
+ } else {
+ *eProfile = OMX_VIDEO_H263ProfileMax;
+ return false;
+ }
+
+ switch (profile_level.level) {
+ case VEN_LEVEL_H263_10:
+ *eLevel = OMX_VIDEO_H263Level10;
+ break;
+ case VEN_LEVEL_H263_20:
+ *eLevel = OMX_VIDEO_H263Level20;
+ break;
+ case VEN_LEVEL_H263_30:
+ *eLevel = OMX_VIDEO_H263Level30;
+ break;
+ case VEN_LEVEL_H263_40:
+ *eLevel = OMX_VIDEO_H263Level40;
+ break;
+ case VEN_LEVEL_H263_45:
+ *eLevel = OMX_VIDEO_H263Level45;
+ break;
+ case VEN_LEVEL_H263_50:
+ *eLevel = OMX_VIDEO_H263Level50;
+ break;
+ case VEN_LEVEL_H263_60:
+ *eLevel = OMX_VIDEO_H263Level60;
+ break;
+ case VEN_LEVEL_H263_70:
+ *eLevel = OMX_VIDEO_H263Level70;
+ break;
+ default:
+ *eLevel = OMX_VIDEO_H263LevelMax;
+ status = false;
+ break;
+ }
+ } else if (m_sVenc_cfg.codectype == VEN_CODEC_H264) {
+ switch (codec_profile.profile) {
+ case VEN_PROFILE_H264_BASELINE:
+ *eProfile = OMX_VIDEO_AVCProfileBaseline;
+ break;
+ case VEN_PROFILE_H264_MAIN:
+ *eProfile = OMX_VIDEO_AVCProfileMain;
+ break;
+ case VEN_PROFILE_H264_HIGH:
+ *eProfile = OMX_VIDEO_AVCProfileHigh;
+ break;
+ default:
+ *eProfile = OMX_VIDEO_AVCProfileMax;
+ status = false;
+ break;
+ }
+
+ if (!status) {
+ return status;
+ }
+
+ switch (profile_level.level) {
+ case VEN_LEVEL_H264_1:
+ *eLevel = OMX_VIDEO_AVCLevel1;
+ break;
+ case VEN_LEVEL_H264_1b:
+ *eLevel = OMX_VIDEO_AVCLevel1b;
+ break;
+ case VEN_LEVEL_H264_1p1:
+ *eLevel = OMX_VIDEO_AVCLevel11;
+ break;
+ case VEN_LEVEL_H264_1p2:
+ *eLevel = OMX_VIDEO_AVCLevel12;
+ break;
+ case VEN_LEVEL_H264_1p3:
+ *eLevel = OMX_VIDEO_AVCLevel13;
+ break;
+ case VEN_LEVEL_H264_2:
+ *eLevel = OMX_VIDEO_AVCLevel2;
+ break;
+ case VEN_LEVEL_H264_2p1:
+ *eLevel = OMX_VIDEO_AVCLevel21;
+ break;
+ case VEN_LEVEL_H264_2p2:
+ *eLevel = OMX_VIDEO_AVCLevel22;
+ break;
+ case VEN_LEVEL_H264_3:
+ *eLevel = OMX_VIDEO_AVCLevel3;
+ break;
+ case VEN_LEVEL_H264_3p1:
+ *eLevel = OMX_VIDEO_AVCLevel31;
+ break;
+ case VEN_LEVEL_H264_3p2:
+ *eLevel = OMX_VIDEO_AVCLevel32;
+ break;
+ case VEN_LEVEL_H264_4:
+ *eLevel = OMX_VIDEO_AVCLevel4;
+ break;
+ default :
+ *eLevel = OMX_VIDEO_AVCLevelMax;
+ status = false;
+ break;
+ }
+ }
+
+ return status;
+}
+
+bool venc_dev::venc_validate_profile_level(OMX_U32 *eProfile, OMX_U32 *eLevel)
+{
+ OMX_U32 new_profile = 0, new_level = 0;
+ unsigned const int *profile_tbl = NULL;
+ OMX_U32 mb_per_frame, mb_per_sec;
+ bool profile_level_found = false;
+
+ DEBUG_PRINT_LOW("Init profile table for respective codec");
+
+ //validate the ht,width,fps,bitrate and set the appropriate profile and level
+ if (m_sVenc_cfg.codectype == VEN_CODEC_MPEG4) {
+ if (*eProfile == 0) {
+ if (!m_profile_set) {
+ *eProfile = OMX_VIDEO_MPEG4ProfileSimple;
+ } else {
+ switch (codec_profile.profile) {
+ case VEN_PROFILE_MPEG4_ASP:
+ *eProfile = OMX_VIDEO_MPEG4ProfileAdvancedSimple;
+ break;
+ case VEN_PROFILE_MPEG4_SP:
+ *eProfile = OMX_VIDEO_MPEG4ProfileSimple;
+ break;
+ default:
+ DEBUG_PRINT_LOW("%s(): Unknown Error", __func__);
+ return false;
+ }
+ }
+ }
+
+ if (*eLevel == 0 && !m_level_set) {
+ *eLevel = OMX_VIDEO_MPEG4LevelMax;
+ }
+
+ if (*eProfile == OMX_VIDEO_MPEG4ProfileSimple) {
+ profile_tbl = (unsigned int const *)mpeg4_profile_level_table;
+ } else if (*eProfile == OMX_VIDEO_MPEG4ProfileAdvancedSimple) {
+ profile_tbl = (unsigned int const *)
+ (&mpeg4_profile_level_table[MPEG4_ASP_START]);
+ } else {
+ DEBUG_PRINT_LOW("Unsupported MPEG4 profile type %lu", *eProfile);
+ return false;
+ }
+ } else if (m_sVenc_cfg.codectype == VEN_CODEC_H264) {
+ if (*eProfile == 0) {
+ if (!m_profile_set) {
+ *eProfile = OMX_VIDEO_AVCProfileBaseline;
+ } else {
+ switch (codec_profile.profile) {
+ case VEN_PROFILE_H264_BASELINE:
+ *eProfile = OMX_VIDEO_AVCProfileBaseline;
+ break;
+#ifndef _MSM8610_
+ case VEN_PROFILE_H264_MAIN:
+ *eProfile = OMX_VIDEO_AVCProfileMain;
+ break;
+ case VEN_PROFILE_H264_HIGH:
+ *eProfile = OMX_VIDEO_AVCProfileHigh;
+ break;
+#endif
+ default:
+ DEBUG_PRINT_LOW("%s(): Unsupported profile %x", __func__, codec_profile.profile);
+ return false;
+ }
+ }
+ }
+
+ if (*eLevel == 0 && !m_level_set) {
+ *eLevel = OMX_VIDEO_AVCLevelMax;
+ }
+
+ if (*eProfile == OMX_VIDEO_AVCProfileBaseline) {
+ profile_tbl = (unsigned int const *)h264_profile_level_table;
+ } else if (*eProfile == OMX_VIDEO_AVCProfileHigh) {
+ profile_tbl = (unsigned int const *)
+ (&h264_profile_level_table[H264_HP_START]);
+ } else if (*eProfile == OMX_VIDEO_AVCProfileMain) {
+ profile_tbl = (unsigned int const *)
+ (&h264_profile_level_table[H264_MP_START]);
+ } else {
+ DEBUG_PRINT_LOW("Unsupported AVC profile type %lu", *eProfile);
+ return false;
+ }
+ } else if (m_sVenc_cfg.codectype == VEN_CODEC_H263) {
+ if (*eProfile == 0) {
+ if (!m_profile_set) {
+ *eProfile = OMX_VIDEO_H263ProfileBaseline;
+ } else {
+ switch (codec_profile.profile) {
+ case VEN_PROFILE_H263_BASELINE:
+ *eProfile = OMX_VIDEO_H263ProfileBaseline;
+ break;
+ default:
+ DEBUG_PRINT_LOW("%s(): Unknown Error", __func__);
+ return false;
+ }
+ }
+ }
+
+ if (*eLevel == 0 && !m_level_set) {
+ *eLevel = OMX_VIDEO_H263LevelMax;
+ }
+
+ if (*eProfile == OMX_VIDEO_H263ProfileBaseline) {
+ profile_tbl = (unsigned int const *)h263_profile_level_table;
+ } else {
+ DEBUG_PRINT_LOW("Unsupported H.263 profile type %lu", *eProfile);
+ return false;
+ }
+ } else {
+ DEBUG_PRINT_LOW("Invalid codec type");
+ return false;
+ }
+
+ mb_per_frame = ((m_sVenc_cfg.input_height + 15) >> 4)*
+ ((m_sVenc_cfg.input_width + 15)>> 4);
+
+ if ((mb_per_frame >= 3600) && (m_sVenc_cfg.codectype == VEN_CODEC_MPEG4)) {
+ if (codec_profile.profile == VEN_PROFILE_MPEG4_ASP)
+ profile_level.level = VEN_LEVEL_MPEG4_5;
+
+ if (codec_profile.profile == VEN_PROFILE_MPEG4_SP)
+ profile_level.level = VEN_LEVEL_MPEG4_6;
+
+ {
+ new_level = profile_level.level;
+ new_profile = codec_profile.profile;
+ return true;
+ }
+ }
+
+ mb_per_sec = mb_per_frame * m_sVenc_cfg.fps_num / m_sVenc_cfg.fps_den;
+
+ do {
+ if (mb_per_frame <= (int)profile_tbl[0]) {
+ if (mb_per_sec <= (int)profile_tbl[1]) {
+ if (m_sVenc_cfg.targetbitrate <= (int)profile_tbl[2]) {
+ new_level = (int)profile_tbl[3];
+ new_profile = (int)profile_tbl[4];
+ profile_level_found = true;
+ DEBUG_PRINT_LOW("Appropriate profile/level found %d/%d", new_profile, new_level);
+ break;
+ }
+ }
+ }
+
+ profile_tbl = profile_tbl + 5;
+ } while (profile_tbl[0] != 0);
+
+ if (profile_level_found != true) {
+ DEBUG_PRINT_LOW("ERROR: Unsupported profile/level");
+ return false;
+ }
+
+ if ((*eLevel == OMX_VIDEO_MPEG4LevelMax) || (*eLevel == OMX_VIDEO_AVCLevelMax)
+ || (*eLevel == OMX_VIDEO_H263LevelMax)) {
+ *eLevel = new_level;
+ }
+
+ DEBUG_PRINT_LOW("%s: Returning with eProfile = %lu"
+ "Level = %lu", __func__, *eProfile, *eLevel);
+
+ return true;
+}
+
+bool venc_dev::venc_max_allowed_bitrate_check(OMX_U32 nTargetBitrate)
+{
+ unsigned const int *profile_tbl = NULL;
+
+ switch (m_sVenc_cfg.codectype) {
+ case VEN_CODEC_MPEG4:
+
+ if (m_eProfile == OMX_VIDEO_MPEG4ProfileSimple) {
+ profile_tbl = (unsigned int const *)mpeg4_profile_level_table;
+ } else if (m_eProfile == OMX_VIDEO_MPEG4ProfileAdvancedSimple) {
+ profile_tbl = (unsigned int const *)
+ (&mpeg4_profile_level_table[MPEG4_ASP_START]);
+ } else {
+ DEBUG_PRINT_ERROR("Unsupported MPEG4 profile type %lu", m_eProfile);
+ return false;
+ }
+
+ break;
+ case VEN_CODEC_H264:
+
+ if (m_eProfile == OMX_VIDEO_AVCProfileBaseline) {
+ profile_tbl = (unsigned int const *)h264_profile_level_table;
+ } else if (m_eProfile == OMX_VIDEO_AVCProfileHigh) {
+ profile_tbl = (unsigned int const *)
+ (&h264_profile_level_table[H264_HP_START]);
+ } else if (m_eProfile == OMX_VIDEO_AVCProfileMain) {
+ profile_tbl = (unsigned int const *)
+ (&h264_profile_level_table[H264_MP_START]);
+ } else {
+ DEBUG_PRINT_ERROR("Unsupported AVC profile type %lu", m_eProfile);
+ return false;
+ }
+
+ break;
+ case VEN_CODEC_H263:
+
+ if (m_eProfile == OMX_VIDEO_H263ProfileBaseline) {
+ profile_tbl = (unsigned int const *)h263_profile_level_table;
+ } else {
+ DEBUG_PRINT_ERROR("Unsupported H.263 profile type %lu", m_eProfile);
+ return false;
+ }
+
+ break;
+ default:
+ DEBUG_PRINT_ERROR("%s: unknown codec type", __func__);
+ return false;
+ }
+
+ while (profile_tbl[0] != 0) {
+ if (profile_tbl[3] == m_eLevel) {
+ if (nTargetBitrate > profile_tbl[2]) {
+ DEBUG_PRINT_ERROR("Max. supported bitrate for Profile[%d] & Level[%d]"
+ " is %u", m_eProfile, m_eLevel, profile_tbl[2]);
+ return false;
+ }
+ }
+
+ profile_tbl += 5;
+ }
+
+ return true;
+}
+
+#ifdef _ANDROID_ICS_
+bool venc_dev::venc_set_meta_mode(bool mode)
+{
+ venc_ioctl_msg ioctl_msg = {NULL,NULL};
+ ioctl_msg.in = &mode;
+ DEBUG_PRINT_HIGH("Set meta buffer mode: %d", mode);
+
+ if (ioctl(m_nDriver_fd,VEN_IOCTL_SET_METABUFFER_MODE,&ioctl_msg) < 0) {
+ DEBUG_PRINT_ERROR(" Set meta buffer mode failed");
+ return false;
+ }
+
+ return true;
+}
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-24 17:57:45 +0000