/**
* @brief This methods sets the Netpolicy info:NetworkIface,
* PDPProfileNo, Address Family with the TCPConnection
* object
*
* @return bool
*/
bool HTTPStackHelper::ConfigureNetPolicy()
{
bool retVal = false;
bool bSetNetPolicy = false;
NetPolicyInfo netPolicyInfo;
std_memset(&netPolicyInfo, 0, sizeof(netPolicyInfo));
if(m_HTTPStateInfo.GetNetPolicy(&netPolicyInfo))
{
netPolicyInfo.addrFamily = AF_INET;
if(m_NetworkIfaceId >= 0 &&
m_NetworkIfaceId != netPolicyInfo.ifaceName )
{
netPolicyInfo.ifaceName = m_NetworkIfaceId;
bSetNetPolicy = true;
}
if(m_PrimaryPDPProfileNo >= 0 &&
m_PrimaryPDPProfileNo != netPolicyInfo.primaryPDPProfileNo)
{
netPolicyInfo.primaryPDPProfileNo = m_PrimaryPDPProfileNo;
bSetNetPolicy = true;
}
if(bSetNetPolicy)
{
if(false == m_HTTPStateInfo.SetNetPolicy(&netPolicyInfo))
{
QTV_MSG_PRIO(QTVDIAG_HTTP_STACK, QTVDIAG_PRIO_ERROR,
"Failed to Set NetPolicy ");
}
else
{
QTV_MSG_PRIO3(QTVDIAG_HTTP_STACK, QTVDIAG_PRIO_ERROR,
"Set NetPolicy succeeded,Iface:%d , PDPProfileNo:%d, Addressfamily:%d",
netPolicyInfo.ifaceName,netPolicyInfo.primaryPDPProfileNo,netPolicyInfo.addrFamily);
retVal = true;
}
}
else
{
QTV_MSG_PRIO3(QTVDIAG_HTTP_STACK, QTVDIAG_PRIO_HIGH,
"Skipping setting NetPolicy, Values in use:iface:%d, Addrfamily:%d, pdpProfileNo:%d",
netPolicyInfo.ifaceName,netPolicyInfo.addrFamily,netPolicyInfo.primaryPDPProfileNo);
retVal = true;
}
}
else
{
QTV_MSG_PRIO(QTVDIAG_HTTP_STACK, QTVDIAG_PRIO_ERROR,
"Failed to Retreive NetPolicy for comparision ");
}
return retVal;
}
int HTTPSourceMMIHelper::ProcessDataRequestStatus
(
int32 portIdx,
void *pBuffHdrParam
)
{
int ret = -1;
MMI_BufferCmdType FillBuffCmdResp;
OMX_BUFFERHEADERTYPE *pBuffHdr = (OMX_BUFFERHEADERTYPE *) pBuffHdrParam;
QTV_NULL_PTR_CHECK(m_pHTTPSourceMMI, ret);
QTV_NULL_PTR_CHECK(pBuffHdr, ret);
OMX_U32 retVal = m_pHTTPSourceMMI->GetSample(portIdx, pBuffHdr);
if (MMI_S_PENDING == retVal)
{
return ret;
}
//notify fillbufferdone
FillBuffCmdResp.nPortIndex = pBuffHdr->nOutputPortIndex;
FillBuffCmdResp.pBufferHdr = pBuffHdr;
QTV_MSG_PRIO3( QTVDIAG_HTTP_STREAMING, QTVDIAG_PRIO_MEDIUM,
"HTTPMMIFillThisBufferDone for port %u pBufferHdr 0x%p pBuffer 0x%p",
(uint32)FillBuffCmdResp.nPortIndex,
(void *)pBuffHdr,
(void *)pBuffHdr->pBuffer );
NotifyMmi(MMI_RESP_FILL_THIS_BUFFER,
retVal, sizeof(FillBuffCmdResp),
&FillBuffCmdResp, m_pHTTPSourceMMI->m_pClientData);
return 0;
}
Vdec_ReturnType vdec_post_input_buffer(struct VDecoder *dec, video_input_frame_info *frame, void *cookie)
{
QTV_MSG_PRIO3(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: post_input data=%p len=%d cookie=%p\n", frame->data, frame->len, cookie);
#ifdef LOG_INPUT_BUFFERS
static int take_input = 1;
#endif
int fatal_err = 0;
/*checkBufAvail flag is needed since we do not need to checkout
* YUV/Slice buffer incase the NAL corresponds to same frame.
* This is required for multiple NALs in one input buffer
*/
bool checkBufAvail = true;
VDEC_INPUT_BUFFER input;
VideoDecoder *pDec = (VideoDecoder*)(dec->core);
VDEC_ERROR err = VDEC_ERR_EVERYTHING_FINE;
if (NULL == dec || NULL == frame || NULL == frame->data )
{
QTV_MSG_PRIO3(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: error: encountered NULL parameter dec: 0x%x frame: 0x%x data: 0x%x\n",
(unsigned int)dec,
(unsigned int)frame,
(unsigned int)frame->data);
return VDEC_EFAILED;
}
input.buffer[0] = (unsigned char*)frame->data;
input.timestamp[0] = (long long)frame->timestamp;
input.buffer_size[0] = (unsigned long int)frame->len;
input.buffer_pos[0] = 0;
input.layers = 1;
input.eOSIndicator[0]= false;
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: received ts: %lld", frame->timestamp);
if (frame->timestamp < timestamp )
{
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: error: out of order stamp! %d < %d\n",
(int)(frame->timestamp&0xFFFFFFFF), timestamp);
}
timestamp = (int)frame->timestamp;
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: vdec_core_post_input. buffer_size[0]: %ld frame->flags: 0x%x\n",
input.buffer_size[0], frame->flags);
if (input.buffer_size[0] == 0 && frame->flags & FRAME_FLAG_EOS)
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: Zero-length buffer with EOS bit set\n");
input.eOSIndicator[0] = true;
if(pDec)
err = pDec->EOS( );
else
err = VDEC_ERR_NULL_STREAM_ID;
if(VDEC_ERR_OUT_OF_BUFFERS == err) return VDEC_EOUTOFBUFFERS;
vdec_decoder_info->ctxt->buffer_done(vdec_decoder_info->ctxt, cookie);
if (VDEC_ERR_EVERYTHING_FINE == err) return VDEC_SUCCESS;
return VDEC_EFAILED;
}
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: vdec_core_post_input\n");
#ifdef LOG_INPUT_BUFFERS
if (take_input)
{
fwritex((unsigned char*)frame->data, frame->len, pInputFile);
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: frame %d frame->len %d\n", counter++, frame->len);
}
#endif
do {
QPERF_TIME(arm_decode, err = pDec->Decode( &input, checkBufAvail ));
if (VDEC_ERR_EVERYTHING_FINE != err)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: vdec_decoder error: %d\n", (int)err);
if(VDEC_ERR_UNSUPPORTED_DIMENSIONS == err) {
fatal_err = 1;
break;
}
}
checkBufAvail = false;
} while( ( VDEC_ERR_EVERYTHING_FINE == err ) && ( 0 != input.buffer_size[0] ) );
#ifdef LOG_INPUT_BUFFERS
take_input = (err==14?0:1);
#endif
if(VDEC_ERR_OUT_OF_BUFFERS == err) return VDEC_EOUTOFBUFFERS;
vdec_input_buffer_release_cb_handler(pDec,&input,cookie);
if(VDEC_ERR_EVERYTHING_FINE == err) return VDEC_SUCCESS;
if(fatal_err) {
static struct vdec_frame frame;
memset(&frame, 0, sizeof(frame));
frame.flags |= FRAME_FLAG_FATAL_ERROR;
QPERF_END(frame_data);
vdec_decoder_info->ctxt->frame_done(vdec_decoder_info->ctxt, &frame);
}
return VDEC_EFAILED;
}
struct VDecoder *vdec_open(struct vdec_context *ctxt)
{
struct VDecoder *dec = NULL;
VDEC_ERROR err = 0;
const VDEC_CONCURRENCY_CONFIG concurrencyConfig = VDEC_CONCURRENT_NONE;
VideoDecoder* pDec = NULL;
dec = (VDecoder*)calloc(1, sizeof(struct VDecoder));
if (!dec) {
return 0;
}
dec->ctxt = ctxt;
dec->width = ctxt->width;
dec->height = ctxt->height;
dec->ctxt->outputBuffer.numBuffers = ctxt->outputBuffer.numBuffers;
if(VDEC_SUCCESS != vdec_commit_memory(dec)) {
return 0;
}
QPERF_RESET(arm_decode);
QPERF_RESET(frame_data);
nFrameDoneCnt = 0;
nGoodFrameCnt = 0;
#ifdef PROFILE_DECODER
qperf_total_frame_cnt = 0;
#endif
vdec_output_frame_index = 0;
timestamp = 0;
int i;
VDEC_PARAMETER_DATA codeDetectionEnable;
codeDetectionEnable.startCodeDetection.bStartCodeDetectionEnable = false; // by default set to false; MPEG4 doesnt require it
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: vdec_open(). width: %d, height: %d\n", dec->width, dec->height);
vdec_decoder_info = dec;
QTV_MSG_PRIO3(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: vdec_open(). width: %d, height: %d kind[%s]\n",
vdec_decoder_info->ctxt->width, vdec_decoder_info->ctxt->height,
vdec_decoder_info->ctxt->kind);
if(!strcmp(vdec_decoder_info->ctxt->kind,"OMX.qcom.video.decoder.avc"))
{
dec->core = reinterpret_cast<VDEC_STREAM_ID>(pCreateFnH264(&err));
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: Creating H264 Decoder [%p]\n",dec->core);
VDEC_PARAMETER_DATA sizeOfNalLengthField;
sizeOfNalLengthField.sizeOfNalLengthField.sizeOfNalLengthField = dec->ctxt->size_of_nal_length_field;
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: NAL lenght [%d]\n",dec->ctxt->size_of_nal_length_field);
pDec = (VideoDecoder*)(dec->core);
if (0 == dec->ctxt->size_of_nal_length_field)
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: START CODE....\n");
codeDetectionEnable.startCodeDetection.bStartCodeDetectionEnable = true;
if(!pDec)
err = VDEC_ERR_NULL_STREAM_ID;
else
err = pDec->SetParameter(VDEC_PARM_START_CODE_DETECTION,&codeDetectionEnable);
if (VDEC_ERR_EVERYTHING_FINE != err)
{
// TBD- printx("[vdec_core] set start code detection parameter failed: %d", (int)err);
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"[vdec_core] set start code detection parameter failed: %d", (int)err);
goto fail_initialize;
}
}
else if(dec->ctxt->size_of_nal_length_field > 0 && dec->ctxt->size_of_nal_length_field <= 4)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: NALU LENGTH[%d]\n",dec->ctxt->size_of_nal_length_field);
// test size of NAL length field decoder support
if(!pDec)
err = VDEC_ERR_NULL_STREAM_ID;
else
err = pDec->SetParameter( VDEC_PARM_SIZE_OF_NAL_LENGTH_FIELD, &sizeOfNalLengthField );
if (VDEC_ERR_EVERYTHING_FINE != err)
{
// TBD- printx("[vdec_core] set start code detection parameter failed: %d", (int)err);
goto fail_initialize;
}
}
else
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: Invalid size of nal length field: %d\n", dec->ctxt->size_of_nal_length_field);
goto fail_core;
}
}
else if ((!strcmp(vdec_decoder_info->ctxt->kind,"OMX.qcom.video.decoder.mpeg4"))
|| (!strcmp(vdec_decoder_info->ctxt->kind,"OMX.qcom.video.decoder.h263")))
{
dec->core = reinterpret_cast<VDEC_STREAM_ID>(pCreateFnMpeg4(&err));
pDec = (VideoDecoder*)(dec->core);
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: Creating MP4 Decoder [%p]\n",dec->core);
}
else if (!strcmp(vdec_decoder_info->ctxt->kind,"OMX.qcom.video.decoder.vc1"))
{
dec->core = reinterpret_cast<VDEC_STREAM_ID>(pCreateFnWmv(&err));
pDec = (VideoDecoder*)(dec->core);
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: Creating WMV Decoder [%p]\n",dec->core);
}
else
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"Incorrect codec kind\n");
goto fail_core;
}
if (VDEC_ERR_EVERYTHING_FINE != err || NULL == dec->core)
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: create failed\n");
goto fail_core;
}
for(i=0; i<VDEC_NFRAMES; i++)
{
slice_buffer_info[i].base = (char*)dec->input[i].base;
//slice_buffer_info[i].phys = dec->input[i].phys;
slice_buffer_info[i].fd = dec->input[i].pmem_id;
}
VDEC_DIMENSIONS frameSize;
frameSize.height = dec->height;
frameSize.width = dec->width;
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: Init width: %d height %d\n", frameSize.width, frameSize.height);
/*
VDEC_PARAMETER_DATA deblockerInfo;
deblockerInfo.deblockerEnable.bDeblockerEnable = true;
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"[vdec_core] SetParameter\n");
err = vdec_set_parameter(dec->core, VDEC_PARM_DEBLOCKER_ENABLE, &deblockerInfo);
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"[vdec_core] after SetParameter\n",err);
if (VDEC_ERR_EVERYTHING_FINE != err)
{
//TBD - printx("[vdec_core] set deblocker enable parameter failed: %d", (int)err);
goto fail_initialize;
}
*/
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: vdec_initialize\n");
if(!pDec)
err = VDEC_ERR_NULL_STREAM_ID;
else
{
err = pDec->Initialize(1,
vdec_frame_buffer_malloc_cb_handler,
vdec_frame_buffer_free_cb_handler,
vdec_frame_cb_handler,
NULL,
frameSize,
VDEC_CONCURRENT_NONE,
slice_buffer_info,
dec->ctxt->outputBuffer.numBuffers,
ctxt->adsp_fd);
}
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: vdec_initialize\n",err);
if (err != VDEC_ERR_EVERYTHING_FINE)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: initialization failed: %d\n", (int)err);
goto fail_initialize;
}
#if NEED_VDEC_LP
#ifdef _ANDROID_
dec->fake = adsp_open("/dev/adsp/VDEC_LP_MODE", dec->core, core_msg_func);
#else
dec->fake = adsp_open("/dev/VDEC_LP_MODE", dec->core, core_msg_func);
#endif //_ANDROID_
if (!dec->fake)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: adsp_open() failed error: %s\n", strerror(errno));
goto fail_initialize;
}
if (adsp_enable((adsp_module*)dec->fake)) goto fail_enable;
#endif
#ifdef LOG_YUV_FRAMES
#ifdef T_WINNT
pYUVFile = fopen ( "../debug/yuvframes.yuv" , "wb" );
#elif _ANDROID_
pYUVFile = fopen ( "/data/yuvframes.yuv" , "wb" );
#else
pYUVFile = fopen ( "yuvframes.yuv" , "wb" );
#endif
#endif
#ifdef LOG_INPUT_BUFFERS
#ifdef T_WINNT
pInputFile = fopen ( "../debug/inputbuffers.bin" , "wb" );
#elif _ANDROID_
pInputFile = fopen ( "/data/inputbuffers.bin" , "wb" );
#else
pInputFile = fopen ( "inputbuffers.bin" , "wb" );
#endif
#endif
return dec;
fail_enable:
#if NEED_VDEC_LP
adsp_close((adsp_module*)dec->fake);
#endif
fail_initialize:
if(pDec) {
pDec->Suspend( );
QTV_Delete( pDec );
}
fail_core:
if (dec) {
dec->dead = 1;
free(dec);
}
return NULL;
}
struct adsp_module *adsp_open(const char *name, struct adsp_open_info info,
void *context, int32 vdec_fd)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL, QTVDIAG_PRIO_LOW, "adsp_open: %s", name);
int fds[2], r;
struct adsp_module *mod;
mod = calloc(1, sizeof(*mod));
if (!mod)
return 0;
mod->ctxt = context;
mod->frame_done = info.frame_done;
mod->buffer_done = info.buffer_done;
#ifndef T_WINNT
mod->dead = 0;
mod->init_done = 0;
r = pthread_create(&mod->thr, 0, adsp_thread, mod);
if (r < 0) {
QTV_MSG_PRIO(QTVDIAG_GENERAL, QTVDIAG_PRIO_ERROR,
"Error - unable to create adsp_thread\n");
goto fail_thread;
}
mod->fd = vdec_fd;
if(mod->fd < 0) {
mod->fd = open("/dev/vdec", O_RDWR);
if (mod->fd < 0) {
QTV_MSG_PRIO3(QTVDIAG_GENERAL, QTVDIAG_PRIO_FATAL,
"adsp: cannot open '%s', fd: %d (%s)\n", name,
mod->fd, strerror(errno));
goto fail_open;
}
}
#if DEBUG
if (pthread_mutex_init(&logMTX, NULL) == 0) {
if (pthread_mutex_lock(&logMTX) == 0) {
if (!logFD) {
logFD = fopen(logFN, "a");
}
if (logFD) {
fprintf(logFD, "\n");
pthread_mutex_unlock(&logMTX);
}
}
if (!logFD) {
pthread_mutex_destroy(&logMTX);
}
}
if (!logFD) {
QTV_MSG_PRIO(QTVDIAG_GENERAL, QTVDIAG_PRIO_ERROR,
"adsp: unable to log adsp writes\n");
}
#endif
#endif
return mod;
fail_open:
mod->dead = 1;
fail_thread:
free(mod);
return 0;
}
HTTPReturnCode
HTTPStackHelper::SendRequest(uint32 requestId,
HTTPMethodType method,
const char *relativeUrl,
int relativeUrlLen)
{
HTTPReturnCode result = HTTP_FAILURE;
/* If request was already sent/sending and SendRequest() comes in with the same requestId
* (ex usecase: In case of HTTP1.0 server, we first try with original URL and retry with ByteRangeURL
* using the same requestId). In such scenario, resetconnection and reset stateinfo to
* mark all as requests as REQUEST_WAITING_TO_SEND.
*
* This ensures req/resp order is preserved. ex: R1-R2-R3 will remain R1'-R2-R3 where R1'=R1 is the
* new byterangeURl request. If connection and state info was not reset, order will be R2-R3-R1'.
*/
if(m_HTTPStateInfo.IsRequestPartiallyOrFullySent(requestId))
{
m_HTTPStateInfo.ResetConnection();
m_HTTPStateInfo.Reset();
SetState(&HTTPStackStateObjects::HTTPStateClosedObj);
}
result = m_HTTPStateInfo.SetRequest(requestId,
method,
relativeUrl,
relativeUrlLen,
m_ProxyServerName);
if (result == HTTP_SUCCESS)
{
if ((&(HTTPStackStateObjects::HTTPStateIdleObj) == m_HTTPState) ||
(&(HTTPStackStateObjects::HTTPStateClosedObj) == m_HTTPState))
{
result = SendRequestInternal(requestId);
}
else if (&(HTTPStackStateObjects::HTTPStateConnectedObj) == m_HTTPState )
{
bool bCreateNewConnection = false;
result = m_HTTPStateInfo.SendPendingRequests(bCreateNewConnection);
// if the head request that have been queued recently needs stack to connect to new server,
// close the current connection and bring up new connection
if (result == HTTP_FAILURE && bCreateNewConnection)
{
QTV_MSG_PRIO3(QTVDIAG_HTTP_STACK, QTVDIAG_PRIO_HIGH,"Creating New connection,result:%d,bCreate :%d,requestId:%u",
result,bCreateNewConnection,requestId);
result = SendRequestInternal(requestId);
}
else if(result == HTTP_FAILURE ||
result == HTTP_WAIT )
{
QTV_MSG_PRIO1(QTVDIAG_HTTP_STACK, QTVDIAG_PRIO_HIGH,"SendPendingRequests Status :%d, For socket errors Reconnect will resend request",
result);
result = HTTP_SUCCESS;
}
}
}
return result;
}
