/** * @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; }