/*
* 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 "va_private.h"
#include "VideoDecoderAVCSecure.h"
#include "VideoDecoderTrace.h"
#include <string.h>
#define STARTCODE_PREFIX_LEN 3
#define NALU_TYPE_MASK 0x1F
#define MAX_NALU_HEADER_BUFFER 8192
static const uint8_t startcodePrefix[STARTCODE_PREFIX_LEN] = {0x00, 0x00, 0x01};
VideoDecoderAVCSecure::VideoDecoderAVCSecure(const char *mimeType)
: VideoDecoderAVC(mimeType),
mNaluHeaderBuffer(NULL),
mSliceHeaderBuffer(NULL) {
setParserType(VBP_H264SECURE);
}
VideoDecoderAVCSecure::~VideoDecoderAVCSecure() {
}
Decode_Status VideoDecoderAVCSecure::start(VideoConfigBuffer *buffer) {
Decode_Status status = VideoDecoderAVC::start(buffer);
if (status != DECODE_SUCCESS) {
return status;
}
mNaluHeaderBuffer = new uint8_t [MAX_NALU_HEADER_BUFFER];
if (mNaluHeaderBuffer == NULL) {
ETRACE("Failed to allocate memory for mNaluHeaderBuffer");
return DECODE_MEMORY_FAIL;
}
mSliceHeaderBuffer = new uint8_t [MAX_NALU_HEADER_BUFFER];
if (mSliceHeaderBuffer == NULL) {
ETRACE("Failed to allocate memory for mSliceHeaderBuffer");
if (mNaluHeaderBuffer) {
delete [] mNaluHeaderBuffer;
mNaluHeaderBuffer = NULL;
}
return DECODE_MEMORY_FAIL;
}
return status;
}
void VideoDecoderAVCSecure::stop(void) {
VideoDecoderAVC::stop();
if (mNaluHeaderBuffer) {
delete [] mNaluHeaderBuffer;
mNaluHeaderBuffer = NULL;
}
if (mSliceHeaderBuffer) {
delete [] mSliceHeaderBuffer;
mSliceHeaderBuffer = NULL;
}
}
Decode_Status VideoDecoderAVCSecure::decode(VideoDecodeBuffer *buffer) {
Decode_Status status;
int32_t sizeAccumulated = 0;
int32_t sliceHeaderSize = 0;
int32_t sizeLeft = 0;
int32_t sliceIdx = 0;
uint8_t naluType;
frame_info_t* pFrameInfo;
mFrameSize = 0;
if (buffer->flag & IS_SECURE_DATA) {
VTRACE("Decoding protected video ...");
mIsEncryptData = 1;
} else {
VTRACE("Decoding clear video ...");
mIsEncryptData = 0;
return VideoDecoderAVC::decode(buffer);
}
if (buffer->size != sizeof(frame_info_t)) {
ETRACE("Not enough data to read frame_info_t!");
return DECODE_INVALID_DATA;
}
pFrameInfo = (frame_info_t*) buffer->data;
mFrameSize = pFrameInfo->length;
VTRACE("mFrameSize = %d", mFrameSize);
memcpy(&mEncParam, pFrameInfo->pavp, sizeof(pavp_info_t));
for (int32_t i = 0; i < pFrameInfo->num_nalus; i++) {
naluType = pFrameInfo->nalus[i].type & NALU_TYPE_MASK;
if (naluType >= h264_NAL_UNIT_TYPE_SLICE && naluType <= h264_NAL_UNIT_TYPE_IDR) {
memcpy(mSliceHeaderBuffer + sliceHeaderSize,
&sliceIdx,
sizeof(int32_t));
sliceHeaderSize += 4;
memcpy(mSliceHeaderBuffer + sliceHeaderSize,
&pFrameInfo->data,
sizeof(uint8_t*));
sliceHeaderSize += sizeof(uint8_t*);
memcpy(mSliceHeaderBuffer + sliceHeaderSize,
&pFrameInfo->nalus[i].offset,
sizeof(uint32_t));
sliceHeaderSize += sizeof(uint32_t);
memcpy(mSliceHeaderBuffer + sliceHeaderSize,
&pFrameInfo->nalus[i].length,
sizeof(uint32_t));
sliceHeaderSize += sizeof(uint32_t);
memcpy(mSliceHeaderBuffer + sliceHeaderSize,
pFrameInfo->nalus[i].slice_header,
sizeof(slice_header_t));
sliceHeaderSize += sizeof(slice_header_t);
if (pFrameInfo->nalus[i].type & 0x60) {
memcpy(mSliceHeaderBuffer+sliceHeaderSize, pFrameInfo->dec_ref_pic_marking, sizeof(dec_ref_pic_marking_t));
} else {
memset(mSliceHeaderBuffer+sliceHeaderSize, 0, sizeof(dec_ref_pic_marking_t));
}
sliceHeaderSize += sizeof(dec_ref_pic_marking_t);
sliceIdx++;
} else if (naluType >= h264_NAL_UNIT_TYPE_SEI && naluType <= h264_NAL_UNIT_TYPE_PPS) {
memcpy(mNaluHeaderBuffer + sizeAccumulated,
startcodePrefix,
STARTCODE_PREFIX_LEN);
sizeAccumulated += STARTCODE_PREFIX_LEN;
memcpy(mNaluHeaderBuffer + sizeAccumulated,
pFrameInfo->nalus[i].data,
pFrameInfo->nalus[i].length);
sizeAccumulated += pFrameInfo->nalus[i].length;
} else {
WTRACE("Failure: DECODE_FRAME_DROPPED");
return DECODE_FRAME_DROPPED;
}
}
vbp_data_h264 *data = NULL;
int new_sequence_to_handle = 0;
if (sizeAccumulated > 0) {
status = VideoDecoderBase::parseBuffer(
mNaluHeaderBuffer,
sizeAccumulated,
false,
(void**)&data);
CHECK_STATUS("VideoDecoderBase::parseBuffer");
// [FIX DRC zoom issue] if one buffer contains more than one nalu
// for example SPS+PPS+IDR, new_sps/new_pps flags set in parseBuffer
// will be flushed in the following updateBuffer.
// So that handleNewSequence will not be handled in decodeFrame()
if (data->new_sps || data->new_pps) {
new_sequence_to_handle = 1;
}
}
if (sliceHeaderSize > 0) {
memset(mSliceHeaderBuffer + sliceHeaderSize, 0xFF, 4);
sliceHeaderSize += 4;
status = VideoDecoderBase::updateBuffer(
mSliceHeaderBuffer,
sliceHeaderSize,
(void**)&data);
CHECK_STATUS("VideoDecoderBase::updateBuffer");
// in case the flags were flushed but indeed new sequence needed to be handled.
if ((1 == new_sequence_to_handle) &&
((data->new_sps == 0) || (data->new_pps == 0))) {
data->new_sps = 1;
data->new_pps = 1;
}
}
if (data == NULL) {
ETRACE("Invalid data returned by parser!");
return DECODE_MEMORY_FAIL;
}
if (!mVAStarted) {
if (data->has_sps && data->has_pps) {
status = startVA(data);
CHECK_STATUS("startVA");
} else {
WTRACE("Can't start VA as either SPS or PPS is still not available.");
return DECODE_SUCCESS;
}
}
status = decodeFrame(buffer, data);
return status;
}
Decode_Status VideoDecoderAVCSecure::decodeSlice(vbp_data_h264 *data, uint32_t picIndex, uint32_t sliceIndex) {
Decode_Status status;
VAStatus vaStatus;
uint32_t bufferIDCount = 0;
// maximum 4 buffers to render a slice: picture parameter, IQMatrix, slice parameter, slice data
VABufferID bufferIDs[5];
vbp_picture_data_h264 *picData = &(data->pic_data[picIndex]);
vbp_slice_data_h264 *sliceData = &(picData->slc_data[sliceIndex]);
VAPictureParameterBufferH264 *picParam = picData->pic_parms;
VASliceParameterBufferH264 *sliceParam = &(sliceData->slc_parms);
VAEncryptionParameterBuffer encryptParam;
if (sliceParam->first_mb_in_slice == 0 || mDecodingFrame == false) {
// either condition indicates start of a new frame
if (sliceParam->first_mb_in_slice != 0) {
WTRACE("The first slice is lost.");
// TODO: handle the first slice lost
}
if (mDecodingFrame) {
// interlace content, complete decoding the first field
vaStatus = vaEndPicture(mVADisplay, mVAContext);
CHECK_VA_STATUS("vaEndPicture");
// for interlace content, top field may be valid only after the second field is parsed
mAcquiredBuffer->pictureOrder= picParam->CurrPic.TopFieldOrderCnt;
}
// Update the reference frames and surface IDs for DPB and current frame
status = updateDPB(picParam);
CHECK_STATUS("updateDPB");
vaStatus = vaBeginPicture(mVADisplay, mVAContext, mAcquiredBuffer->renderBuffer.surface);
CHECK_VA_STATUS("vaBeginPicture");
// start decoding a frame
mDecodingFrame = true;
vaStatus = vaCreateBuffer(
mVADisplay,
mVAContext,
VAPictureParameterBufferType,
sizeof(VAPictureParameterBufferH264),
1,
picParam,
&bufferIDs[bufferIDCount]);
CHECK_VA_STATUS("vaCreatePictureParameterBuffer");
bufferIDCount++;
vaStatus = vaCreateBuffer(
mVADisplay,
mVAContext,
VAIQMatrixBufferType,
sizeof(VAIQMatrixBufferH264),
1,
data->IQ_matrix_buf,
&bufferIDs[bufferIDCount]);
CHECK_VA_STATUS("vaCreateIQMatrixBuffer");
bufferIDCount++;
if (mIsEncryptData) {
memset(&encryptParam, 0, sizeof(VAEncryptionParameterBuffer));
encryptParam.pavpCounterMode = 4;
encryptParam.pavpEncryptionType = 2;
encryptParam.hostEncryptMode = 2;
encryptParam.pavpHasBeenEnabled = 1;
encryptParam.app_id = 0;
memcpy(encryptParam.pavpAesCounter, mEncParam.iv, 16);
vaStatus = vaCreateBuffer(
mVADisplay,
mVAContext,
(VABufferType)VAEncryptionParameterBufferType,
sizeof(VAEncryptionParameterBuffer),
1,
&encryptParam,
&bufferIDs[bufferIDCount]);
CHECK_VA_STATUS("vaCreateEncryptionParameterBuffer");
bufferIDCount++;
}
vaStatus = vaCreateBuffer(
mVADisplay,
mVAContext,
VASliceDataBufferType,
mFrameSize, //size
1, //num_elements
sliceData->buffer_addr + sliceData->slice_offset,
&bufferIDs[bufferIDCount]);
CHECK_VA_STATUS("vaCreateSliceDataBuffer");
bufferIDCount++;
}
vaStatus = vaCreateBuffer(
mVADisplay,
mVAContext,
VASliceParameterBufferType,
sizeof(VASliceParameterBufferH264Base),
1,
sliceParam,
&bufferIDs[bufferIDCount]);
CHECK_VA_STATUS("vaCreateSliceParameterBuffer");
bufferIDCount++;
vaStatus = vaRenderPicture(
mVADisplay,
mVAContext,
bufferIDs,
bufferIDCount);
CHECK_VA_STATUS("vaRenderPicture");
return DECODE_SUCCESS;
}
Decode_Status VideoDecoderAVCSecure::getCodecSpecificConfigs(
VAProfile profile, VAConfigID *config)
{
VAStatus vaStatus;
VAConfigAttrib attrib[2];
if (config == NULL) {
ETRACE("Invalid parameter!");
return DECODE_FAIL;
}
attrib[0].type = VAConfigAttribRTFormat;
attrib[0].value = VA_RT_FORMAT_YUV420;
attrib[1].type = VAConfigAttribDecSliceMode;
attrib[1].value = VA_DEC_SLICE_MODE_NORMAL;
vaStatus = vaGetConfigAttributes(mVADisplay,profile,VAEntrypointVLD, &attrib[1], 1);
if (attrib[1].value & VA_DEC_SLICE_MODE_BASE)
{
ITRACE("AVC short format used");
attrib[1].value = VA_DEC_SLICE_MODE_BASE;
} else if (attrib[1].value & VA_DEC_SLICE_MODE_NORMAL) {
ITRACE("AVC long format ssed");
attrib[1].value = VA_DEC_SLICE_MODE_NORMAL;
} else {
ETRACE("Unsupported Decode Slice Mode!");
return DECODE_FAIL;
}
vaStatus = vaCreateConfig(
mVADisplay,
profile,
VAEntrypointVLD,
&attrib[0],
2,
config);
CHECK_VA_STATUS("vaCreateConfig");
return DECODE_SUCCESS;
}