| /* |
| * Copyright (c) 2009-2011 Intel Corporation. All rights reserved. |
| * |
| * 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. |
| */ |
| |
| #include <string.h> |
| #include <stdlib.h> |
| #include "VideoEncoderLog.h" |
| #include "VideoEncoderAVC.h" |
| #include <va/va_tpi.h> |
| #include <va/va_enc_h264.h> |
| #include <bitstream.h> |
| |
| VideoEncoderAVC::VideoEncoderAVC() |
| :VideoEncoderBase() { |
| if(VideoEncoderBase::queryProfileLevelConfig(mVADisplay, VAProfileH264High) == ENCODE_SUCCESS){ |
| mComParams.profile = VAProfileH264High; |
| mComParams.level = 42; |
| }else if(VideoEncoderBase::queryProfileLevelConfig(mVADisplay, VAProfileH264Main) == ENCODE_SUCCESS){ |
| mComParams.profile = VAProfileH264Main; |
| mComParams.level = 41; |
| } |
| mVideoParamsAVC.basicUnitSize = 0; |
| mVideoParamsAVC.VUIFlag = 0; |
| mVideoParamsAVC.sliceNum.iSliceNum = 2; |
| mVideoParamsAVC.sliceNum.pSliceNum = 2; |
| mVideoParamsAVC.idrInterval = 2; |
| mVideoParamsAVC.ipPeriod = 1; |
| mVideoParamsAVC.maxSliceSize = 0; |
| mVideoParamsAVC.delimiterType = AVC_DELIMITER_ANNEXB; |
| mSliceNum = 2; |
| mVideoParamsAVC.crop.LeftOffset = 0; |
| mVideoParamsAVC.crop.RightOffset = 0; |
| mVideoParamsAVC.crop.TopOffset = 0; |
| mVideoParamsAVC.crop.BottomOffset = 0; |
| mVideoParamsAVC.SAR.SarWidth = 0; |
| mVideoParamsAVC.SAR.SarHeight = 0; |
| mVideoParamsAVC.bEntropyCodingCABAC = 0; |
| mVideoParamsAVC.bWeightedPPrediction = 0; |
| mVideoParamsAVC.bDirect8x8Inference = 0; |
| mVideoParamsAVC.bConstIpred = 0; |
| mAutoReferenceSurfaceNum = 4; |
| |
| packed_seq_header_param_buf_id = VA_INVALID_ID; |
| packed_seq_buf_id = VA_INVALID_ID; |
| packed_pic_header_param_buf_id = VA_INVALID_ID; |
| packed_pic_buf_id = VA_INVALID_ID; |
| packed_sei_header_param_buf_id = VA_INVALID_ID; /* the SEI buffer */ |
| packed_sei_buf_id = VA_INVALID_ID; |
| } |
| |
| Encode_Status VideoEncoderAVC::start() { |
| |
| Encode_Status ret = ENCODE_SUCCESS; |
| LOG_V( "Begin\n"); |
| |
| if (mComParams.rcMode == VA_RC_VCM) { |
| // If we are in VCM, we will set slice num to max value |
| // mVideoParamsAVC.sliceNum.iSliceNum = (mComParams.resolution.height + 15) / 16; |
| // mVideoParamsAVC.sliceNum.pSliceNum = mVideoParamsAVC.sliceNum.iSliceNum; |
| } |
| |
| ret = VideoEncoderBase::start (); |
| CHECK_ENCODE_STATUS_RETURN("VideoEncoderBase::start"); |
| |
| LOG_V( "end\n"); |
| return ret; |
| } |
| |
| Encode_Status VideoEncoderAVC::derivedSetParams(VideoParamConfigSet *videoEncParams) { |
| |
| CHECK_NULL_RETURN_IFFAIL(videoEncParams); |
| VideoParamsAVC *encParamsAVC = reinterpret_cast <VideoParamsAVC *> (videoEncParams); |
| |
| // AVC parames |
| if (encParamsAVC->size != sizeof (VideoParamsAVC)) { |
| return ENCODE_INVALID_PARAMS; |
| } |
| |
| if(encParamsAVC->ipPeriod == 0 || encParamsAVC->ipPeriod >4) |
| return ENCODE_INVALID_PARAMS; |
| |
| if((mComParams.intraPeriod >1)&&(mComParams.intraPeriod % encParamsAVC->ipPeriod !=0)) |
| return ENCODE_INVALID_PARAMS; |
| |
| mVideoParamsAVC = *encParamsAVC; |
| if(mComParams.profile == VAProfileH264Baseline){ |
| mVideoParamsAVC.bEntropyCodingCABAC = 0; |
| mVideoParamsAVC.bDirect8x8Inference = 0; |
| mVideoParamsAVC.bWeightedPPrediction = 0; |
| } |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC:: derivedGetParams(VideoParamConfigSet *videoEncParams) { |
| |
| CHECK_NULL_RETURN_IFFAIL(videoEncParams); |
| VideoParamsAVC *encParamsAVC = reinterpret_cast <VideoParamsAVC *> (videoEncParams); |
| |
| // AVC parames |
| if (encParamsAVC->size != sizeof (VideoParamsAVC)) { |
| return ENCODE_INVALID_PARAMS; |
| } |
| |
| *encParamsAVC = mVideoParamsAVC; |
| return ENCODE_SUCCESS; |
| |
| } |
| |
| Encode_Status VideoEncoderAVC::derivedSetConfig(VideoParamConfigSet *videoEncConfig) { |
| |
| CHECK_NULL_RETURN_IFFAIL(videoEncConfig); |
| LOG_V("Config type = %d\n", (int)videoEncConfig->type); |
| |
| switch (videoEncConfig->type) { |
| case VideoConfigTypeAVCIntraPeriod: { |
| |
| VideoConfigAVCIntraPeriod *configAVCIntraPeriod = |
| reinterpret_cast <VideoConfigAVCIntraPeriod *> (videoEncConfig); |
| // Config Intra Peroid |
| if (configAVCIntraPeriod->size != sizeof (VideoConfigAVCIntraPeriod)) { |
| return ENCODE_INVALID_PARAMS; |
| } |
| |
| if(configAVCIntraPeriod->ipPeriod == 0 || configAVCIntraPeriod->ipPeriod >4) |
| return ENCODE_INVALID_PARAMS; |
| if((configAVCIntraPeriod->intraPeriod >1)&&(configAVCIntraPeriod->intraPeriod % configAVCIntraPeriod->ipPeriod !=0)) |
| return ENCODE_INVALID_PARAMS; |
| |
| mVideoParamsAVC.idrInterval = configAVCIntraPeriod->idrInterval; |
| mVideoParamsAVC.ipPeriod = configAVCIntraPeriod->ipPeriod; |
| mComParams.intraPeriod = configAVCIntraPeriod->intraPeriod; |
| mNewHeader = true; |
| break; |
| } |
| case VideoConfigTypeNALSize: { |
| // Config MTU |
| VideoConfigNALSize *configNALSize = |
| reinterpret_cast <VideoConfigNALSize *> (videoEncConfig); |
| if (configNALSize->size != sizeof (VideoConfigNALSize)) { |
| return ENCODE_INVALID_PARAMS; |
| } |
| |
| mVideoParamsAVC.maxSliceSize = configNALSize->maxSliceSize; |
| mRenderMaxSliceSize = true; |
| break; |
| } |
| case VideoConfigTypeIDRRequest: { |
| if(mVideoParamsAVC.ipPeriod >1) |
| return ENCODE_FAIL; |
| else |
| mNewHeader = true; |
| break; |
| } |
| case VideoConfigTypeSliceNum: { |
| |
| VideoConfigSliceNum *configSliceNum = |
| reinterpret_cast <VideoConfigSliceNum *> (videoEncConfig); |
| // Config Slice size |
| if (configSliceNum->size != sizeof (VideoConfigSliceNum)) { |
| return ENCODE_INVALID_PARAMS; |
| } |
| |
| mVideoParamsAVC.sliceNum = configSliceNum->sliceNum; |
| break; |
| } |
| default: { |
| LOG_E ("Invalid Config Type"); |
| break; |
| } |
| } |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC:: derivedGetConfig( |
| VideoParamConfigSet *videoEncConfig) { |
| |
| CHECK_NULL_RETURN_IFFAIL(videoEncConfig); |
| LOG_V("Config type = %d\n", (int)videoEncConfig->type); |
| |
| switch (videoEncConfig->type) { |
| |
| case VideoConfigTypeAVCIntraPeriod: { |
| |
| VideoConfigAVCIntraPeriod *configAVCIntraPeriod = |
| reinterpret_cast <VideoConfigAVCIntraPeriod *> (videoEncConfig); |
| if (configAVCIntraPeriod->size != sizeof (VideoConfigAVCIntraPeriod)) { |
| return ENCODE_INVALID_PARAMS; |
| } |
| |
| configAVCIntraPeriod->idrInterval = mVideoParamsAVC.idrInterval; |
| configAVCIntraPeriod->intraPeriod = mComParams.intraPeriod; |
| configAVCIntraPeriod->ipPeriod = mVideoParamsAVC.ipPeriod; |
| |
| break; |
| } |
| case VideoConfigTypeNALSize: { |
| |
| VideoConfigNALSize *configNALSize = |
| reinterpret_cast <VideoConfigNALSize *> (videoEncConfig); |
| if (configNALSize->size != sizeof (VideoConfigNALSize)) { |
| return ENCODE_INVALID_PARAMS; |
| } |
| |
| configNALSize->maxSliceSize = mVideoParamsAVC.maxSliceSize; |
| break; |
| } |
| case VideoConfigTypeIDRRequest: { |
| break; |
| |
| } |
| case VideoConfigTypeSliceNum: { |
| |
| VideoConfigSliceNum *configSliceNum = |
| reinterpret_cast <VideoConfigSliceNum *> (videoEncConfig); |
| if (configSliceNum->size != sizeof (VideoConfigSliceNum)) { |
| return ENCODE_INVALID_PARAMS; |
| } |
| |
| configSliceNum->sliceNum = mVideoParamsAVC.sliceNum; |
| break; |
| } |
| default: { |
| LOG_E ("Invalid Config Type"); |
| break; |
| } |
| } |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::updateFrameInfo(EncodeTask* task) { |
| uint32_t idrPeroid = mComParams.intraPeriod * mVideoParamsAVC.idrInterval; |
| FrameType frametype; |
| uint32_t frame_num = mFrameNum; |
| uint32_t intraPeriod = mComParams.intraPeriod; |
| |
| if (idrPeroid != 0) { |
| if(mVideoParamsAVC.ipPeriod > 1) |
| frame_num = frame_num % (idrPeroid + 1); |
| else |
| frame_num = frame_num % idrPeroid ; |
| }else{ |
| if (mComParams.intraPeriod == 0) |
| intraPeriod = 0xFFFFFFFF; |
| } |
| |
| |
| if(frame_num ==0){ |
| frametype = FTYPE_IDR; |
| }else if(intraPeriod ==1) |
| // only I frame need intraPeriod=idrInterval=ipPeriod=0 |
| frametype = FTYPE_I; |
| else if(mVideoParamsAVC.ipPeriod == 1){ // no B frame |
| if((frame_num > 1) &&((frame_num -1)%intraPeriod == 0)) |
| frametype = FTYPE_I; |
| else |
| frametype = FTYPE_P; |
| } else { |
| if(((frame_num-1)%intraPeriod == 0)&&(frame_num >intraPeriod)) |
| frametype = FTYPE_I; |
| else{ |
| frame_num = frame_num%intraPeriod; |
| if(frame_num == 0) |
| frametype = FTYPE_B; |
| else if((frame_num-1)%mVideoParamsAVC.ipPeriod == 0) |
| frametype = FTYPE_P; |
| else |
| frametype = FTYPE_B; |
| } |
| } |
| |
| if (frametype == FTYPE_IDR || frametype == FTYPE_I) |
| task->flag |= ENCODE_BUFFERFLAG_SYNCFRAME; |
| |
| if (frametype != task->type) { |
| const char* FrameTypeStr[10] = {"UNKNOWN", "I", "P", "B", "SI", "SP", "EI", "EP", "S", "IDR"}; |
| if ((uint32_t) task->type < 9) |
| LOG_V("libMIX thinks it is %s Frame, the input is %s Frame", FrameTypeStr[frametype], FrameTypeStr[task->type]); |
| else |
| LOG_V("Wrong Frame type %d, type may not be initialized ?\n", task->type); |
| } |
| |
| //temparily comment out to avoid uninitialize error |
| // if (task->type == FTYPE_UNKNOWN || (uint32_t) task->type > 9) |
| task->type = frametype; |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::getExtFormatOutput(VideoEncOutputBuffer *outBuffer) { |
| |
| Encode_Status ret = ENCODE_SUCCESS; |
| |
| LOG_V("Begin\n"); |
| |
| switch (outBuffer->format) { |
| case OUTPUT_CODEC_DATA: { |
| // Output the codec data |
| ret = outputCodecData(outBuffer); |
| CHECK_ENCODE_STATUS_CLEANUP("outputCodecData"); |
| break; |
| } |
| |
| case OUTPUT_ONE_NAL: { |
| // Output only one NAL unit |
| ret = outputOneNALU(outBuffer, true); |
| CHECK_ENCODE_STATUS_CLEANUP("outputOneNALU"); |
| break; |
| } |
| |
| case OUTPUT_ONE_NAL_WITHOUT_STARTCODE: { |
| ret = outputOneNALU(outBuffer, false); |
| CHECK_ENCODE_STATUS_CLEANUP("outputOneNALU"); |
| break; |
| } |
| |
| case OUTPUT_LENGTH_PREFIXED: { |
| // Output length prefixed |
| ret = outputLengthPrefixed(outBuffer); |
| CHECK_ENCODE_STATUS_CLEANUP("outputLengthPrefixed"); |
| break; |
| } |
| |
| case OUTPUT_NALULENGTHS_PREFIXED: { |
| // Output nalu lengths ahead of bitstream |
| ret = outputNaluLengthsPrefixed(outBuffer); |
| CHECK_ENCODE_STATUS_CLEANUP("outputNaluLengthsPrefixed"); |
| break; |
| } |
| |
| default: |
| LOG_E("Invalid buffer mode\n"); |
| ret = ENCODE_FAIL; |
| break; |
| } |
| |
| LOG_V("out size is = %d\n", outBuffer->dataSize); |
| |
| |
| CLEAN_UP: |
| |
| |
| LOG_V("End\n"); |
| return ret; |
| } |
| |
| Encode_Status VideoEncoderAVC::getOneNALUnit( |
| uint8_t *inBuffer, uint32_t bufSize, uint32_t *nalSize, |
| uint32_t *nalType, uint32_t *nalOffset, uint32_t status) { |
| uint32_t pos = 0; |
| uint32_t zeroByteCount = 0; |
| uint32_t singleByteTable[3][2] = {{1,0},{2,0},{2,3}}; |
| uint32_t dataRemaining = 0; |
| uint8_t *dataPtr; |
| |
| // Don't need to check parameters here as we just checked by caller |
| while ((inBuffer[pos++] == 0x00)) { |
| zeroByteCount ++; |
| if (pos >= bufSize) //to make sure the buffer to be accessed is valid |
| break; |
| } |
| |
| if (inBuffer[pos - 1] != 0x01 || zeroByteCount < 2) { |
| LOG_E("The stream is not AnnexB format \n"); |
| LOG_E("segment status is %x \n", status); |
| return ENCODE_FAIL; //not AnnexB, we won't process it |
| } |
| |
| *nalType = (*(inBuffer + pos)) & 0x1F; |
| LOG_V ("NAL type = 0x%x\n", *nalType); |
| |
| zeroByteCount = 0; |
| *nalOffset = pos; |
| |
| if (status & VA_CODED_BUF_STATUS_SINGLE_NALU) { |
| *nalSize = bufSize - pos; |
| return ENCODE_SUCCESS; |
| } |
| |
| dataPtr = inBuffer + pos; |
| dataRemaining = bufSize - pos + 1; |
| |
| while ((dataRemaining > 0) && (zeroByteCount < 3)) { |
| if (((((intptr_t)dataPtr) & 0xF ) == 0) && (0 == zeroByteCount) |
| && (dataRemaining > 0xF)) { |
| |
| __asm__ ( |
| //Data input |
| "movl %1, %%ecx\n\t"//data_ptr=>ecx |
| "movl %0, %%eax\n\t"//data_remaing=>eax |
| //Main compare loop |
| // |
| "0:\n\t" //MATCH_8_ZERO: |
| "pxor %%xmm0,%%xmm0\n\t"//set 0=>xmm0 |
| "pcmpeqb (%%ecx),%%xmm0\n\t"//data_ptr=xmm0,(byte==0)?0xFF:0x00 |
| "pmovmskb %%xmm0, %%edx\n\t"//edx[0]=xmm0[7],edx[1]=xmm0[15],...,edx[15]=xmm0[127] |
| "test $0xAAAA, %%edx\n\t"//edx& 1010 1010 1010 1010b |
| "jnz 2f\n\t"//Not equal to zero means that at least one byte 0x00 |
| |
| "1:\n\t" //PREPARE_NEXT_MATCH: |
| "sub $0x10, %%eax\n\t"//16 + ecx --> ecx |
| "add $0x10, %%ecx\n\t"//eax-16 --> eax |
| "cmp $0x10, %%eax\n\t" |
| "jge 0b\n\t"//search next 16 bytes |
| |
| "2:\n\t" //DATA_RET: |
| "movl %%ecx, %1\n\t"//output ecx->data_ptr |
| "movl %%eax, %0\n\t"//output eax->data_remaining |
| : "+m"(dataRemaining), "+m"(dataPtr) |
| : |
| :"eax", "ecx", "edx", "xmm0" |
| ); |
| if (0 >= dataRemaining) { |
| break; |
| } |
| |
| } |
| //check the value of each byte |
| if ((*dataPtr) >= 2) { |
| |
| zeroByteCount = 0; |
| |
| } |
| else { |
| zeroByteCount = singleByteTable[zeroByteCount][*dataPtr]; |
| } |
| |
| dataPtr ++; |
| dataRemaining --; |
| } |
| |
| if ((3 == zeroByteCount) && (dataRemaining > 0)) { |
| |
| *nalSize = bufSize - dataRemaining - *nalOffset - 3; |
| |
| } else if (0 == dataRemaining) { |
| |
| *nalSize = bufSize - *nalOffset; |
| } |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::getHeader( |
| uint8_t *inBuffer, uint32_t bufSize, uint32_t *headerSize, uint32_t status) { |
| |
| uint32_t nalType = 0; |
| uint32_t nalSize = 0; |
| uint32_t nalOffset = 0; |
| uint32_t size = 0; |
| uint8_t *buf = inBuffer; |
| Encode_Status ret = ENCODE_SUCCESS; |
| |
| *headerSize = 0; |
| CHECK_NULL_RETURN_IFFAIL(inBuffer); |
| |
| if (bufSize == 0) { |
| //bufSize shoule not be 0, error happens |
| LOG_E("Buffer size is 0\n"); |
| return ENCODE_FAIL; |
| } |
| |
| while (1) { |
| nalType = nalSize = nalOffset = 0; |
| ret = getOneNALUnit(buf, bufSize, &nalSize, &nalType, &nalOffset, status); |
| CHECK_ENCODE_STATUS_RETURN("getOneNALUnit"); |
| |
| LOG_V("NAL type = %d, NAL size = %d, offset = %d\n", nalType, nalSize, nalOffset); |
| size = nalSize + nalOffset; |
| |
| // Codec_data should be SPS or PPS |
| if (nalType == 7 || nalType == 8) { |
| *headerSize += size; |
| buf += size; |
| bufSize -= size; |
| } else { |
| LOG_V("No header found or no header anymore\n"); |
| break; |
| } |
| } |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::outputCodecData( |
| VideoEncOutputBuffer *outBuffer) { |
| |
| Encode_Status ret = ENCODE_SUCCESS; |
| uint32_t headerSize = 0; |
| |
| ret = getHeader((uint8_t *)mCurSegment->buf + mOffsetInSeg, |
| mCurSegment->size - mOffsetInSeg, &headerSize, mCurSegment->status); |
| CHECK_ENCODE_STATUS_RETURN("getHeader"); |
| if (headerSize == 0) { |
| outBuffer->dataSize = 0; |
| mCurSegment = NULL; |
| return ENCODE_NO_REQUEST_DATA; |
| } |
| |
| if (headerSize <= outBuffer->bufferSize) { |
| memcpy(outBuffer->data, (uint8_t *)mCurSegment->buf + mOffsetInSeg, headerSize); |
| mTotalSizeCopied += headerSize; |
| mOffsetInSeg += headerSize; |
| outBuffer->dataSize = headerSize; |
| outBuffer->remainingSize = 0; |
| outBuffer->flag |= ENCODE_BUFFERFLAG_ENDOFFRAME; |
| outBuffer->flag |= ENCODE_BUFFERFLAG_CODECCONFIG; |
| outBuffer->flag |= ENCODE_BUFFERFLAG_SYNCFRAME; |
| } else { |
| // we need a big enough buffer, otherwise we won't output anything |
| outBuffer->dataSize = 0; |
| outBuffer->remainingSize = headerSize; |
| outBuffer->flag |= ENCODE_BUFFERFLAG_DATAINVALID; |
| LOG_E("Buffer size too small\n"); |
| return ENCODE_BUFFER_TOO_SMALL; |
| } |
| |
| return ret; |
| } |
| |
| Encode_Status VideoEncoderAVC::outputOneNALU( |
| VideoEncOutputBuffer *outBuffer, bool startCode) { |
| |
| uint32_t nalType = 0; |
| uint32_t nalSize = 0; |
| uint32_t nalOffset = 0; |
| uint32_t sizeToBeCopied = 0; |
| |
| Encode_Status ret = ENCODE_SUCCESS; |
| CHECK_NULL_RETURN_IFFAIL(mCurSegment->buf); |
| |
| ret = getOneNALUnit((uint8_t *)mCurSegment->buf + mOffsetInSeg, |
| mCurSegment->size - mOffsetInSeg, &nalSize, &nalType, &nalOffset, mCurSegment->status); |
| CHECK_ENCODE_STATUS_RETURN("getOneNALUnit"); |
| |
| // check if we need startcode along with the payload |
| if (startCode) { |
| sizeToBeCopied = nalSize + nalOffset; |
| } else { |
| sizeToBeCopied = nalSize; |
| } |
| |
| if (sizeToBeCopied <= outBuffer->bufferSize) { |
| if (startCode) { |
| memcpy(outBuffer->data, (uint8_t *)mCurSegment->buf + mOffsetInSeg, sizeToBeCopied); |
| } else { |
| memcpy(outBuffer->data, (uint8_t *)mCurSegment->buf + mOffsetInSeg + nalOffset, |
| sizeToBeCopied); |
| } |
| mTotalSizeCopied += sizeToBeCopied; |
| mOffsetInSeg += (nalSize + nalOffset); |
| outBuffer->dataSize = sizeToBeCopied; |
| outBuffer->flag |= ENCODE_BUFFERFLAG_PARTIALFRAME; |
| outBuffer->remainingSize = 0; |
| } else { |
| // if nothing to be copied out, set flag to invalid |
| outBuffer->dataSize = 0; |
| outBuffer->flag |= ENCODE_BUFFERFLAG_DATAINVALID; |
| outBuffer->remainingSize = sizeToBeCopied; |
| LOG_W("Buffer size too small\n"); |
| return ENCODE_BUFFER_TOO_SMALL; |
| } |
| |
| // check if all data in current segment has been copied out |
| if (mCurSegment->size == mOffsetInSeg) { |
| if (mCurSegment->next != NULL) { |
| mCurSegment = (VACodedBufferSegment *)mCurSegment->next; |
| mOffsetInSeg = 0; |
| } else { |
| LOG_V("End of stream\n"); |
| outBuffer->flag |= ENCODE_BUFFERFLAG_ENDOFFRAME; |
| mCurSegment = NULL; |
| } |
| } |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::outputLengthPrefixed(VideoEncOutputBuffer *outBuffer) { |
| |
| Encode_Status ret = ENCODE_SUCCESS; |
| uint32_t nalType = 0; |
| uint32_t nalSize = 0; |
| uint32_t nalOffset = 0; |
| uint32_t sizeCopiedHere = 0; |
| |
| CHECK_NULL_RETURN_IFFAIL(mCurSegment->buf); |
| |
| while (1) { |
| |
| if (mCurSegment->size < mOffsetInSeg || outBuffer->bufferSize < sizeCopiedHere) { |
| LOG_E("mCurSegment->size < mOffsetInSeg || outBuffer->bufferSize < sizeCopiedHere\n"); |
| return ENCODE_FAIL; |
| } |
| |
| // we need to handle the whole bitstream NAL by NAL |
| ret = getOneNALUnit( |
| (uint8_t *)mCurSegment->buf + mOffsetInSeg, |
| mCurSegment->size - mOffsetInSeg, &nalSize, &nalType, &nalOffset, mCurSegment->status); |
| CHECK_ENCODE_STATUS_RETURN("getOneNALUnit"); |
| |
| if (nalSize + 4 <= outBuffer->bufferSize - sizeCopiedHere) { |
| // write the NAL length to bit stream |
| outBuffer->data[sizeCopiedHere] = (nalSize >> 24) & 0xff; |
| outBuffer->data[sizeCopiedHere + 1] = (nalSize >> 16) & 0xff; |
| outBuffer->data[sizeCopiedHere + 2] = (nalSize >> 8) & 0xff; |
| outBuffer->data[sizeCopiedHere + 3] = nalSize & 0xff; |
| |
| sizeCopiedHere += 4; |
| mTotalSizeCopied += 4; |
| |
| memcpy(outBuffer->data + sizeCopiedHere, |
| (uint8_t *)mCurSegment->buf + mOffsetInSeg + nalOffset, nalSize); |
| |
| sizeCopiedHere += nalSize; |
| mTotalSizeCopied += nalSize; |
| mOffsetInSeg += (nalSize + nalOffset); |
| |
| } else { |
| outBuffer->dataSize = sizeCopiedHere; |
| // In case the start code is 3-byte length but we use 4-byte for length prefixed |
| // so the remainingSize size may larger than the remaining data size |
| outBuffer->remainingSize = mTotalSize - mTotalSizeCopied + 100; |
| outBuffer->flag |= ENCODE_BUFFERFLAG_PARTIALFRAME; |
| LOG_E("Buffer size too small\n"); |
| return ENCODE_BUFFER_TOO_SMALL; |
| } |
| |
| // check if all data in current segment has been copied out |
| if (mCurSegment->size == mOffsetInSeg) { |
| if (mCurSegment->next != NULL) { |
| mCurSegment = (VACodedBufferSegment *)mCurSegment->next; |
| mOffsetInSeg = 0; |
| } else { |
| LOG_V("End of stream\n"); |
| outBuffer->dataSize = sizeCopiedHere; |
| outBuffer->remainingSize = 0; |
| outBuffer->flag |= ENCODE_BUFFERFLAG_ENDOFFRAME; |
| mCurSegment = NULL; |
| break; |
| } |
| } |
| } |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::outputNaluLengthsPrefixed(VideoEncOutputBuffer *outBuffer) { |
| |
| Encode_Status ret = ENCODE_SUCCESS; |
| uint32_t nalType = 0; |
| uint32_t nalSize = 0; |
| uint32_t nalOffset = 0; |
| uint32_t sizeCopiedHere = 0; |
| const uint32_t NALUINFO_OFFSET = 256; |
| uint32_t nalNum = 0; |
| |
| CHECK_NULL_RETURN_IFFAIL(mCurSegment->buf); |
| |
| while (1) { |
| |
| if (mCurSegment->size < mOffsetInSeg || outBuffer->bufferSize < sizeCopiedHere) { |
| LOG_E("mCurSegment->size < mOffsetInSeg || outBuffer->bufferSize < sizeCopiedHere\n"); |
| return ENCODE_FAIL; |
| } |
| |
| // we need to handle the whole bitstream NAL by NAL |
| ret = getOneNALUnit( |
| (uint8_t *)mCurSegment->buf + mOffsetInSeg, |
| mCurSegment->size - mOffsetInSeg, &nalSize, &nalType, &nalOffset, mCurSegment->status); |
| CHECK_ENCODE_STATUS_RETURN("getOneNALUnit"); |
| |
| if (nalSize + 4 <= outBuffer->bufferSize - NALUINFO_OFFSET - sizeCopiedHere) { |
| |
| memcpy(outBuffer->data + NALUINFO_OFFSET + sizeCopiedHere, |
| (uint8_t *)mCurSegment->buf + mOffsetInSeg, nalSize + nalOffset); |
| |
| sizeCopiedHere += nalSize + nalOffset; |
| mTotalSizeCopied += nalSize + nalOffset; |
| mOffsetInSeg += (nalSize + nalOffset); |
| |
| } else { |
| outBuffer->dataSize = sizeCopiedHere; |
| // In case the start code is 3-byte length but we use 4-byte for length prefixed |
| // so the remainingSize size may larger than the remaining data size |
| outBuffer->remainingSize = mTotalSize - mTotalSizeCopied + 100; |
| outBuffer->flag |= ENCODE_BUFFERFLAG_PARTIALFRAME; |
| LOG_E("Buffer size too small\n"); |
| return ENCODE_BUFFER_TOO_SMALL; |
| } |
| |
| nalNum ++; |
| uint32_t *nalLength = (uint32_t *) (outBuffer->data + (nalNum+1) * 4); |
| |
| *nalLength = nalSize + nalOffset; |
| |
| // check if all data in current segment has been copied out |
| if (mCurSegment->size == mOffsetInSeg) { |
| if (mCurSegment->next != NULL) { |
| mCurSegment = (VACodedBufferSegment *)mCurSegment->next; |
| mOffsetInSeg = 0; |
| } else { |
| LOG_V("End of stream\n"); |
| outBuffer->dataSize = sizeCopiedHere; |
| outBuffer->remainingSize = 0; |
| outBuffer->flag |= ENCODE_BUFFERFLAG_ENDOFFRAME; |
| mCurSegment = NULL; |
| break; |
| } |
| } |
| } |
| |
| outBuffer->offset = NALUINFO_OFFSET; |
| uint32_t *nalHead = (uint32_t *) outBuffer->data; |
| *nalHead = 0x4E414C4C; //'nall' |
| *(++nalHead) = nalNum; |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::sendEncodeCommand(EncodeTask *task) { |
| Encode_Status ret = ENCODE_SUCCESS; |
| |
| LOG_V( "Begin\n"); |
| |
| if (mFrameNum == 0 || mNewHeader) { |
| if (mRenderHrd) { |
| ret = renderHrd(); |
| mRenderHrd = false; |
| CHECK_ENCODE_STATUS_RETURN("renderHrd"); |
| } |
| |
| mFrameNum = 0; |
| ret = renderSequenceParams(task); |
| CHECK_ENCODE_STATUS_RETURN("renderSequenceParams"); |
| if (mNewHeader) { |
| mNewHeader = false; //Set to require new header filed to false |
| mFrameNum = 0; //reset mFrameNum to 0 |
| updateFrameInfo(task); //recalculate frame info if mNewHeader is set true after PrepareFrameInfo in encode() |
| } |
| } |
| |
| if (mRenderMaxSliceSize && mVideoParamsAVC.maxSliceSize != 0) { |
| ret = renderMaxSliceSize(); |
| CHECK_ENCODE_STATUS_RETURN("renderMaxSliceSize"); |
| mRenderMaxSliceSize = false; |
| } |
| |
| if (mComParams.rcParams.enableIntraFrameQPControl && (task->type == FTYPE_IDR || task->type == FTYPE_I)) |
| mRenderBitRate = true; |
| |
| if (mRenderBitRate) { |
| ret = VideoEncoderBase::renderDynamicBitrate(task); |
| CHECK_ENCODE_STATUS_RETURN("renderDynamicBitrate"); |
| } |
| |
| if (mRenderAIR && |
| (mComParams.refreshType == VIDEO_ENC_AIR || |
| mComParams.refreshType == VIDEO_ENC_BOTH)) { |
| |
| ret = renderAIR(); |
| CHECK_ENCODE_STATUS_RETURN("renderAIR"); |
| |
| mRenderAIR = false; |
| } |
| |
| if (mRenderCIR) { |
| |
| ret = renderCIR(); |
| CHECK_ENCODE_STATUS_RETURN("renderCIR"); |
| |
| mRenderCIR = false; |
| } |
| |
| if (mRenderFrameRate) { |
| |
| ret = VideoEncoderBase::renderDynamicFrameRate(); |
| CHECK_ENCODE_STATUS_RETURN("renderDynamicFrameRate"); |
| |
| mRenderFrameRate = false; |
| } |
| |
| ret = renderPictureParams(task); |
| CHECK_ENCODE_STATUS_RETURN("renderPictureParams"); |
| |
| if (mFrameNum == 0 && (mEncPackedHeaders != VA_ATTRIB_NOT_SUPPORTED)) { |
| ret = renderPackedSequenceParams(task); |
| CHECK_ENCODE_STATUS_RETURN("renderPackedSequenceParams"); |
| |
| ret = renderPackedPictureParams(task); |
| CHECK_ENCODE_STATUS_RETURN("renderPackedPictureParams"); |
| } |
| |
| ret = renderSliceParams(task); |
| CHECK_ENCODE_STATUS_RETURN("renderSliceParams"); |
| |
| LOG_V( "End\n"); |
| return ENCODE_SUCCESS; |
| } |
| |
| |
| Encode_Status VideoEncoderAVC::renderMaxSliceSize() { |
| |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| LOG_V( "Begin\n\n"); |
| |
| if (mComParams.rcMode != RATE_CONTROL_VCM) { |
| LOG_W ("Not in VCM mode, but call send_max_slice_size\n"); |
| return ENCODE_SUCCESS; |
| } |
| |
| VAEncMiscParameterBuffer *miscEncParamBuf; |
| VAEncMiscParameterMaxSliceSize *maxSliceSizeParam; |
| VABufferID miscParamBufferID; |
| |
| vaStatus = vaCreateBuffer( |
| mVADisplay, mVAContext, |
| VAEncMiscParameterBufferType, |
| sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterMaxSliceSize), |
| 1, NULL, &miscParamBufferID); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| |
| vaStatus = vaMapBuffer(mVADisplay, miscParamBufferID, (void **)&miscEncParamBuf); |
| CHECK_VA_STATUS_RETURN("vaMapBuffer"); |
| |
| miscEncParamBuf->type = VAEncMiscParameterTypeMaxSliceSize; |
| maxSliceSizeParam = (VAEncMiscParameterMaxSliceSize *)miscEncParamBuf->data; |
| |
| maxSliceSizeParam->max_slice_size = mVideoParamsAVC.maxSliceSize; |
| |
| vaStatus = vaUnmapBuffer(mVADisplay, miscParamBufferID); |
| CHECK_VA_STATUS_RETURN("vaUnmapBuffer"); |
| |
| LOG_I( "max slice size = %d\n", maxSliceSizeParam->max_slice_size); |
| |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &miscParamBufferID, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::renderCIR(){ |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| LOG_V( "%s Begin\n", __FUNCTION__); |
| |
| VABufferID miscParamBufferCIRid; |
| VAEncMiscParameterBuffer *misc_param; |
| VAEncMiscParameterCIR *misc_cir_param; |
| |
| vaStatus = vaCreateBuffer(mVADisplay, mVAContext, |
| VAEncMiscParameterBufferType, |
| sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterCIR), |
| 1, |
| NULL, |
| &miscParamBufferCIRid); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| |
| vaStatus = vaMapBuffer(mVADisplay, miscParamBufferCIRid, (void **)&misc_param); |
| CHECK_VA_STATUS_RETURN("vaMapBuffer"); |
| |
| misc_param->type = VAEncMiscParameterTypeCIR; |
| misc_cir_param = (VAEncMiscParameterCIR *)misc_param->data; |
| misc_cir_param->cir_num_mbs = mComParams.cirParams.cir_num_mbs; |
| LOG_I( "cir_num_mbs %d \n", misc_cir_param->cir_num_mbs); |
| |
| vaUnmapBuffer(mVADisplay, miscParamBufferCIRid); |
| CHECK_VA_STATUS_RETURN("vaUnmapBuffer"); |
| |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &miscParamBufferCIRid, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::renderAIR() { |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| LOG_V( "Begin\n\n"); |
| |
| VAEncMiscParameterBuffer *miscEncParamBuf; |
| VAEncMiscParameterAIR *airParams; |
| VABufferID miscParamBufferID; |
| |
| vaStatus = vaCreateBuffer( |
| mVADisplay, mVAContext, |
| VAEncMiscParameterBufferType, |
| sizeof(miscEncParamBuf) + sizeof(VAEncMiscParameterAIR), |
| 1, NULL, &miscParamBufferID); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| |
| vaStatus = vaMapBuffer(mVADisplay, miscParamBufferID, (void **)&miscEncParamBuf); |
| CHECK_VA_STATUS_RETURN("vaMapBuffer"); |
| |
| miscEncParamBuf->type = VAEncMiscParameterTypeAIR; |
| airParams = (VAEncMiscParameterAIR *)miscEncParamBuf->data; |
| |
| airParams->air_num_mbs = mComParams.airParams.airMBs; |
| airParams->air_threshold= mComParams.airParams.airThreshold; |
| airParams->air_auto = mComParams.airParams.airAuto; |
| |
| vaStatus = vaUnmapBuffer(mVADisplay, miscParamBufferID); |
| CHECK_VA_STATUS_RETURN("vaUnmapBuffer"); |
| |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &miscParamBufferID, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| |
| LOG_I( "airThreshold = %d\n", airParams->air_threshold); |
| return ENCODE_SUCCESS; |
| } |
| |
| int VideoEncoderAVC::calcLevel(int numMbs) { |
| int level = 30; |
| |
| if (numMbs < 1620) { |
| level = 30; |
| } else if (numMbs < 3600) { |
| level = 31; |
| } else if (numMbs < 5120) { |
| level = 32; |
| } else if (numMbs < 8192) { |
| level = 41; |
| } else if (numMbs < 8704) { |
| level = 42; |
| } else if (numMbs < 22080) { |
| level = 50; |
| } else if (numMbs < 36864) { |
| level = 51; |
| } else { |
| LOG_W("No such level can support that resolution"); |
| level = 51; |
| } |
| return level; |
| } |
| |
| Encode_Status VideoEncoderAVC::renderSequenceParams(EncodeTask *) { |
| |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| VAEncSequenceParameterBufferH264 avcSeqParams = VAEncSequenceParameterBufferH264(); |
| VAEncMiscParameterBuffer *miscEncRCParamBuf; |
| VAEncMiscParameterBuffer *miscEncFrameRateParamBuf; |
| VAEncMiscParameterRateControl *rcMiscParam; |
| VAEncMiscParameterFrameRate *framerateParam; |
| int level; |
| uint32_t frameRateNum = mComParams.frameRate.frameRateNum; |
| uint32_t frameRateDenom = mComParams.frameRate.frameRateDenom; |
| |
| LOG_V( "Begin\n\n"); |
| vaStatus = vaCreateBuffer(mVADisplay, mVAContext, |
| VAEncMiscParameterBufferType, |
| sizeof (VAEncMiscParameterBuffer) + sizeof (VAEncMiscParameterRateControl), |
| 1, NULL, |
| &mRcParamBuf); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| vaStatus = vaMapBuffer(mVADisplay, mRcParamBuf, (void **)&miscEncRCParamBuf); |
| CHECK_VA_STATUS_RETURN("vaMapBuffer"); |
| |
| vaStatus = vaCreateBuffer(mVADisplay, mVAContext, |
| VAEncMiscParameterBufferType, |
| sizeof (VAEncMiscParameterBuffer) + sizeof (VAEncMiscParameterFrameRate), |
| 1, NULL, |
| &mFrameRateParamBuf); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| vaStatus = vaMapBuffer(mVADisplay, mFrameRateParamBuf, (void **)&miscEncFrameRateParamBuf); |
| CHECK_VA_STATUS_RETURN("vaMapBuffer"); |
| |
| miscEncRCParamBuf->type = VAEncMiscParameterTypeRateControl; |
| rcMiscParam = (VAEncMiscParameterRateControl *)miscEncRCParamBuf->data; |
| miscEncFrameRateParamBuf->type = VAEncMiscParameterTypeFrameRate; |
| framerateParam = (VAEncMiscParameterFrameRate *)miscEncFrameRateParamBuf->data; |
| // set up the sequence params for HW |
| // avcSeqParams.level_idc = mLevel; |
| avcSeqParams.intra_period = mComParams.intraPeriod; |
| avcSeqParams.intra_idr_period = mVideoParamsAVC.idrInterval; |
| avcSeqParams.ip_period = mVideoParamsAVC.ipPeriod; |
| avcSeqParams.picture_width_in_mbs = (mComParams.resolution.width + 15) / 16; |
| avcSeqParams.picture_height_in_mbs = (mComParams.resolution.height + 15) / 16; |
| |
| level = calcLevel (avcSeqParams.picture_width_in_mbs * avcSeqParams.picture_height_in_mbs); |
| avcSeqParams.level_idc = level; |
| avcSeqParams.bits_per_second = mComParams.rcParams.bitRate; |
| framerateParam->framerate = |
| (unsigned int) (frameRateNum + frameRateDenom /2 ) / frameRateDenom; |
| rcMiscParam->initial_qp = mComParams.rcParams.initQP; |
| rcMiscParam->min_qp = mComParams.rcParams.minQP; |
| rcMiscParam->max_qp = mComParams.rcParams.maxQP; |
| if (mComParams.rcParams.enableIntraFrameQPControl) { |
| rcMiscParam->min_qp = mComParams.rcParams.I_minQP; |
| rcMiscParam->max_qp = mComParams.rcParams.I_maxQP; |
| } |
| rcMiscParam->window_size = mComParams.rcParams.windowSize; |
| //target bitrate is sent to libva through Sequence Parameter Buffer |
| rcMiscParam->bits_per_second = 0; |
| rcMiscParam->basic_unit_size = mVideoParamsAVC.basicUnitSize; //for rate control usage |
| avcSeqParams.intra_period = mComParams.intraPeriod; |
| //avcSeqParams.vui_flag = 248; |
| avcSeqParams.vui_parameters_present_flag = mVideoParamsAVC.VUIFlag; |
| avcSeqParams.num_units_in_tick = frameRateDenom; |
| avcSeqParams.time_scale = 2 * frameRateNum; |
| avcSeqParams.seq_parameter_set_id = 0; |
| if (mVideoParamsAVC.crop.LeftOffset || |
| mVideoParamsAVC.crop.RightOffset || |
| mVideoParamsAVC.crop.TopOffset || |
| mVideoParamsAVC.crop.BottomOffset) { |
| avcSeqParams.frame_cropping_flag = true; |
| avcSeqParams.frame_crop_left_offset = mVideoParamsAVC.crop.LeftOffset; |
| avcSeqParams.frame_crop_right_offset = mVideoParamsAVC.crop.RightOffset; |
| avcSeqParams.frame_crop_top_offset = mVideoParamsAVC.crop.TopOffset; |
| avcSeqParams.frame_crop_bottom_offset = mVideoParamsAVC.crop.BottomOffset; |
| } else { |
| avcSeqParams.frame_cropping_flag = false; |
| |
| if (mComParams.resolution.width & 0xf) { |
| avcSeqParams.frame_cropping_flag = true; |
| uint32_t AWidth = (mComParams.resolution.width + 0xf) & (~0xf); |
| avcSeqParams.frame_crop_right_offset = ( AWidth - mComParams.resolution.width ) / 2; |
| } |
| |
| if (mComParams.resolution.height & 0xf) { |
| avcSeqParams.frame_cropping_flag = true; |
| uint32_t AHeight = (mComParams.resolution.height + 0xf) & (~0xf); |
| avcSeqParams.frame_crop_bottom_offset = ( AHeight - mComParams.resolution.height ) / 2; |
| } |
| } |
| |
| if(avcSeqParams.vui_parameters_present_flag && (mVideoParamsAVC.SAR.SarWidth || mVideoParamsAVC.SAR.SarHeight)) { |
| avcSeqParams.vui_fields.bits.aspect_ratio_info_present_flag = true; |
| avcSeqParams.aspect_ratio_idc = 0xff /* Extended_SAR */; |
| avcSeqParams.sar_width = mVideoParamsAVC.SAR.SarWidth; |
| avcSeqParams.sar_height = mVideoParamsAVC.SAR.SarHeight; |
| } |
| |
| avcSeqParams.max_num_ref_frames = 1; |
| |
| if(avcSeqParams.ip_period > 1) |
| avcSeqParams.max_num_ref_frames = 2; |
| |
| LOG_V("===h264 sequence params===\n"); |
| LOG_V( "seq_parameter_set_id = %d\n", (uint32_t)avcSeqParams.seq_parameter_set_id); |
| LOG_V( "level_idc = %d\n", (uint32_t)avcSeqParams.level_idc); |
| LOG_V( "intra_period = %d\n", avcSeqParams.intra_period); |
| LOG_V( "idr_interval = %d\n", avcSeqParams.intra_idr_period); |
| LOG_V( "picture_width_in_mbs = %d\n", avcSeqParams.picture_width_in_mbs); |
| LOG_V( "picture_height_in_mbs = %d\n", avcSeqParams.picture_height_in_mbs); |
| LOG_V( "bitrate = %d\n", rcMiscParam->bits_per_second); |
| LOG_V( "frame_rate = %d\n", framerateParam->framerate); |
| LOG_V( "initial_qp = %d\n", rcMiscParam->initial_qp); |
| LOG_V( "min_qp = %d\n", rcMiscParam->min_qp); |
| LOG_V( "basic_unit_size = %d\n", rcMiscParam->basic_unit_size); |
| LOG_V( "bDirect8x8Inference = %d\n",mVideoParamsAVC.bDirect8x8Inference); |
| |
| // Not sure whether these settings work for all drivers |
| avcSeqParams.seq_fields.bits.frame_mbs_only_flag = 1; |
| avcSeqParams.seq_fields.bits.pic_order_cnt_type = 0; |
| avcSeqParams.seq_fields.bits.direct_8x8_inference_flag = mVideoParamsAVC.bDirect8x8Inference; |
| |
| avcSeqParams.seq_fields.bits.log2_max_frame_num_minus4 = 0; |
| avcSeqParams.seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = 2; |
| // avcSeqParams.time_scale = 900; |
| // avcSeqParams.num_units_in_tick = 15; /* Tc = num_units_in_tick / time_sacle */ |
| // Not sure whether these settings work for all drivers |
| |
| vaStatus = vaUnmapBuffer(mVADisplay, mRcParamBuf); |
| CHECK_VA_STATUS_RETURN("vaUnmapBuffer"); |
| vaStatus = vaUnmapBuffer(mVADisplay, mFrameRateParamBuf); |
| CHECK_VA_STATUS_RETURN("vaUnmapBuffer"); |
| vaStatus = vaCreateBuffer( |
| mVADisplay, mVAContext, |
| VAEncSequenceParameterBufferType, |
| sizeof(avcSeqParams), 1, &avcSeqParams, |
| &mSeqParamBuf); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &mFrameRateParamBuf, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &mSeqParamBuf, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &mRcParamBuf, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::renderPackedSequenceParams(EncodeTask *) { |
| |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| VAEncSequenceParameterBufferH264 *avcSeqParams; |
| VAEncPackedHeaderParameterBuffer packed_header_param_buffer; |
| unsigned char *packed_seq_buffer = NULL; |
| unsigned int length_in_bits; |
| |
| LOG_V("Begin\n"); |
| |
| vaStatus = vaMapBuffer(mVADisplay, mSeqParamBuf, (void **)&avcSeqParams); |
| CHECK_VA_STATUS_RETURN("vaMapBuffer"); |
| |
| length_in_bits = build_packed_seq_buffer(&packed_seq_buffer, mComParams.profile, avcSeqParams); |
| packed_header_param_buffer.type = VAEncPackedHeaderSequence; |
| packed_header_param_buffer.bit_length = length_in_bits; |
| packed_header_param_buffer.has_emulation_bytes = 0; |
| vaStatus = vaCreateBuffer(mVADisplay, mVAContext, |
| VAEncPackedHeaderParameterBufferType, |
| sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer, |
| &packed_seq_header_param_buf_id); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| |
| vaStatus = vaCreateBuffer(mVADisplay, mVAContext, |
| VAEncPackedHeaderDataBufferType, |
| (length_in_bits + 7) / 8, 1, packed_seq_buffer, |
| &packed_seq_buf_id); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &packed_seq_header_param_buf_id, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &packed_seq_buf_id, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| |
| vaStatus = vaUnmapBuffer(mVADisplay, mSeqParamBuf); |
| CHECK_VA_STATUS_RETURN("vaUnmapBuffer"); |
| |
| free(packed_seq_buffer); |
| |
| LOG_V("End\n"); |
| |
| return vaStatus; |
| } |
| |
| Encode_Status VideoEncoderAVC::renderPictureParams(EncodeTask *task) { |
| |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| VAEncPictureParameterBufferH264 avcPicParams = VAEncPictureParameterBufferH264(); |
| uint32_t RefFrmIdx; |
| |
| LOG_V( "Begin\n\n"); |
| // set picture params for HW |
| if (mAutoReference == false) { |
| for (RefFrmIdx = 0; RefFrmIdx < 16; RefFrmIdx++) { |
| avcPicParams.ReferenceFrames[RefFrmIdx].picture_id = VA_INVALID_ID; |
| avcPicParams.ReferenceFrames[RefFrmIdx].flags = VA_PICTURE_H264_INVALID; |
| } |
| avcPicParams.ReferenceFrames[0].picture_id= task->ref_surface; |
| avcPicParams.ReferenceFrames[0].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE; |
| avcPicParams.CurrPic.picture_id= task->rec_surface; |
| // Not sure whether these settings work for all drivers |
| avcPicParams.CurrPic.TopFieldOrderCnt = mFrameNum * 2; |
| |
| avcPicParams.pic_fields.bits.transform_8x8_mode_flag = 0; |
| avcPicParams.seq_parameter_set_id = 0; |
| avcPicParams.pic_parameter_set_id = 0; |
| |
| avcPicParams.last_picture = 0; |
| avcPicParams.frame_num = 0; |
| |
| avcPicParams.pic_init_qp = 26; |
| avcPicParams.num_ref_idx_l0_active_minus1 = 0; |
| avcPicParams.num_ref_idx_l1_active_minus1 = 0; |
| |
| avcPicParams.pic_fields.bits.idr_pic_flag = 0; |
| avcPicParams.pic_fields.bits.reference_pic_flag = 0; |
| avcPicParams.pic_fields.bits.entropy_coding_mode_flag = 0; |
| avcPicParams.pic_fields.bits.weighted_pred_flag = 0; |
| avcPicParams.pic_fields.bits.weighted_bipred_idc = 0; |
| avcPicParams.pic_fields.bits.transform_8x8_mode_flag = 0; |
| avcPicParams.pic_fields.bits.deblocking_filter_control_present_flag = 1; |
| |
| avcPicParams.frame_num = mFrameNum; |
| avcPicParams.pic_fields.bits.reference_pic_flag = 1; |
| // Not sure whether these settings work for all drivers |
| }else { |
| avcPicParams.CurrPic.picture_id= VA_INVALID_SURFACE; |
| for(uint32_t i =0; i< mAutoReferenceSurfaceNum; i++) |
| avcPicParams.ReferenceFrames[i].picture_id = mAutoRefSurfaces[i]; |
| } |
| |
| avcPicParams.pic_fields.bits.idr_pic_flag = (mFrameNum == 0); |
| avcPicParams.pic_fields.bits.entropy_coding_mode_flag = mVideoParamsAVC.bEntropyCodingCABAC; |
| avcPicParams.coded_buf = task->coded_buffer; |
| avcPicParams.last_picture = 0; |
| |
| LOG_V("======h264 picture params======\n"); |
| LOG_V( "reference_picture = 0x%08x\n", avcPicParams.ReferenceFrames[0].picture_id); |
| LOG_V( "reconstructed_picture = 0x%08x\n", avcPicParams.CurrPic.picture_id); |
| LOG_V( "coded_buf = 0x%08x\n", avcPicParams.coded_buf); |
| //LOG_I( "picture_width = %d\n", avcPicParams.picture_width); |
| //LOG_I( "picture_height = %d\n\n", avcPicParams.picture_height); |
| |
| vaStatus = vaCreateBuffer( |
| mVADisplay, mVAContext, |
| VAEncPictureParameterBufferType, |
| sizeof(avcPicParams), |
| 1,&avcPicParams, |
| &mPicParamBuf); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &mPicParamBuf, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| |
| LOG_V( "end\n"); |
| return ENCODE_SUCCESS; |
| } |
| |
| Encode_Status VideoEncoderAVC::renderPackedPictureParams(EncodeTask *) { |
| |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| VAEncPictureParameterBufferH264 *avcPicParams; |
| VAEncPackedHeaderParameterBuffer packed_header_param_buffer; |
| unsigned char *packed_pic_buffer = NULL; |
| unsigned int length_in_bits; |
| |
| LOG_V("Begin\n"); |
| |
| vaStatus = vaMapBuffer(mVADisplay, mPicParamBuf, (void **)&avcPicParams); |
| CHECK_VA_STATUS_RETURN("vaMapBuffer"); |
| |
| length_in_bits = build_packed_pic_buffer(&packed_pic_buffer, avcPicParams); |
| packed_header_param_buffer.type = VAEncPackedHeaderPicture; |
| packed_header_param_buffer.bit_length = length_in_bits; |
| packed_header_param_buffer.has_emulation_bytes = 0; |
| vaStatus = vaCreateBuffer(mVADisplay, mVAContext, |
| VAEncPackedHeaderParameterBufferType, |
| sizeof(packed_header_param_buffer), 1, &packed_header_param_buffer, |
| &packed_pic_header_param_buf_id); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| |
| vaStatus = vaCreateBuffer(mVADisplay, mVAContext, |
| VAEncPackedHeaderDataBufferType, |
| (length_in_bits + 7) / 8, 1, packed_pic_buffer, |
| &packed_pic_buf_id); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &packed_pic_header_param_buf_id, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &packed_pic_buf_id, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| |
| vaStatus = vaUnmapBuffer(mVADisplay, mSeqParamBuf); |
| CHECK_VA_STATUS_RETURN("vaUnmapBuffer"); |
| |
| free(packed_pic_buffer); |
| |
| LOG_V("End\n"); |
| |
| return vaStatus; |
| } |
| |
| Encode_Status VideoEncoderAVC::renderSliceParams(EncodeTask *task) { |
| |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| |
| uint32_t sliceNum = 0; |
| uint32_t sliceIndex = 0; |
| uint32_t sliceHeightInMB = 0; |
| uint32_t maxSliceNum = 0; |
| uint32_t minSliceNum = 0; |
| uint32_t actualSliceHeightInMB = 0; |
| uint32_t startRowInMB = 0; |
| uint32_t modulus = 0; |
| uint32_t RefFrmIdx; |
| |
| LOG_V( "Begin\n\n"); |
| |
| maxSliceNum = (mComParams.resolution.height + 15) / 16; |
| minSliceNum = 1; |
| |
| if (task->type == FTYPE_I || task->type == FTYPE_IDR) { |
| sliceNum = mVideoParamsAVC.sliceNum.iSliceNum; |
| } else { |
| sliceNum = mVideoParamsAVC.sliceNum.pSliceNum; |
| } |
| |
| if (sliceNum < minSliceNum) { |
| LOG_W("Slice Number is too small"); |
| sliceNum = minSliceNum; |
| } |
| |
| if (sliceNum > maxSliceNum) { |
| LOG_W("Slice Number is too big"); |
| sliceNum = maxSliceNum; |
| } |
| |
| mSliceNum= sliceNum; |
| modulus = maxSliceNum % sliceNum; |
| sliceHeightInMB = (maxSliceNum - modulus) / sliceNum ; |
| |
| vaStatus = vaCreateBuffer( |
| mVADisplay, mVAContext, |
| VAEncSliceParameterBufferType, |
| sizeof(VAEncSliceParameterBufferH264), |
| sliceNum, NULL, |
| &mSliceParamBuf); |
| CHECK_VA_STATUS_RETURN("vaCreateBuffer"); |
| |
| VAEncSliceParameterBufferH264 *sliceParams, *currentSlice; |
| |
| vaStatus = vaMapBuffer(mVADisplay, mSliceParamBuf, (void **)&sliceParams); |
| CHECK_VA_STATUS_RETURN("vaMapBuffer"); |
| if(!sliceParams) |
| return ENCODE_NULL_PTR; |
| memset(sliceParams, 0 , sizeof(VAEncSliceParameterBufferH264)); |
| if(!sliceParams) |
| return ENCODE_NULL_PTR; |
| |
| currentSlice = sliceParams; |
| startRowInMB = 0; |
| for (sliceIndex = 0; sliceIndex < sliceNum; sliceIndex++) { |
| currentSlice = sliceParams + sliceIndex; |
| actualSliceHeightInMB = sliceHeightInMB; |
| if (sliceIndex < modulus) { |
| actualSliceHeightInMB ++; |
| } |
| |
| // starting MB row number for this slice, suppose macroblock 16x16 |
| currentSlice->macroblock_address = startRowInMB * ((mComParams.resolution.width + 0xf) & ~0xf) / 16; |
| // slice height measured in MB |
| currentSlice->num_macroblocks = actualSliceHeightInMB * ((mComParams.resolution.width + 0xf) & ~0xf) / 16; |
| if(task->type == FTYPE_I||task->type == FTYPE_IDR) |
| currentSlice->slice_type = 2; |
| else if(task->type == FTYPE_P) |
| currentSlice->slice_type = 0; |
| else if(task->type == FTYPE_B) |
| currentSlice->slice_type = 1; |
| currentSlice->disable_deblocking_filter_idc = mComParams.disableDeblocking; |
| |
| // This is a temporary fix suggested by Binglin for bad encoding quality issue |
| // TODO: We need a long term design for this field |
| //currentSlice->slice_flags.bits.uses_long_term_ref = 0; |
| //currentSlice->slice_flags.bits.is_long_term_ref = 0; |
| |
| LOG_V("======AVC slice params======\n"); |
| LOG_V( "slice_index = %d\n", (int) sliceIndex); |
| LOG_V( "macroblock_address = %d\n", (int) currentSlice->macroblock_address); |
| LOG_V( "slice_height_in_mb = %d\n", (int) currentSlice->num_macroblocks); |
| LOG_V( "slice.type = %d\n", (int) currentSlice->slice_type); |
| LOG_V("disable_deblocking_filter_idc = %d\n\n", (int) currentSlice->disable_deblocking_filter_idc); |
| |
| // Not sure whether these settings work for all drivers |
| currentSlice->pic_parameter_set_id = 0; |
| currentSlice->pic_order_cnt_lsb = mFrameNum * 2; |
| currentSlice->direct_spatial_mv_pred_flag = 0; |
| currentSlice->num_ref_idx_l0_active_minus1 = 0; /* FIXME: ??? */ |
| currentSlice->num_ref_idx_l1_active_minus1 = 0; |
| currentSlice->cabac_init_idc = 0; |
| currentSlice->slice_qp_delta = 0; |
| currentSlice->disable_deblocking_filter_idc = 0; |
| currentSlice->slice_alpha_c0_offset_div2 = 2; |
| currentSlice->slice_beta_offset_div2 = 2; |
| currentSlice->idr_pic_id = 0; |
| for (RefFrmIdx = 0; RefFrmIdx < 32; RefFrmIdx++) { |
| currentSlice->RefPicList0[RefFrmIdx].picture_id = VA_INVALID_ID; |
| currentSlice->RefPicList0[RefFrmIdx].flags = VA_PICTURE_H264_INVALID; |
| } |
| currentSlice->RefPicList0[0].picture_id = task->ref_surface; |
| currentSlice->RefPicList0[0].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE; |
| // Not sure whether these settings work for all drivers |
| |
| startRowInMB += actualSliceHeightInMB; |
| } |
| |
| vaStatus = vaUnmapBuffer(mVADisplay, mSliceParamBuf); |
| CHECK_VA_STATUS_RETURN("vaUnmapBuffer"); |
| |
| vaStatus = vaRenderPicture(mVADisplay, mVAContext, &mSliceParamBuf, 1); |
| CHECK_VA_STATUS_RETURN("vaRenderPicture"); |
| LOG_V( "end\n"); |
| return ENCODE_SUCCESS; |
| } |
