| /* ------------------------------------------------------------------ |
| * Copyright (C) 2008 PacketVideo |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either |
| * express or implied. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * ------------------------------------------------------------------- |
| */ |
| /* |
| //////////////////////////////////////////////////////////////////////////////// |
| // // |
| // File: pvm4vencoder.cpp // |
| // // |
| // Modified: 01/15/03 // |
| // Note:: Black in RGB is (16,128,128) in YUV // |
| // // |
| // Modified: 04/09/03 // |
| // Note:: Optimized function RGB2YUV420_12bit() // |
| ////////////////////////////////////////////////////////////////////////////////// |
| */ |
| |
| #include "pvm4vencoder.h" |
| #include "oscl_mem.h" |
| |
| #include "oscl_dll.h" |
| OSCL_DLL_ENTRY_POINT_DEFAULT() |
| |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| CPVM4VEncoder::CPVM4VEncoder() |
| { |
| //iEncoderControl |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF CPVM4VEncoder::~CPVM4VEncoder() |
| { |
| Cancel(); /* CTimer function */ |
| Terminate(); |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF CPVM4VEncoder* CPVM4VEncoder::New(int32 aThreadId) |
| { |
| CPVM4VEncoder* self = new CPVM4VEncoder; |
| if (self && self->Construct(aThreadId)) |
| return self; |
| if (self) |
| OSCL_DELETE(self); |
| return NULL; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| bool CPVM4VEncoder::Construct(int32 aThreadId) |
| { |
| oscl_memset((void *)&iEncoderControl, 0, sizeof(VideoEncControls)); |
| iInitialized = false; |
| iObserver = NULL; |
| iNumOutputData = 0; |
| iYUVIn = NULL; |
| for (int i = 0; i < KCVEIMaxOutputBuffer; i++) |
| { |
| iOutputData[i] = NULL; |
| } |
| iState = EIdle; |
| |
| if (aThreadId >= 0) |
| AddToScheduler(); |
| |
| return true; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| void CPVM4VEncoder::DoCancel() |
| { |
| /* called when Cancel() is called.*/ |
| // They use Stop for PVEngine.cpp in PVPlayer. |
| return ; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::SetObserver(MPVCVEIObserver *aObserver) |
| { |
| iObserver = aObserver; |
| return ECVEI_SUCCESS; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::AddBuffer(TPVVideoOutputData *aVidOut) |
| { |
| if (iNumOutputData >= KCVEIMaxOutputBuffer) |
| { |
| return ECVEI_FAIL; |
| } |
| |
| iOutputData[iNumOutputData++] = aVidOut; |
| |
| return ECVEI_SUCCESS; |
| } |
| |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::Encode(TPVVideoInputData *aVidIn) |
| { |
| ULong modTime; |
| VideoEncFrameIO vid_in; |
| |
| if (iState != EIdle || iObserver == NULL) |
| { |
| return ECVEI_FAIL; |
| } |
| |
| if (aVidIn->iTimeStamp >= iNextModTime) |
| { |
| if (iVideoFormat == ECVEI_YUV420) |
| #ifdef YUV_INPUT |
| { |
| if (iYUVIn) /* iSrcWidth is not multiple of 4 or iSrcHeight is odd number */ |
| { |
| CopyToYUVIn(aVidIn->iSource, iSrcWidth, iSrcHeight, |
| ((iSrcWidth + 15) >> 4) << 4, ((iSrcHeight + 15) >> 4) << 4); |
| iVideoIn = iYUVIn; |
| } |
| else /* otherwise, we can just use aVidIn->iSource */ |
| { |
| iVideoIn = aVidIn->iSource; // Sept 14, 2005 */ |
| } |
| } |
| #else |
| return ECVEI_FAIL; |
| #endif |
| if (iVideoFormat == ECVEI_RGB12) |
| #ifdef RGB12_INPUT |
| { |
| RGB2YUV420_12bit((uint32 *)aVidIn->iSource, iSrcWidth, iSrcHeight, |
| ((iSrcWidth + 15) >> 4) << 4, ((iSrcHeight + 15) >> 4) << 4); |
| iVideoIn = iYUVIn; |
| } |
| #else |
| return ECVEI_FAIL; |
| #endif |
| if (iVideoFormat == ECVEI_RGB24) |
| #ifdef RGB24_INPUT |
| { |
| RGB2YUV420_24bit(aVidIn->iSource, iSrcWidth, iSrcHeight, |
| ((iSrcWidth + 15) >> 4) << 4, ((iSrcHeight + 15) >> 4) << 4); |
| iVideoIn = iYUVIn; |
| } |
| #else |
| return ECVEI_FAIL; |
| #endif |
| |
| /* assign with backward-P or B-Vop this timestamp must be re-ordered */ |
| iTimeStamp = aVidIn->iTimeStamp; |
| |
| modTime = iTimeStamp; |
| |
| #ifdef NO_SLICE_ENCODE |
| return ECVEI_FAIL; |
| #else |
| vid_in.height = ((iSrcHeight + 15) >> 4) << 4; |
| vid_in.pitch = ((iSrcWidth + 15) >> 4) << 4; |
| vid_in.timestamp = modTime; |
| vid_in.yChan = (UChar*)iVideoIn; |
| vid_in.uChan = (UChar*)(iVideoIn + vid_in.height * vid_in.pitch); |
| vid_in.vChan = vid_in.uChan + ((vid_in.height * vid_in.pitch) >> 2); |
| |
| /*status = */ |
| (int) PVEncodeFrameSet(&iEncoderControl, &vid_in, &modTime, &iNumLayer); |
| #endif |
| |
| iState = EEncode; |
| RunIfNotReady(); |
| |
| return ECVEI_SUCCESS; |
| } |
| else /* if(aVidIn->iTimeStamp >= iNextModTime) */ |
| { |
| iTimeStamp = aVidIn->iTimeStamp; |
| iNumLayer = -1; |
| iState = EEncode; |
| RunIfNotReady(); |
| return ECVEI_SUCCESS; |
| } |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| void CPVM4VEncoder::Run() |
| { |
| #ifndef NO_SLICE_ENCODE |
| |
| //Bool status; |
| Int Size, endOfFrame = 0; |
| ULong modTime; |
| int32 oindx; |
| VideoEncFrameIO vid_out; |
| |
| switch (iState) |
| { |
| case EEncode: |
| /* find available bitstream */ |
| if (iNumOutputData <= 0) |
| { |
| iObserver->HandlePVCVEIEvent(iId, ECVEI_NO_BUFFERS); |
| RunIfNotReady(50); |
| break; |
| } |
| oindx = --iNumOutputData; /* last-in first-out */ |
| Size = iOutputData[oindx]->iBitStreamSize; |
| iOutputData[oindx]->iExternalTimeStamp = iTimeStamp; |
| iOutputData[oindx]->iVideoTimeStamp = iTimeStamp; |
| iOutputData[oindx]->iFrame = iVideoOut; |
| |
| if (iNumLayer == -1) |
| { |
| iOutputData[oindx]->iBitStreamSize = 0; |
| iOutputData[oindx]->iLayerNumber = iNumLayer; |
| iState = EIdle; |
| iObserver->HandlePVCVEIEvent(iId, ECVEI_FRAME_DONE, (uint32)iOutputData[oindx]); |
| break; |
| } |
| |
| /*status = */ |
| (int) PVEncodeSlice(&iEncoderControl, (UChar*)iOutputData[oindx]->iBitStream, &Size, |
| &endOfFrame, &vid_out, &modTime); |
| |
| iOutputData[oindx]->iBitStreamSize = Size; |
| iOutputData[oindx]->iLayerNumber = iNumLayer; |
| if (endOfFrame != 0) /* done with this frame */ |
| { |
| iNextModTime = modTime; |
| iOutputData[oindx]->iFrame = iVideoOut = (uint8*)vid_out.yChan; |
| iOutputData[oindx]->iVideoTimeStamp = vid_out.timestamp; |
| |
| if (endOfFrame == -1) /* pre-skip */ |
| { |
| iOutputData[oindx]->iLayerNumber = -1; |
| } |
| else |
| { |
| PVGetHintTrack(&iEncoderControl, &(iOutputData[oindx]->iHintTrack)); |
| } |
| iState = EIdle; |
| iObserver->HandlePVCVEIEvent(iId, ECVEI_FRAME_DONE, (uint32)iOutputData[oindx]); |
| } |
| else |
| { |
| RunIfNotReady(); |
| iObserver->HandlePVCVEIEvent(iId, ECVEI_BUFFER_READY, (uint32)iOutputData[oindx]); |
| } |
| |
| break; |
| default: |
| break; |
| } |
| #endif /* NO_SLICE_ENCODE */ |
| |
| return ; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::Initialize(TPVVideoInputFormat *aVidInFormat, TPVVideoEncodeParam *aEncParam) |
| { |
| |
| int /*status,*/i; |
| MP4EncodingMode ENC_Mode ; |
| ParamEncMode RvlcMode = PV_OFF; /* default no RVLC */ |
| Int quantType[2] = {0, 0}; /* default H.263 quant*/ |
| VideoEncOptions aEncOption; /* encoding options */ |
| |
| iState = EIdle ; // stop encoding |
| iId = aEncParam->iEncodeID; |
| |
| if (aEncParam->iContentType == ECVEI_STREAMING) |
| { |
| ENC_Mode = DATA_PARTITIONING_MODE; |
| } |
| else if (aEncParam->iContentType == ECVEI_DOWNLOAD) |
| { |
| if (aEncParam->iPacketSize > 0) |
| { |
| ENC_Mode = COMBINE_MODE_WITH_ERR_RES; |
| } |
| else |
| { |
| ENC_Mode = COMBINE_MODE_NO_ERR_RES; |
| } |
| } |
| else if (aEncParam->iContentType == ECVEI_H263) |
| { |
| if (aEncParam->iPacketSize > 0) |
| { |
| ENC_Mode = H263_MODE_WITH_ERR_RES; |
| } |
| else |
| { |
| ENC_Mode = H263_MODE; |
| } |
| } |
| else |
| { |
| return ECVEI_FAIL; |
| } |
| |
| iSrcWidth = aVidInFormat->iFrameWidth; |
| iSrcHeight = aVidInFormat->iFrameHeight; |
| iSrcFrameRate = (int) aVidInFormat->iFrameRate; |
| iVideoFormat = (TPVVideoFormat) aVidInFormat->iVideoFormat; |
| iFrameOrientation = aVidInFormat->iFrameOrientation; |
| |
| if (iInitialized == true) /* clean up before re-initialized */ |
| { |
| /*status = */(int) PVCleanUpVideoEncoder(&iEncoderControl); |
| if (iYUVIn) |
| { |
| oscl_free(iYUVIn); |
| iYUVIn = NULL; |
| } |
| if (iVideoFormat == ECVEI_RGB24 || iVideoFormat == ECVEI_RGB12) |
| { |
| #if defined(RGB24_INPUT)||defined(RGB12_INPUT) |
| freeRGB2YUVTables(); |
| #else |
| return ECVEI_FAIL; |
| #endif |
| } |
| } |
| |
| // allocate iYUVIn |
| if (((iSrcWidth&0xF) || (iSrcHeight&0xF)) || iVideoFormat != ECVEI_YUV420) /* Not multiple of 16 */ |
| { |
| iYUVIn = (uint8*) oscl_malloc(((((iSrcWidth + 15) >> 4) * ((iSrcHeight + 15) >> 4)) * 3) << 7); |
| if (iYUVIn == NULL) |
| { |
| return ECVEI_FAIL; |
| } |
| } |
| |
| // check the buffer delay according to the clip duration |
| if (aEncParam->iClipDuration > 0 && aEncParam->iRateControlType == EVBR_1) |
| { |
| if (aEncParam->iBufferDelay > aEncParam->iClipDuration / 10000.0) //enforce 10% variation of the clip duration as the bound of buffer delay |
| { |
| aEncParam->iBufferDelay = aEncParam->iClipDuration / (float)10000.0; |
| } |
| } |
| |
| /* Initialize the color conversion table if needed*/ |
| if (iVideoFormat == ECVEI_RGB24 || iVideoFormat == ECVEI_RGB12) |
| { |
| #if defined(RGB24_INPUT)||defined(RGB12_INPUT) |
| initRGB2YUVTables(); |
| #else |
| return ECVEI_FAIL; |
| #endif |
| } |
| |
| PVGetDefaultEncOption(&aEncOption, 0); |
| |
| for (i = 0; i < aEncParam->iNumLayer; i++) |
| { |
| aEncOption.encWidth[i] = iEncWidth[i] = aEncParam->iFrameWidth[i]; |
| aEncOption.encHeight[i] = iEncHeight[i] = aEncParam->iFrameHeight[i]; |
| aEncOption.encFrameRate[i] = iEncFrameRate[i] = aEncParam->iFrameRate[i]; |
| } |
| |
| if (aEncParam->iRateControlType == ECONSTANT_Q) |
| aEncOption.rcType = CONSTANT_Q; |
| else if (aEncParam->iRateControlType == ECBR_1) |
| aEncOption.rcType = CBR_1; |
| else if (aEncParam->iRateControlType == EVBR_1) |
| aEncOption.rcType = VBR_1; |
| else |
| return ECVEI_FAIL; |
| |
| // Check the bitrate, framerate, image size and buffer delay for 3GGP compliance |
| #ifdef FOR_3GPP_COMPLIANCE |
| Check3GPPCompliance(aEncParam, iEncWidth, iEncHeight); |
| #endif |
| |
| Int profile_level = (Int)ECVEI_CORE_LEVEL2; |
| if (aEncParam->iNumLayer > 1) profile_level = (Int)ECVEI_CORE_SCALABLE_LEVEL3; |
| |
| |
| aEncOption.encMode = ENC_Mode; |
| aEncOption.packetSize = aEncParam->iPacketSize; |
| aEncOption.profile_level = (ProfileLevelType)profile_level; |
| aEncOption.rvlcEnable = RvlcMode; |
| aEncOption.numLayers = aEncParam->iNumLayer; |
| aEncOption.timeIncRes = 1000; |
| aEncOption.tickPerSrc = (int)(1000 / aVidInFormat->iFrameRate + 0.5); |
| |
| for (i = 0; i < aEncParam->iNumLayer; i++) |
| { |
| aEncOption.bitRate[i] = aEncParam->iBitRate[i]; |
| aEncOption.iQuant[i] = aEncParam->iIquant[i]; |
| aEncOption.pQuant[i] = aEncParam->iPquant[i]; |
| aEncOption.quantType[i] = quantType[i]; /* default to H.263 */ |
| } |
| |
| aEncOption.vbvDelay = (float)aEncParam->iBufferDelay; |
| aEncOption.intraPeriod = aEncParam->iIFrameInterval; |
| aEncOption.numIntraMB = aEncParam->iNumIntraMBRefresh; |
| aEncOption.sceneDetect = (aEncParam->iSceneDetection == true) ? PV_ON : PV_OFF; |
| aEncOption.noFrameSkipped = (aEncParam->iNoFrameSkip == true) ? PV_ON : PV_OFF; |
| aEncOption.searchRange = aEncParam->iSearchRange; |
| aEncOption.mv8x8Enable = (aEncParam->iMV8x8 == true) ? PV_ON : PV_OFF; |
| |
| if (PV_FALSE == PVInitVideoEncoder(&iEncoderControl, &aEncOption)) |
| { |
| goto FAIL; |
| } |
| |
| iNextModTime = 0; |
| iInitialized = true; |
| return ECVEI_SUCCESS; |
| |
| FAIL: |
| iInitialized = false; |
| return ECVEI_FAIL; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF int32 CPVM4VEncoder::GetBufferSize() |
| { |
| Int bufSize = 0; |
| |
| //PVGetVBVSize(&iEncoderControl,&bufSize); |
| PVGetMaxVideoFrameSize(&iEncoderControl, &bufSize); |
| |
| return (int32) bufSize; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF int32 CPVM4VEncoder::GetEncodeWidth(int32 aLayer) |
| { |
| return (int32)iEncWidth[aLayer]; |
| } |
| |
| OSCL_EXPORT_REF int32 CPVM4VEncoder::GetEncodeHeight(int32 aLayer) |
| { |
| return (int32)iEncHeight[aLayer]; |
| } |
| |
| OSCL_EXPORT_REF float CPVM4VEncoder::GetEncodeFrameRate(int32 aLayer) |
| { |
| return iEncFrameRate[aLayer]; |
| } |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::GetVolHeader(uint8 *volHeader, int32 *size, int32 layer) |
| { |
| Int aSize, aLayer = layer; |
| |
| if (iInitialized == false) /* has to be initialized first */ |
| return ECVEI_FAIL; |
| |
| aSize = *size; |
| if (PVGetVolHeader(&iEncoderControl, (UChar*)volHeader, &aSize, aLayer) == PV_FALSE) |
| return ECVEI_FAIL; |
| |
| *size = aSize; |
| return ECVEI_SUCCESS; |
| } |
| |
| #ifdef PVAUTHOR_PROFILING |
| #include "pvauthorprofile.h" |
| #endif |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::EncodeFrame(TPVVideoInputData *aVidIn, TPVVideoOutputData *aVidOut |
| #ifdef PVAUTHOR_PROFILING |
| , void *aParam1 |
| #endif |
| ) |
| { |
| |
| Bool status; |
| Int Size; |
| Int nLayer = 0; |
| ULong modTime; |
| VideoEncFrameIO vid_in, vid_out; |
| |
| if (aVidIn->iTimeStamp >= iNextModTime) /* time to encode */ |
| { |
| iState = EIdle; /* stop current encoding */ |
| |
| Size = aVidOut->iBitStreamSize; |
| |
| #ifdef PVAUTHOR_PROFILING |
| if (aParam1)((CPVAuthorProfile*)aParam1)->Start(); |
| #endif |
| |
| if (iVideoFormat == ECVEI_YUV420) |
| #ifdef YUV_INPUT |
| { |
| if (iYUVIn) /* iSrcWidth or iSrcHeight is not multiple of 16 */ |
| { |
| CopyToYUVIn(aVidIn->iSource, iSrcWidth, iSrcHeight, |
| ((iSrcWidth + 15) >> 4) << 4, ((iSrcHeight + 15) >> 4) << 4); |
| iVideoIn = iYUVIn; |
| } |
| else /* otherwise, we can just use aVidIn->iSource */ |
| { |
| iVideoIn = aVidIn->iSource; // Sept 14, 2005 */ |
| } |
| } |
| #else |
| return ECVEI_FAIL; |
| #endif |
| else if (iVideoFormat == ECVEI_RGB12) |
| #ifdef RGB12_INPUT |
| { |
| RGB2YUV420_12bit((uint32 *)aVidIn->iSource, iSrcWidth, iSrcHeight, |
| ((iSrcWidth + 15) >> 4) << 4, ((iSrcHeight + 15) >> 4) << 4); |
| iVideoIn = iYUVIn; |
| } |
| #else |
| return ECVEI_FAIL; |
| #endif |
| |
| else if (iVideoFormat == ECVEI_RGB24) |
| #ifdef RGB24_INPUT |
| { |
| RGB2YUV420_24bit(aVidIn->iSource, iSrcWidth, iSrcHeight, |
| ((iSrcWidth + 15) >> 4) << 4, ((iSrcHeight + 15) >> 4) << 4); |
| iVideoIn = iYUVIn; |
| } |
| #else |
| return ECVEI_FAIL; |
| #endif |
| |
| #ifdef PVAUTHOR_PROFILING |
| if (aParam1)((CPVAuthorProfile*)aParam1)->Stop(CPVAuthorProfile::EColorInput); |
| #endif |
| |
| #ifdef PVAUTHOR_PROFILING |
| if (aParam1)((CPVAuthorProfile*)aParam1)->Start(); |
| #endif |
| |
| /* with backward-P or B-Vop this timestamp must be re-ordered */ |
| aVidOut->iExternalTimeStamp = aVidIn->iTimeStamp; |
| aVidOut->iVideoTimeStamp = aVidOut->iExternalTimeStamp; |
| |
| vid_in.height = ((iSrcHeight + 15) >> 4) << 4; |
| vid_in.pitch = ((iSrcWidth + 15) >> 4) << 4; |
| vid_in.timestamp = aVidIn->iTimeStamp; |
| vid_in.yChan = (UChar*)iVideoIn; |
| vid_in.uChan = (UChar*)(iVideoIn + vid_in.height * vid_in.pitch); |
| vid_in.vChan = vid_in.uChan + ((vid_in.height * vid_in.pitch) >> 2); |
| |
| status = PVEncodeVideoFrame(&iEncoderControl, |
| &vid_in, &vid_out, &modTime, (UChar*)aVidOut->iBitStream, &Size, &nLayer); |
| |
| if (status == PV_TRUE) |
| { |
| iNextModTime = modTime; |
| |
| aVidOut->iLayerNumber = nLayer; |
| aVidOut->iBitStreamSize = Size; |
| aVidOut->iFrame = iVideoOut = (uint8*)vid_out.yChan; |
| aVidOut->iVideoTimeStamp = vid_out.timestamp; |
| |
| PVGetHintTrack(&iEncoderControl, &aVidOut->iHintTrack); |
| |
| #ifdef PVAUTHOR_PROFILING |
| if (aParam1)((CPVAuthorProfile*)aParam1)->Stop(CPVAuthorProfile::EVideoEncode); |
| #endif |
| return ECVEI_SUCCESS; |
| } |
| else |
| return ECVEI_FAIL; |
| } |
| else /* if(aVidIn->iTimeStamp >= iNextModTime) */ |
| { |
| aVidOut->iLayerNumber = -1; |
| aVidOut->iBitStreamSize = 0; |
| #ifdef PVAUTHOR_PROFILING |
| if (aParam1)((CPVAuthorProfile*)aParam1)->AddVal |
| (CPVAuthorProfile::EVidSkip, iNextModTime - aVidIn->iTimeStamp); |
| #endif |
| return ECVEI_SUCCESS; |
| } |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::FlushOutput(TPVVideoOutputData *aVidOut) |
| { |
| OSCL_UNUSED_ARG(aVidOut); |
| return ECVEI_SUCCESS; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| TCVEI_RETVAL CPVM4VEncoder::Terminate() |
| { |
| iState = EIdle; /* stop current encoding */ |
| if (iInitialized == true) |
| { |
| PVCleanUpVideoEncoder(&iEncoderControl); |
| iInitialized = false; |
| |
| if (iYUVIn) |
| { |
| oscl_free(iYUVIn); |
| iYUVIn = NULL; |
| } |
| |
| #if defined(RGB12_INPUT)||defined(RGB24_INPUT) |
| if (iVideoFormat == ECVEI_RGB24 || iVideoFormat == ECVEI_RGB12) |
| freeRGB2YUVTables(); |
| #endif |
| } |
| return ECVEI_SUCCESS; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::UpdateBitRate(int32 aNumLayer, int32 *aBitRate) |
| { |
| #ifndef LIMITED_API |
| Int i, bitRate[2] = {0, 0}; |
| |
| for (i = 0; i < aNumLayer; i++) |
| { |
| bitRate[i] = aBitRate[i]; |
| } |
| |
| if (PVUpdateBitRate(&iEncoderControl, &bitRate[0]) == PV_TRUE) |
| return ECVEI_SUCCESS; |
| else |
| #endif |
| return ECVEI_FAIL; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::UpdateFrameRate(int32 aNumLayer, float *aFrameRate) |
| { |
| OSCL_UNUSED_ARG(aNumLayer); |
| #ifndef LIMITED_API |
| if (PVUpdateEncFrameRate(&iEncoderControl, aFrameRate) == PV_TRUE) |
| return ECVEI_SUCCESS; |
| else |
| #else |
| OSCL_UNUSED_ARG(aFrameRate); |
| #endif |
| return ECVEI_FAIL; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::UpdateIFrameInterval(int32 aIFrameInterval) |
| { |
| #ifndef LIMITED_API |
| if (PVUpdateIFrameInterval(&iEncoderControl, aIFrameInterval) == PV_TRUE) |
| return ECVEI_SUCCESS; |
| else |
| #endif |
| return ECVEI_FAIL; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::IFrameRequest() |
| { |
| #ifndef LIMITED_API |
| if (PVIFrameRequest(&iEncoderControl) == PV_TRUE) |
| return ECVEI_SUCCESS; |
| else |
| #endif |
| return ECVEI_FAIL; |
| } |
| |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| OSCL_EXPORT_REF TCVEI_RETVAL CPVM4VEncoder::SetIntraMBRefresh(int32 aNumMBRefresh) |
| { |
| #ifndef LIMITED_API |
| if (PVUpdateNumIntraMBRefresh(&iEncoderControl, aNumMBRefresh) == PV_TRUE) |
| return ECVEI_SUCCESS; |
| else |
| #endif |
| return ECVEI_FAIL; |
| } |
| |
| #ifdef YUV_INPUT |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| /* Copy from YUV input to YUV frame inside M4VEnc lib */ |
| /* When input is not YUV, the color conv will write it directly to iVideoInOut. */ |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| |
| void CPVM4VEncoder::CopyToYUVIn(uint8 *YUV, Int width, Int height, Int width_16, Int height_16) |
| { |
| UChar *y, *u, *v, *yChan, *uChan, *vChan; |
| Int y_ind, ilimit, jlimit, i, j, ioffset; |
| Int size = width * height; |
| Int size16 = width_16 * height_16; |
| |
| /* do padding at the bottom first */ |
| /* do padding if input RGB size(height) is different from the output YUV size(height_16) */ |
| if (height < height_16 || width < width_16) /* if padding */ |
| { |
| Int offset = (height < height_16) ? height : height_16; |
| |
| offset = (offset * width_16); |
| |
| if (width < width_16) |
| { |
| offset -= (width_16 - width); |
| } |
| |
| yChan = (UChar*)(iYUVIn + offset); |
| oscl_memset(yChan, 16, size16 - offset); /* pad with zeros */ |
| |
| uChan = (UChar*)(iYUVIn + size16 + (offset >> 2)); |
| oscl_memset(uChan, 128, (size16 - offset) >> 2); |
| |
| vChan = (UChar*)(iYUVIn + size16 + (size16 >> 2) + (offset >> 2)); |
| oscl_memset(vChan, 128, (size16 - offset) >> 2); |
| } |
| |
| /* then do padding on the top */ |
| yChan = (UChar*)iYUVIn; /* Normal order */ |
| uChan = (UChar*)(iYUVIn + size16); |
| vChan = (UChar*)(uChan + (size16 >> 2)); |
| |
| u = (UChar*)(&(YUV[size])); |
| v = (UChar*)(&(YUV[size*5/4])); |
| |
| /* To center the output */ |
| if (height_16 > height) /* output taller than input */ |
| { |
| if (width_16 >= width) /* output wider than or equal input */ |
| { |
| i = ((height_16 - height) >> 1) * width_16 + (((width_16 - width) >> 3) << 2); |
| /* make sure that (width_16-width)>>1 is divisible by 4 */ |
| j = ((height_16 - height) >> 2) * (width_16 >> 1) + (((width_16 - width) >> 4) << 2); |
| /* make sure that (width_16-width)>>2 is divisible by 4 */ |
| } |
| else /* output narrower than input */ |
| { |
| i = ((height_16 - height) >> 1) * width_16; |
| j = ((height_16 - height) >> 2) * (width_16 >> 1); |
| YUV += ((width - width_16) >> 1); |
| u += ((width - width_16) >> 2); |
| v += ((width - width_16) >> 2); |
| } |
| oscl_memset((uint8 *)yChan, 16, i); |
| yChan += i; |
| oscl_memset((uint8 *)uChan, 128, j); |
| uChan += j; |
| oscl_memset((uint8 *)vChan, 128, j); |
| vChan += j; |
| } |
| else /* output shorter or equal input */ |
| { |
| if (width_16 >= width) /* output wider or equal input */ |
| { |
| i = (((width_16 - width) >> 3) << 2); |
| /* make sure that (width_16-width)>>1 is divisible by 4 */ |
| j = (((width_16 - width) >> 4) << 2); |
| /* make sure that (width_16-width)>>2 is divisible by 4 */ |
| YUV += (((height - height_16) >> 1) * width); |
| u += (((height - height_16) >> 1) * width) >> 2; |
| v += (((height - height_16) >> 1) * width) >> 2; |
| } |
| else /* output narrower than input */ |
| { |
| i = 0; |
| j = 0; |
| YUV += (((height - height_16) >> 1) * width + ((width - width_16) >> 1)); |
| u += (((height - height_16) >> 1) * width + ((width - width_16) >> 1)) >> 2; |
| v += (((height - height_16) >> 1) * width + ((width - width_16) >> 1)) >> 2; |
| } |
| oscl_memset((uint8 *)yChan, 16, i); |
| yChan += i; |
| oscl_memset((uint8 *)uChan, 128, j); |
| uChan += j; |
| oscl_memset((uint8 *)vChan, 128, j); |
| vChan += j; |
| } |
| |
| /* Copy with cropping or zero-padding */ |
| if (height < height_16) |
| jlimit = height; |
| else |
| jlimit = height_16; |
| |
| if (width < width_16) |
| { |
| ilimit = width; |
| ioffset = width_16 - width; |
| } |
| else |
| { |
| ilimit = width_16; |
| ioffset = 0; |
| } |
| |
| /* Copy Y */ |
| /* Set up pointer for fast looping */ |
| y = (UChar*)YUV; |
| |
| if (width == width_16 && height == height_16) /* no need to pad */ |
| { |
| oscl_memcpy(yChan, y, size); |
| } |
| else |
| { |
| for (y_ind = 0; y_ind < (jlimit - 1) ;y_ind++) |
| { |
| oscl_memcpy(yChan, y, ilimit); |
| oscl_memset(yChan + ilimit, 16, ioffset); /* pad with zero */ |
| yChan += width_16; |
| y += width; |
| } |
| oscl_memcpy(yChan, y, ilimit); /* last line no padding */ |
| } |
| /* Copy U and V */ |
| /* Set up pointers for fast looping */ |
| if (width == width_16 && height == height_16) /* no need to pad */ |
| { |
| oscl_memcpy(uChan, u, size >> 2); |
| oscl_memcpy(vChan, v, size >> 2); |
| } |
| else |
| { |
| for (y_ind = 0; y_ind < (jlimit >> 1) - 1;y_ind++) |
| { |
| oscl_memcpy(uChan, u, ilimit >> 1); |
| oscl_memcpy(vChan, v, ilimit >> 1); |
| oscl_memset(uChan + (ilimit >> 1), 128, ioffset >> 1); |
| oscl_memset(vChan + (ilimit >> 1), 128, ioffset >> 1); |
| uChan += (width_16 >> 1); |
| u += (width >> 1); |
| vChan += (width_16 >> 1); |
| v += (width >> 1); |
| } |
| oscl_memcpy(uChan, u, ilimit >> 1); /* last line no padding */ |
| oscl_memcpy(vChan, v, ilimit >> 1); |
| } |
| |
| return ; |
| } |
| #endif |
| |
| #if defined(RGB12_INPUT) || defined(RGB24_INPUT) |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| /* The following four functions are for RGB->YUV, convert */ |
| /* RGB input(12bit/24bit) to YUV frame inside M4VEnc lib */ |
| /* ///////////////////////////////////////////////////////////////////////// */ |
| TCVEI_RETVAL CPVM4VEncoder::initRGB2YUVTables() |
| { |
| Int i; |
| uint16 *pTable; |
| |
| iY_Table = NULL; |
| iCb_Table = iCr_Table = ipCb_Table = ipCr_Table = NULL; |
| |
| /* memory allocation */ |
| if ((iY_Table = (uint8*)oscl_malloc(384)) == NULL) |
| return ECVEI_FAIL; |
| |
| if ((iCb_Table = (uint16*)oscl_malloc(768 * 2)) == NULL) |
| return ECVEI_FAIL; |
| |
| if ((iCr_Table = (uint16*)oscl_malloc(768 * 2)) == NULL) |
| return ECVEI_FAIL; |
| |
| #define pv_max(a, b) ((a) >= (b) ? (a) : (b)) |
| #define pv_min(a, b) ((a) <= (b) ? (a) : (b)) |
| |
| /* Table generation */ |
| for (i = 0; i < 384; i++) |
| iY_Table[i] = (uint8) pv_max(pv_min(255, (Int)(0.7152 * i + 16 + 0.5)), 0); |
| |
| pTable = iCb_Table + 384; |
| for (i = -384; i < 384; i++) |
| pTable[i] = (uint16) pv_max(pv_min(255, (Int)(0.386 * i + 128 + 0.5)), 0); |
| ipCb_Table = iCb_Table + 384; |
| |
| pTable = iCr_Table + 384; |
| for (i = -384; i < 384; i++) |
| pTable[i] = (uint16) pv_max(pv_min(255, (Int)(0.454 * i + 128 + 0.5)), 0); |
| ipCr_Table = iCr_Table + 384; |
| |
| return ECVEI_SUCCESS; |
| |
| } |
| |
| void CPVM4VEncoder::freeRGB2YUVTables() |
| { |
| if (iY_Table) oscl_free(iY_Table); |
| if (iCb_Table) oscl_free(iCb_Table); |
| if (iCr_Table) oscl_free(iCr_Table); |
| |
| iY_Table = NULL; |
| iCb_Table = iCr_Table = ipCb_Table = ipCr_Table = NULL; |
| |
| } |
| #endif |
| #ifdef RGB12_INPUT |
| #ifdef VERSION_0 |
| /* Assume B is in the first 4 bits, G is in the second 4 bits, and R is in the third 4 bits, of a whole 16bit unsigned integer */ |
| void CPVM4VEncoder::RGB2YUV420_12bit(uint16 *inputRGB, Int width, Int height, Int width_16, Int height_16) |
| { |
| Int i, j; |
| uint8 *tempY, *tempU, *tempV; |
| uint16 *inputRGB_prevRow = NULL; |
| |
| |
| tempY = iYUVIn; /* Normal order */ |
| tempU = iYUVIn + height_16 * width_16; |
| tempV = iYUVIn + height_16 * width_16 + (height_16 * width_16 >> 2); |
| |
| for (j = 0; j < height; j++) |
| { |
| for (i = 0; i < width; i++) |
| { |
| |
| *tempY++ = iY_Table[(6616*(inputRGB[i] << 4 & 0x00f0) + ((inputRGB[i] & 0x00f0) << 16) + 19481 * (inputRGB[i] >> 4 & 0x00f0)) >> 16]; |
| |
| /* downsampling U, V */ |
| if (j % 2 == 1 && i % 2 == 1) |
| { |
| |
| *tempU++ = (uint8)(ipCb_Table[(((inputRGB[i] << 4 & 0x00f0) << 16) - ((inputRGB[i] & 0x00f0) << 16) + |
| 19525 * ((inputRGB[i] << 4 & 0x00f0) - (inputRGB[i] >> 4 & 0x00f0))) >> 16] + /* bottom right(current) */ |
| |
| ipCb_Table[(((inputRGB[i-1] << 4 & 0x00f0) << 16) - ((inputRGB[i-1] & 0x00f0) << 16) + |
| 19525 * ((inputRGB[i-1] << 4 & 0x00f0) - (inputRGB[i-1] >> 4 & 0x00f0))) >> 16] + /* bottom left */ |
| |
| ipCb_Table[(((inputRGB_prevRow[i] << 4 & 0x00f0) << 16) - ((inputRGB_prevRow[i] & 0x00f0) << 16) + |
| 19525 * ((inputRGB_prevRow[i] << 4 & 0x00f0) - (inputRGB_prevRow[i] >> 4 & 0x00f0))) >> 16] + /* top right */ |
| |
| ipCb_Table[(((inputRGB_prevRow[i-1] << 4 & 0x00f0) << 16) - ((inputRGB_prevRow[i-1] & 0x00f0) << 16) + |
| 19525 * ((inputRGB_prevRow[i-1] << 4 & 0x00f0) - (inputRGB_prevRow[i-1] >> 4 & 0x00f0))) >> 16] + /* top left */ |
| |
| 2 >> 2); |
| |
| |
| *tempV++ = (uint8)(ipCr_Table[(((inputRGB[i] >> 4 & 0x00f0) << 16) - ((inputRGB[i] & 0x00f0) << 16) + |
| 6640 * ((inputRGB[i] >> 4 & 0x00f0) - (inputRGB[i] << 4 & 0x00f0))) >> 16] + /* bottom right(current) */ |
| |
| ipCr_Table[(((inputRGB[i-1] >> 4 & 0x00f0) << 16) - ((inputRGB[i-1] & 0x00f0) << 16) + |
| 6640 * ((inputRGB[i-1] >> 4 & 0x00f0) - (inputRGB[i-1] << 4 & 0x00f0))) >> 16] + /* bottom left */ |
| |
| ipCr_Table[(((inputRGB_prevRow[i] >> 4 & 0x00f0) << 16) - ((inputRGB_prevRow[i] & 0x00f0) << 16) + |
| 6640 * ((inputRGB_prevRow[i] >> 4 & 0x00f0) - (inputRGB_prevRow[i] << 4 & 0x00f0))) >> 16] + /* top right */ |
| |
| ipCr_Table[(((inputRGB_prevRow[i-1] >> 4 & 0x00f0) << 16) - ((inputRGB_prevRow[i-1] & 0x00f0) << 16) + |
| 6640 * ((inputRGB_prevRow[i-1] >> 4 & 0x00f0) - (inputRGB_prevRow[i-1] << 4 & 0x00f0))) >> 16] + /* top left */ |
| |
| 2 >> 2); |
| } |
| } |
| |
| /* do padding if input RGB size(width) is different from the output YUV size(width_16) */ |
| if (width < width_16) |
| { |
| oscl_memset(tempY, *(tempY - 1), width_16 - width); |
| tempY += (width_16 - width); |
| |
| if (j % 2 == 1) |
| { |
| oscl_memset(tempU, *(tempU - 1), (width_16 - width) >> 1); |
| tempU += (width_16 - width) >> 1; |
| oscl_memset(tempV, *(tempV - 1), (width_16 - width) >> 1); |
| tempV += (width_16 - width) >> 1; |
| } |
| } |
| |
| inputRGB_prevRow = inputRGB; |
| inputRGB += width; /* move to the next row */ |
| } |
| |
| /* do padding if input RGB size(height) is different from the output YUV size(height_16) */ |
| if (height < height_16) |
| { |
| tempY = iYUVIn + height * width_16; |
| tempU = tempY - width_16;/* tempU is for temporary use, not meaning U stuff */ |
| for (i = height; i < height_16; i++) |
| { |
| oscl_memcpy(tempY, tempU, width_16); |
| tempY += width_16; |
| } |
| |
| tempU = iYUVIn + height_16 * width_16 + (height * width_16 >> 2); |
| tempV = tempU - (width_16 >> 1); /* tempV is for temporary use, not meaning V stuff */ |
| for (i = height >> 1; i<height_16 >> 1; i++) |
| { |
| oscl_memcpy(tempU, tempV, (width_16 >> 1)); |
| tempU += (width_16 >> 1); |
| } |
| |
| tempV = iYUVIn + height_16 * width_16 + (height_16 * width_16 >> 2) + (height * width_16 >> 2); |
| tempY = tempV - (width_16 >> 1); /* tempY is for temporary use, not meaning Y stuff */ |
| for (i = height >> 1; i<height_16 >> 1; i++) |
| { |
| oscl_memcpy(tempV, tempY, (width_16 >> 1)); |
| tempV += (width_16 >> 1); |
| } |
| |
| } |
| |
| } |
| #endif |
| |
| /* Assume width is divisible by 8 */ |
| void CPVM4VEncoder::RGB2YUV420_12bit( |
| uint32 *inputRGB, |
| Int width, |
| Int height, |
| Int width_16, |
| Int height_16) |
| { |
| Int i; |
| Int j; |
| Int ilimit; |
| Int jlimit; |
| uint32 *tempY; |
| uint32 *tempU; |
| uint32 *tempV; |
| uint32 pixels; |
| uint32 pixels_nextRow; |
| uint32 yuv_value; |
| uint32 yuv_value1; |
| uint32 yuv_value2; |
| Int R_ds; /* "_ds" is the downsample version */ |
| Int G_ds; /* "_ds" is the downsample version */ |
| Int B_ds; /* "_ds" is the downsample version */ |
| Int adjust = (width >> 1); |
| Int size16 = height_16 * width_16; |
| Int tmp; |
| uint32 temp; |
| |
| /* do padding at the bottom first */ |
| /* do padding if input RGB size(height) is different from the output YUV size(height_16) */ |
| if (height < height_16 || width < width_16) |
| { /* if padding */ |
| Int offset = (height < height_16) ? height : height_16; |
| |
| offset = (offset * width_16); |
| |
| if (width < width_16) |
| { |
| offset -= (width_16 - width); |
| } |
| |
| tempY = (uint32 *)iYUVIn + (offset >> 2); |
| oscl_memset((uint8 *)tempY, 16, size16 - offset); /* pad with zeros */ |
| |
| tempU = (uint32 *)iYUVIn + (size16 >> 2) + (offset >> 4); |
| oscl_memset((uint8 *)tempU, 128, (size16 - offset) >> 2); |
| |
| tempV = (uint32 *)iYUVIn + (size16 >> 2) + (size16 >> 4) + (offset >> 4); |
| oscl_memset((uint8 *)tempV, 128, (size16 - offset) >> 2); |
| } |
| |
| /* then do padding on the top */ |
| tempY = (uint32 *)iYUVIn; /* Normal order */ |
| tempU = tempY + ((size16) >> 2); |
| tempV = tempU + ((size16) >> 4); |
| |
| /* To center the output */ |
| if (height_16 > height) |
| { |
| if (width_16 >= width) |
| { |
| i = ((height_16 - height) >> 1) * width_16 + (((width_16 - width) >> 3) << 2); |
| /* make sure that (width_16-width)>>1 is divisible by 4 */ |
| j = ((height_16 - height) >> 2) * (width_16 >> 1) + (((width_16 - width) >> 4) << 2); |
| /* make sure that (width_16-width)>>2 is divisible by 4 */ |
| } |
| else |
| { |
| i = ((height_16 - height) >> 1) * width_16; |
| j = ((height_16 - height) >> 2) * (width_16 >> 1); |
| inputRGB += (width - width_16) >> 2; |
| } |
| oscl_memset((uint8 *)tempY, 16, i); |
| tempY += (i >> 2); |
| oscl_memset((uint8 *)tempU, 128, j); |
| tempU += (j >> 2); |
| oscl_memset((uint8 *)tempV, 128, j); |
| tempV += (j >> 2); |
| } |
| else |
| { |
| if (width_16 >= width) |
| { |
| i = (((width_16 - width) >> 3) << 2); |
| /* make sure that (width_16-width)>>1 is divisible by 4 */ |
| j = (((width_16 - width) >> 4) << 2); |
| /* make sure that (width_16-width)>>2 is divisible by 4 */ |
| inputRGB += (((height - height_16) >> 1) * width) >> 1; |
| |
| oscl_memset((uint8 *)tempY, 16, i); |
| tempY += (i >> 2); |
| oscl_memset((uint8 *)tempU, 128, j); |
| tempU += (j >> 2); |
| oscl_memset((uint8 *)tempV, 128, j); |
| tempV += (j >> 2); |
| |
| } |
| else |
| { |
| i = 0; |
| j = 0; |
| inputRGB += (((height - height_16) >> 1) * width + ((width - width_16) >> 1)) >> 1 ; |
| } |
| } |
| |
| /* ColorConv RGB12-to-YUV420 with cropping or zero-padding */ |
| if (height < height_16) |
| { |
| jlimit = height; |
| } |
| else |
| { |
| jlimit = height_16; |
| } |
| |
| if (width < width_16) |
| { |
| ilimit = width >> 1; |
| } |
| else |
| { |
| ilimit = width_16 >> 1; |
| } |
| |
| width = width_16 - width; |
| |
| |
| for (j = 0; j < jlimit; j++) |
| { |
| |
| for (i = 0; i < ilimit; i += 4) |
| { |
| pixels = inputRGB[i]; |
| temp = (827 * (pixels & 0x000F000F) + 2435 * ((pixels & 0x0F000F00) >> 8)); |
| yuv_value = (iY_Table[((temp&0x0FFFF)>> 9) + (pixels & 0x000000F0)] | |
| (iY_Table[(temp >>25) + ((pixels & 0x00F00000)>>16)] << 8)); |
| |
| pixels = inputRGB[i+1]; |
| temp = (827 * (pixels & 0x000F000F) + 2435 * ((pixels & 0x0F000F00) >> 8)); |
| *tempY++ = (yuv_value | |
| (iY_Table[((temp&0x0FFFF)>> 9) + (pixels & 0x000000F0)] | |
| (iY_Table[(temp >>25) + ((pixels & 0x00F00000)>>16)] << 8)) << 16); |
| |
| pixels = inputRGB[i+2]; |
| temp = (827 * (pixels & 0x000F000F) + 2435 * ((pixels & 0x0F000F00) >> 8)); |
| yuv_value = (iY_Table[((temp&0x0FFFF)>> 9) + (pixels & 0x000000F0)] | |
| (iY_Table[(temp >>25) + ((pixels & 0x00F00000)>>16)] << 8)); |
| |
| pixels = inputRGB[i+3]; |
| temp = (827 * (pixels & 0x000F000F) + 2435 * ((pixels & 0x0F000F00) >> 8)); |
| *tempY++ = (yuv_value | |
| (iY_Table[((temp&0x0FFFF)>> 9) + (pixels & 0x000000F0)] | |
| (iY_Table[(temp >>25) + ((pixels & 0x00F00000)>>16)] << 8)) << 16); |
| |
| |
| /* downsampling U, V */ |
| |
| pixels_nextRow = inputRGB[i+3+adjust/*(width>>1)*/]; |
| G_ds = pixels & 0x00F000F0; |
| G_ds += (pixels_nextRow & 0x00F000F0); |
| G_ds += (G_ds >> 16); |
| |
| G_ds -= 2; /* equivalent to adding constant 2<<16 = 131072 */ |
| |
| pixels &= 0x0F0F0F0F; |
| pixels += (pixels_nextRow & 0x0F0F0F0F); |
| |
| pixels += (pixels >> 16); |
| |
| B_ds = (pixels & 0x0003F) << 4; |
| |
| R_ds = (pixels & 0x03F00) >> 4; |
| |
| tmp = B_ds - R_ds; |
| |
| yuv_value1 = ipCb_Table[(((B_ds-G_ds)<<16) + 19525*tmp)>>18] << 24; |
| yuv_value2 = ipCr_Table[(((R_ds-G_ds)<<16) - 6640*tmp)>>18] << 24; |
| |
| pixels = inputRGB[i+2]; |
| pixels_nextRow = inputRGB[i+2+adjust/*(width>>1)*/]; |
| |
| G_ds = pixels & 0x00F000F0; |
| G_ds += (pixels_nextRow & 0x00F000F0); |
| G_ds += (G_ds >> 16); |
| |
| G_ds -= 2; /* equivalent to adding constant 2<<16 = 131072 */ |
| |
| pixels &= 0x0F0F0F0F; |
| pixels += (pixels_nextRow & 0x0F0F0F0F); |
| |
| pixels += (pixels >> 16); |
| |
| B_ds = (pixels & 0x0003F) << 4; |
| |
| R_ds = (pixels & 0x03F00) >> 4; |
| tmp = B_ds - R_ds; |
| |
| yuv_value1 |= ipCb_Table[(((B_ds-G_ds)<<16) + 19525*tmp)>>18] << 16; |
| yuv_value2 |= ipCr_Table[(((R_ds-G_ds)<<16) - 6640*tmp)>>18] << 16; |
| |
| pixels = inputRGB[i+1]; |
| pixels_nextRow = inputRGB[i+1+adjust /*(width>>1)*/]; |
| |
| G_ds = pixels & 0x00F000F0; |
| G_ds += (pixels_nextRow & 0x00F000F0); |
| G_ds += (G_ds >> 16); |
| |
| G_ds -= 2; /* equivalent to adding constant 2<<16 = 131072 */ |
| |
| pixels &= 0x0F0F0F0F; |
| pixels += (pixels_nextRow & 0x0F0F0F0F); |
| |
| pixels += (pixels >> 16); |
| |
| B_ds = (pixels & 0x0003F) << 4; |
| |
| R_ds = (pixels & 0x03F00) >> 4; |
| tmp = B_ds - R_ds; |
| |
| |
| yuv_value1 |= ipCb_Table[(((B_ds-G_ds)<<16) + 19525*tmp)>>18] << 8; |
| yuv_value2 |= ipCr_Table[(((R_ds-G_ds)<<16) - 6640*tmp)>>18] << 8; |
| |
| pixels = inputRGB[i]; |
| pixels_nextRow = inputRGB[i+adjust/*(width>>1)*/]; |
| |
| G_ds = pixels & 0x00F000F0; |
| G_ds += (pixels_nextRow & 0x00F000F0); |
| G_ds += (G_ds >> 16); |
| |
| G_ds -= 2; /* equivalent to adding constant 2<<16 = 131072 */ |
| |
| pixels &= 0x0F0F0F0F; |
| pixels += (pixels_nextRow & 0x0F0F0F0F); |
| |
| pixels += (pixels >> 16); |
| |
| B_ds = (pixels & 0x0003F) << 4; |
| |
| R_ds = (pixels & 0x03F00) >> 4; |
| tmp = B_ds - R_ds; |
| |
| *tempU++ = yuv_value1 | (ipCb_Table[(((B_ds-G_ds)<<16) + 19525*tmp)>>18]); |
| *tempV++ = yuv_value2 | (ipCr_Table[(((R_ds-G_ds)<<16) - 6640*tmp)>>18]); |
| } |
| |
| /* do padding if input RGB size(width) is different from the output YUV size(width_16) */ |
| |
| if ((width > 0) && j < jlimit - 1) |
| { |
| oscl_memset((uint8 *)tempY, 16/*(*(tempY-1))>>24*/, width); |
| tempY += width >> 2; |
| oscl_memset((uint8 *)tempU, 128/*(*(tempU-1))>>24*/, width >> 1); |
| tempU += width >> 3; |
| oscl_memset((uint8 *)tempV, 128/*(*(tempV-1))>>24*/, width >> 1); |
| tempV += width >> 3; |
| } |
| |
| if (j++ == (jlimit - 1)) |
| { |
| break; /* dealing with a odd height */ |
| } |
| |
| inputRGB += adjust; /* (160/2 = 80 ) */ /*(width>>1)*/; /* move to the next row */ |
| |
| for (i = 0; i < ilimit; i += 4) |
| { |
| pixels = inputRGB[i]; |
| temp = (827 * (pixels & 0x000F000F) + 2435 * ((pixels & 0x0F000F00) >> 8)); |
| yuv_value = (iY_Table[((temp&0x0FFFF)>> 9) + (pixels & 0x000000F0)] | |
| (iY_Table[(temp >>25) + ((pixels & 0x00F00000)>>16)] << 8)); |
| |
| pixels = inputRGB[i+1]; |
| temp = (827 * (pixels & 0x000F000F) + 2435 * ((pixels & 0x0F000F00) >> 8)); |
| *tempY++ = (yuv_value | |
| (iY_Table[((temp&0x0FFFF)>> 9) + (pixels & 0x000000F0)] | |
| (iY_Table[(temp >>25) + ((pixels & 0x00F00000)>>16)] << 8)) << 16); |
| |
| pixels = inputRGB[i+2]; |
| temp = (827 * (pixels & 0x000F000F) + 2435 * ((pixels & 0x0F000F00) >> 8)); |
| yuv_value = (iY_Table[((temp&0x0FFFF)>> 9) + (pixels & 0x000000F0)] | |
| (iY_Table[(temp >>25) + ((pixels & 0x00F00000)>>16)] << 8)); |
| |
| pixels = inputRGB[i+3]; |
| temp = (827 * (pixels & 0x000F000F) + 2435 * ((pixels & 0x0F000F00) >> 8)); |
| *tempY++ = (yuv_value | |
| (iY_Table[((temp&0x0FFFF)>> 9) + (pixels & 0x000000F0)] | |
| (iY_Table[(temp >>25) + ((pixels & 0x00F00000)>>16)] << 8)) << 16); |
| |
| } |
| |
| /* do padding if input RGB size(width) is different from the output YUV size(width_16) */ |
| if ((width > 0) && j < jlimit - 1) |
| { |
| oscl_memset((uint8 *)tempY, 16/*(*(tempY-1))>>24*/, width); |
| tempY += width >> 2; |
| } |
| |
| inputRGB += adjust; /* (160/2 = 80 ) */ /*(width>>1)*/; /* move to the next row */ |
| |
| } /* for(j=0; j<jlimit; j++)*/ |
| } |
| #endif |
| #ifdef RGB24_INPUT |
| /* Assume B is in the first byte, G is in the second byte, and R is in the third byte, of a whole 3-octct group */ |
| void CPVM4VEncoder::RGB2YUV420_24bit(uint8 *inputRGB, Int width, Int height, Int width_16, Int height_16) |
| { |
| Int i, j, ilimit, jlimit; |
| uint8 *tempY, *tempU, *tempV; |
| uint8 *inputRGB_prevRow = NULL; |
| int32 size16 = height_16 * width_16; |
| int32 adjust = (width + (width << 1)); |
| |
| /* do padding at the bottom first */ |
| /* do padding if input RGB size(height) is different from the output YUV size(height_16) */ |
| if (height < height_16 || width < width_16) /* if padding */ |
| { |
| Int offset = (height < height_16) ? height : height_16; |
| |
| offset = (offset * width_16); |
| |
| if (width < width_16) |
| { |
| offset -= (width_16 - width); |
| } |
| tempY = iYUVIn + offset; |
| oscl_memset((uint8 *)tempY, 16, size16 - offset); /* pad with zeros */ |
| |
| tempU = iYUVIn + size16 + (offset >> 2); |
| oscl_memset((uint8 *)tempU, 128, (size16 - offset) >> 2); |
| |
| tempV = iYUVIn + size16 + (size16 >> 2) + (offset >> 2); |
| oscl_memset((uint8 *)tempV, 128, (size16 - offset) >> 2); |
| } |
| |
| /* then do padding on the top */ |
| tempY = iYUVIn; /* Normal order */ |
| tempU = iYUVIn + size16; |
| tempV = tempU + (size16 >> 2); |
| |
| /* To center the output */ |
| if (height_16 > height) |
| { |
| if (width_16 >= width) |
| { |
| i = ((height_16 - height) >> 1) * width_16 + (((width_16 - width) >> 3) << 2); |
| /* make sure that (width_16-width)>>1 is divisible by 4 */ |
| j = ((height_16 - height) >> 2) * (width_16 >> 1) + (((width_16 - width) >> 4) << 2); |
| /* make sure that (width_16-width)>>2 is divisible by 4 */ |
| } |
| else |
| { |
| i = ((height_16 - height) >> 1) * width_16; |
| j = ((height_16 - height) >> 2) * (width_16 >> 1); |
| inputRGB += ((width - width_16) >> 1) * 3; |
| } |
| oscl_memset((uint8 *)tempY, 16, i); |
| tempY += i; |
| oscl_memset((uint8 *)tempU, 128, j); |
| tempU += j; |
| oscl_memset((uint8 *)tempV, 128, j); |
| tempV += j; |
| } |
| else |
| { |
| if (width_16 >= width) |
| { |
| i = (((width_16 - width) >> 3) << 2); |
| /* make sure that (width_16-width)>>1 is divisible by 4 */ |
| j = (((width_16 - width) >> 4) << 2); |
| /* make sure that (width_16-width)>>2 is divisible by 4 */ |
| inputRGB += (((height - height_16) >> 1) * width) * 3; |
| } |
| else |
| { |
| i = 0; |
| j = 0; |
| inputRGB += (((height - height_16) >> 1) * width + ((width - width_16) >> 1)) * 3; |
| } |
| oscl_memset((uint8 *)tempY, 16, i); |
| tempY += i; |
| oscl_memset((uint8 *)tempU, 128, j); |
| tempU += j; |
| oscl_memset((uint8 *)tempV, 128, j); |
| tempV += j; |
| } |
| |
| /* ColorConv RGB24-to-YUV420 with cropping or zero-padding */ |
| if (height < height_16) |
| jlimit = height; |
| else |
| jlimit = height_16; |
| |
| if (width < width_16) |
| ilimit = width; |
| else |
| ilimit = width_16; |
| |
| if (iFrameOrientation > 0) |
| { |
| inputRGB += (jlimit - 1) * width * 3 ; // move to last row |
| adjust = -adjust; |
| } |
| |
| |
| for (j = 0; j < jlimit; j++) |
| { |
| for (i = 0; i < ilimit*3; i += 3) |
| { |
| |
| *tempY++ = iY_Table[(6616*inputRGB[i] + (inputRGB[i+1] << 16) + 19481 * inputRGB[i+2]) >> 16]; |
| |
| /* downsampling U, V */ |
| if (j % 2 == 1 && i % 2 == 1) |
| { |
| |
| *tempU++ = (unsigned char)((ipCb_Table[((inputRGB[i] << 16) - (inputRGB[i+1] << 16) + 19525 * (inputRGB[i] - inputRGB[i+2])) >> 16] + /* bottom right(current) */ |
| ipCb_Table[((inputRGB[i-3] << 16) - (inputRGB[i-2] << 16) + 19525 * (inputRGB[i-3] - inputRGB[i-1])) >> 16] + /* bottom left */ |
| ipCb_Table[((inputRGB_prevRow[i] << 16) - (inputRGB_prevRow[i+1] << 16) + 19525 * (inputRGB_prevRow[i] - inputRGB_prevRow[i+2])) >> 16] + /* top right */ |
| ipCb_Table[((inputRGB_prevRow[i-3] << 16) - (inputRGB_prevRow[i-2] << 16) + 19525 * (inputRGB_prevRow[i-3] - inputRGB_prevRow[i-1])) >> 16] + /* top left */ |
| 2) >> 2); |
| |
| |
| *tempV++ = (unsigned char)((ipCr_Table[((inputRGB[i+2] << 16) - (inputRGB[i+1] << 16) + 6640 * (inputRGB[i+2] - inputRGB[i])) >> 16] + /* bottom right(current) */ |
| ipCr_Table[((inputRGB[i-1] << 16) - (inputRGB[i-2] << 16) + 6640 * (inputRGB[i-1] - inputRGB[i-3])) >> 16] + /* bottom left */ |
| ipCr_Table[((inputRGB_prevRow[i+2] << 16) - (inputRGB_prevRow[i+1] << 16) + 6640 * (inputRGB_prevRow[i+2] - inputRGB_prevRow[i])) >> 16] + /* top right */ |
| ipCr_Table[((inputRGB_prevRow[i-1] << 16) - (inputRGB_prevRow[i-2] << 16) + 6640 * (inputRGB_prevRow[i-1] - inputRGB_prevRow[i-3])) >> 16] + /* top left */ |
| 2) >> 2); |
| |
| } |
| } |
| |
| /* do padding if input RGB size(width) is different from the output YUV size(width_16) */ |
| if (width < width_16 && j < jlimit - 1) |
| { |
| oscl_memset(tempY, 16/* *(tempY-1)*/, width_16 - width); |
| tempY += (width_16 - width); |
| |
| if (j % 2 == 1) |
| { |
| oscl_memset(tempU, 128/* *(tempU-1)*/, (width_16 - width) >> 1); |
| tempU += (width_16 - width) >> 1; |
| oscl_memset(tempV, 128/* *(tempV-1)*/, (width_16 - width) >> 1); |
| tempV += (width_16 - width) >> 1; |
| } |
| } |
| |
| inputRGB_prevRow = inputRGB; |
| inputRGB += adjust ; /* move to the next row */ |
| } |
| |
| } |
| #endif |
| |
| #ifdef FOR_3GPP_COMPLIANCE |
| void CPVM4VEncoder::Check3GPPCompliance(TPVVideoEncodeParam *aEncParam, Int *aEncWidth, Int *aEncHeight) |
| { |
| |
| //MPEG-4 Simple profile and level 0 |
| #define MAX_BITRATE 64000 |
| #define MAX_FRAMERATE 15 |
| #define MAX_WIDTH 176 |
| #define MAX_HEIGHT 144 |
| #define MAX_BUFFERSIZE 163840 |
| |
| // check bitrate, framerate, video size and vbv buffer |
| if (aEncParam->iBitRate[0] > MAX_BITRATE) aEncParam->iBitRate[0] = MAX_BITRATE; |
| if (aEncParam->iFrameRate[0] > MAX_FRAMERATE) aEncParam->iFrameRate[0] = MAX_FRAMERATE; |
| if (aEncWidth[0] > MAX_WIDTH) aEncWidth[0] = MAX_WIDTH; |
| if (aEncHeight[0] > MAX_HEIGHT) aEncHeight[0] = MAX_HEIGHT; |
| if (aEncParam->iBitRate[0]*aEncParam->iBufferDelay > MAX_BUFFERSIZE) |
| aEncParam->iBufferDelay = (float)MAX_BUFFERSIZE / aEncParam->iBitRate[0]; |
| } |
| #endif |
| |
