Home | History | Annotate | Download | only in moorefield 
      1 /*
      2 * Copyright (c) 2009-2011 Intel Corporation.  All rights reserved.
      3 *
      4 * Licensed under the Apache License, Version 2.0 (the "License");
      5 * you may not use this file except in compliance with the License.
      6 * You may obtain a copy of the License at
      7 *
      8 * http://www.apache.org/licenses/LICENSE-2.0
      9 *
     10 * Unless required by applicable law or agreed to in writing, software
     11 * distributed under the License is distributed on an "AS IS" BASIS,
     12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 * See the License for the specific language governing permissions and
     14 * limitations under the License.
     15 */
     16 
     17 #include <va/va.h>
     18 #include "VideoDecoderBase.h"
     19 #include "VideoDecoderAVC.h"
     20 #include "VideoDecoderTrace.h"
     21 #include "vbp_loader.h"
     22 #include "VideoDecoderAVCSecure.h"
     23 #include "VideoFrameInfo.h"
     24 
     25 #include <string.h>
     26 
     27 #define MAX_SLICEHEADER_BUFFER_SIZE 4096
     28 #define STARTCODE_PREFIX_LEN        3
     29 #define NALU_TYPE_MASK              0x1F
     30 #define MAX_NALU_HEADER_BUFFER      8192
     31 static const uint8_t startcodePrefix[STARTCODE_PREFIX_LEN] = {0x00, 0x00, 0x01};
     32 
     33 /* H264 start code values */
     34 typedef enum _h264_nal_unit_type
     35 {
     36     h264_NAL_UNIT_TYPE_unspecified = 0,
     37     h264_NAL_UNIT_TYPE_SLICE,
     38     h264_NAL_UNIT_TYPE_DPA,
     39     h264_NAL_UNIT_TYPE_DPB,
     40     h264_NAL_UNIT_TYPE_DPC,
     41     h264_NAL_UNIT_TYPE_IDR,
     42     h264_NAL_UNIT_TYPE_SEI,
     43     h264_NAL_UNIT_TYPE_SPS,
     44     h264_NAL_UNIT_TYPE_PPS,
     45     h264_NAL_UNIT_TYPE_Acc_unit_delimiter,
     46     h264_NAL_UNIT_TYPE_EOSeq,
     47     h264_NAL_UNIT_TYPE_EOstream,
     48     h264_NAL_UNIT_TYPE_filler_data,
     49     h264_NAL_UNIT_TYPE_SPS_extension,
     50     h264_NAL_UNIT_TYPE_ACP = 19,
     51     h264_NAL_UNIT_TYPE_Slice_extension = 20
     52 } h264_nal_unit_type_t;
     53 
     54 VideoDecoderAVCSecure::VideoDecoderAVCSecure(const char *mimeType)
     55     : VideoDecoderAVC(mimeType){
     56     mFrameSize     = 0;
     57     mFrameData     = NULL;
     58     mIsEncryptData = 0;
     59     mClearData     = NULL;
     60     mCachedHeader  = NULL;
     61     setParserType(VBP_H264SECURE);
     62     mFrameIdx = 0;
     63     mModularMode = 0;
     64     mSliceNum = 0;
     65 }
     66 
     67 Decode_Status VideoDecoderAVCSecure::start(VideoConfigBuffer *buffer) {
     68     VTRACE("VideoDecoderAVCSecure::start");
     69 
     70     Decode_Status status = VideoDecoderAVC::start(buffer);
     71     if (status != DECODE_SUCCESS) {
     72         return status;
     73     }
     74 
     75     mClearData = new uint8_t [MAX_NALU_HEADER_BUFFER];
     76     if (mClearData == NULL) {
     77         ETRACE("Failed to allocate memory for mClearData");
     78         return DECODE_MEMORY_FAIL;
     79     }
     80 
     81     mCachedHeader= new uint8_t [MAX_SLICEHEADER_BUFFER_SIZE];
     82     if (mCachedHeader == NULL) {
     83         ETRACE("Failed to allocate memory for mCachedHeader");
     84         return DECODE_MEMORY_FAIL;
     85     }
     86 
     87     return status;
     88 }
     89 
     90 void VideoDecoderAVCSecure::stop(void) {
     91     VTRACE("VideoDecoderAVCSecure::stop");
     92     VideoDecoderAVC::stop();
     93 
     94     if (mClearData) {
     95         delete [] mClearData;
     96         mClearData = NULL;
     97     }
     98 
     99     if (mCachedHeader) {
    100         delete [] mCachedHeader;
    101         mCachedHeader = NULL;
    102     }
    103 }
    104 Decode_Status VideoDecoderAVCSecure::processModularInputBuffer(VideoDecodeBuffer *buffer, vbp_data_h264 **data)
    105 {
    106     VTRACE("processModularInputBuffer +++");
    107     Decode_Status status;
    108     int32_t clear_data_size = 0;
    109     uint8_t *clear_data = NULL;
    110 
    111     int32_t nalu_num = 0;
    112     uint8_t nalu_type = 0;
    113     int32_t nalu_offset = 0;
    114     uint32_t nalu_size = 0;
    115     uint8_t naluType = 0;
    116     uint8_t *nalu_data = NULL;
    117     uint32_t sliceidx = 0;
    118 
    119     frame_info_t *pFrameInfo = NULL;
    120     mSliceNum = 0;
    121     memset(&mSliceInfo, 0, sizeof(mSliceInfo));
    122     mIsEncryptData = 0;
    123 
    124     if (buffer->flag & IS_SECURE_DATA) {
    125         VTRACE("Decoding protected video ...");
    126         pFrameInfo = (frame_info_t *) buffer->data;
    127         if (pFrameInfo == NULL) {
    128             ETRACE("Invalid parameter: pFrameInfo is NULL!");
    129             return DECODE_MEMORY_FAIL;
    130         }
    131 
    132         mFrameData = (uint8_t *)pFrameInfo + pFrameInfo->data_offset_from_frameinfo;
    133         mFrameSize = pFrameInfo->size;
    134         VTRACE("mFrameData = %p, mFrameSize = %d", mFrameData, mFrameSize);
    135 
    136         nalu_num  = pFrameInfo->num_nalus;
    137         VTRACE("nalu_num = %d", nalu_num);
    138 
    139         if (nalu_num <= 0 || nalu_num >= MAX_NUM_NALUS) {
    140             ETRACE("Invalid parameter: nalu_num = %d", nalu_num);
    141             return DECODE_MEMORY_FAIL;
    142         }
    143 
    144         for (int32_t i = 0; i < nalu_num; i++) {
    145 
    146             nalu_size = pFrameInfo->nalus[i].length;
    147             nalu_type = pFrameInfo->nalus[i].type;
    148             nalu_offset = pFrameInfo->nalus[i].offset;
    149             nalu_data = ((uint8_t *)pFrameInfo) + pFrameInfo->nalus[i].data_offset_from_frameinfo;
    150             naluType  = nalu_type & NALU_TYPE_MASK;
    151 
    152             VTRACE("nalu_type = 0x%x, nalu_size = %d, nalu_offset = 0x%x", nalu_type, nalu_size, nalu_offset);
    153 
    154             // FIXME: this is a w/a to handle the case when two frame data was wrongly packed into one buffer
    155             // especially IDR + Slice. let it gracefully quit.
    156             if ((naluType == h264_NAL_UNIT_TYPE_SLICE) && (i > 0)) {
    157                 uint8_t former_naluType = pFrameInfo->nalus[i-1].type & NALU_TYPE_MASK;
    158                 if (former_naluType == h264_NAL_UNIT_TYPE_IDR) {
    159                     ETRACE("Invalid parameter: IDR slice + SLICE in one buffer");
    160                     break; // abandon this slice
    161                 }
    162             }
    163 
    164             if (naluType >= h264_NAL_UNIT_TYPE_SLICE && naluType <= h264_NAL_UNIT_TYPE_IDR) {
    165 
    166                 mIsEncryptData = 1;
    167                 VTRACE("slice idx = %d", sliceidx);
    168                 mSliceInfo[sliceidx].sliceHeaderByte = nalu_type;
    169                 mSliceInfo[sliceidx].sliceStartOffset = (nalu_offset >> 4) << 4;
    170                 mSliceInfo[sliceidx].sliceByteOffset = nalu_offset - mSliceInfo[sliceidx].sliceStartOffset;
    171                 mSliceInfo[sliceidx].sliceLength = mSliceInfo[sliceidx].sliceByteOffset + nalu_size;
    172                 mSliceInfo[sliceidx].sliceSize = (mSliceInfo[sliceidx].sliceByteOffset + nalu_size + 0xF) & ~0xF;
    173                 VTRACE("sliceHeaderByte = 0x%x", mSliceInfo[sliceidx].sliceHeaderByte);
    174                 VTRACE("sliceStartOffset = %d", mSliceInfo[sliceidx].sliceStartOffset);
    175                 VTRACE("sliceByteOffset = %d", mSliceInfo[sliceidx].sliceByteOffset);
    176                 VTRACE("sliceSize = %d", mSliceInfo[sliceidx].sliceSize);
    177                 VTRACE("sliceLength = %d", mSliceInfo[sliceidx].sliceLength);
    178 
    179 #if 0
    180                 uint32_t testsize;
    181                 uint8_t *testdata;
    182                 testsize = mSliceInfo[sliceidx].sliceSize > 64 ? 64 : mSliceInfo[sliceidx].sliceSize ;
    183                 testdata = (uint8_t *)(mFrameData);
    184                 for (int i = 0; i < testsize; i++) {
    185                     VTRACE("testdata[%d] = 0x%x", i, testdata[i]);
    186                 }
    187 #endif
    188                 sliceidx++;
    189 
    190             } else if (naluType == h264_NAL_UNIT_TYPE_SPS || naluType == h264_NAL_UNIT_TYPE_PPS) {
    191                 if (nalu_data == NULL) {
    192                     ETRACE("Invalid parameter: nalu_data = NULL for naluType 0x%x", naluType);
    193                     return DECODE_MEMORY_FAIL;
    194                 }
    195                 memcpy(mClearData + clear_data_size,
    196                     nalu_data,
    197                     nalu_size);
    198                 clear_data_size += nalu_size;
    199             } else {
    200                 ITRACE("Nalu type = 0x%x is skipped", naluType);
    201                 continue;
    202             }
    203         }
    204         clear_data = mClearData;
    205         mSliceNum = sliceidx;
    206 
    207     } else {
    208         VTRACE("Decoding clear video ...");
    209         mIsEncryptData = 0;
    210         mFrameSize = buffer->size;
    211         mFrameData = (uint8_t *)pFrameInfo + (int)pFrameInfo->data_offset_from_frameinfo;
    212         clear_data = (uint8_t *)pFrameInfo + (int)pFrameInfo->data_offset_from_frameinfo;
    213         clear_data_size = buffer->size;
    214     }
    215 
    216     if (clear_data_size > 0) {
    217         status =  VideoDecoderBase::parseBuffer(
    218                 clear_data,
    219                 clear_data_size,
    220                 false,
    221                 (void**)data);
    222         CHECK_STATUS("VideoDecoderBase::parseBuffer");
    223     } else {
    224         status =  VideoDecoderBase::queryBuffer((void**)data);
    225         CHECK_STATUS("VideoDecoderBase::queryBuffer");
    226     }
    227     return DECODE_SUCCESS;
    228 }
    229 
    230 Decode_Status VideoDecoderAVCSecure::processClassicInputBuffer(VideoDecodeBuffer *buffer, vbp_data_h264 **data)
    231 {
    232     Decode_Status status;
    233     int32_t clear_data_size = 0;
    234     uint8_t *clear_data = NULL;
    235     uint8_t naluType = 0;
    236 
    237     int32_t num_nalus;
    238     int32_t offset;
    239     uint8_t *data_src;
    240     uint8_t *nalu_data;
    241     uint32_t nalu_size;
    242 
    243     if (buffer->flag & IS_SECURE_DATA) {
    244         VTRACE("Decoding protected video ...");
    245         mIsEncryptData = 1;
    246 
    247         mFrameData = buffer->data;
    248         mFrameSize = buffer->size;
    249         VTRACE("mFrameData = %p, mFrameSize = %d", mFrameData, mFrameSize);
    250         num_nalus  = *(uint32_t *)(buffer->data + buffer->size + sizeof(uint32_t));
    251         VTRACE("num_nalus = %d", num_nalus);
    252         offset = 4;
    253         for (int32_t i = 0; i < num_nalus; i++) {
    254             VTRACE("%d nalu, offset = %d", i, offset);
    255             data_src = buffer->data + buffer->size + sizeof(uint32_t) + offset;
    256             nalu_size = *(uint32_t *)(data_src + 2 * sizeof(uint32_t));
    257             nalu_size = (nalu_size + 0x03) & (~0x03);
    258 
    259             nalu_data = data_src + 3 *sizeof(uint32_t);
    260             naluType  = nalu_data[0] & NALU_TYPE_MASK;
    261             offset += nalu_size + 3 *sizeof(uint32_t);
    262             VTRACE("naluType = 0x%x", naluType);
    263             VTRACE("nalu_size = %d, nalu_data = %p", nalu_size, nalu_data);
    264 
    265             if (naluType >= h264_NAL_UNIT_TYPE_SLICE && naluType <= h264_NAL_UNIT_TYPE_IDR) {
    266                 ETRACE("Slice NALU received!");
    267                 return DECODE_INVALID_DATA;
    268             }
    269 
    270             else if (naluType >= h264_NAL_UNIT_TYPE_SEI && naluType <= h264_NAL_UNIT_TYPE_PPS) {
    271                 memcpy(mClearData + clear_data_size,
    272                     startcodePrefix,
    273                     STARTCODE_PREFIX_LEN);
    274                 clear_data_size += STARTCODE_PREFIX_LEN;
    275                 memcpy(mClearData + clear_data_size,
    276                     nalu_data,
    277                     nalu_size);
    278                 clear_data_size += nalu_size;
    279             } else {
    280                 ETRACE("Failure: DECODE_FRAME_DROPPED");
    281                 return DECODE_FRAME_DROPPED;
    282             }
    283         }
    284         clear_data = mClearData;
    285     } else {
    286         VTRACE("Decoding clear video ...");
    287         mIsEncryptData = 0;
    288         mFrameSize = buffer->size;
    289         mFrameData = buffer->data;
    290         clear_data = buffer->data;
    291         clear_data_size = buffer->size;
    292     }
    293 
    294     if (clear_data_size > 0) {
    295         status =  VideoDecoderBase::parseBuffer(
    296                 clear_data,
    297                 clear_data_size,
    298                 false,
    299                 (void**)data);
    300         CHECK_STATUS("VideoDecoderBase::parseBuffer");
    301     } else {
    302         status =  VideoDecoderBase::queryBuffer((void**)data);
    303         CHECK_STATUS("VideoDecoderBase::queryBuffer");
    304     }
    305     return DECODE_SUCCESS;
    306 }
    307 
    308 Decode_Status VideoDecoderAVCSecure::decode(VideoDecodeBuffer *buffer) {
    309     VTRACE("VideoDecoderAVCSecure::decode");
    310     Decode_Status status;
    311     vbp_data_h264 *data = NULL;
    312     if (buffer == NULL) {
    313         return DECODE_INVALID_DATA;
    314     }
    315 
    316 #if 0
    317     uint32_t testsize;
    318     uint8_t *testdata;
    319     testsize = buffer->size > 16 ? 16:buffer->size ;
    320     testdata = (uint8_t *)(buffer->data);
    321     for (int i = 0; i < 16; i++) {
    322         VTRACE("testdata[%d] = 0x%x", i, testdata[i]);
    323     }
    324 #endif
    325     if (buffer->flag & IS_SUBSAMPLE_ENCRYPTION) {
    326         mModularMode = 1;
    327     }
    328 
    329     if (mModularMode) {
    330         status = processModularInputBuffer(buffer,&data);
    331         CHECK_STATUS("processModularInputBuffer");
    332     }
    333     else {
    334         status = processClassicInputBuffer(buffer,&data);
    335         CHECK_STATUS("processClassicInputBuffer");
    336     }
    337 
    338     if (!mVAStarted) {
    339          if (data->has_sps && data->has_pps) {
    340             status = startVA(data);
    341             CHECK_STATUS("startVA");
    342         } else {
    343             WTRACE("Can't start VA as either SPS or PPS is still not available.");
    344             return DECODE_SUCCESS;
    345         }
    346     }
    347 
    348     status = decodeFrame(buffer, data);
    349 
    350     return status;
    351 }
    352 
    353 Decode_Status VideoDecoderAVCSecure::decodeFrame(VideoDecodeBuffer *buffer, vbp_data_h264 *data) {
    354     VTRACE("VideoDecoderAVCSecure::decodeFrame");
    355     Decode_Status status;
    356     VTRACE("data->has_sps = %d, data->has_pps = %d", data->has_sps, data->has_pps);
    357 
    358 #if 0
    359     // Don't remove the following codes, it can be enabled for debugging DPB.
    360     for (unsigned int i = 0; i < data->num_pictures; i++) {
    361         VAPictureH264 &pic = data->pic_data[i].pic_parms->CurrPic;
    362         VTRACE("%d: decoding frame %.2f, poc top = %d, poc bottom = %d, flags = %d,  reference = %d",
    363                 i,
    364                 buffer->timeStamp/1E6,
    365                 pic.TopFieldOrderCnt,
    366                 pic.BottomFieldOrderCnt,
    367                 pic.flags,
    368                 (pic.flags & VA_PICTURE_H264_SHORT_TERM_REFERENCE) ||
    369                 (pic.flags & VA_PICTURE_H264_LONG_TERM_REFERENCE));
    370     }
    371 #endif
    372 
    373     if (data->new_sps || data->new_pps) {
    374         status = handleNewSequence(data);
    375         CHECK_STATUS("handleNewSequence");
    376     }
    377 
    378     if (mModularMode && (!mIsEncryptData)) {
    379         if (data->pic_data[0].num_slices == 0) {
    380             ITRACE("No slice available for decoding.");
    381             status = mSizeChanged ? DECODE_FORMAT_CHANGE : DECODE_SUCCESS;
    382             mSizeChanged = false;
    383             return status;
    384         }
    385     }
    386 
    387     uint64_t lastPTS = mCurrentPTS;
    388     mCurrentPTS = buffer->timeStamp;
    389 
    390     // start decoding a new frame
    391     status = acquireSurfaceBuffer();
    392     CHECK_STATUS("acquireSurfaceBuffer");
    393 
    394     if (mModularMode) {
    395         status = parseModularSliceHeader(data);
    396         if (status != DECODE_SUCCESS)
    397             status = parseModularSliceHeader(data);
    398     }
    399     else {
    400         status = parseClassicSliceHeader(data);
    401     }
    402 
    403     if (status != DECODE_SUCCESS) {
    404         endDecodingFrame(true);
    405         if (status == DECODE_PARSER_FAIL) {
    406             ETRACE("parse frame failed with DECODE_PARSER_FAIL");
    407             status = DECODE_INVALID_DATA;
    408         }
    409         return status;
    410     }
    411 
    412     status = beginDecodingFrame(data);
    413     CHECK_STATUS("beginDecodingFrame");
    414 
    415    // finish decoding the last frame
    416     status = endDecodingFrame(false);
    417     CHECK_STATUS("endDecodingFrame");
    418 
    419     if (isNewFrame(data, lastPTS == mCurrentPTS) == 0) {
    420         ETRACE("Can't handle interlaced frames yet");
    421         return DECODE_FAIL;
    422     }
    423 
    424     return DECODE_SUCCESS;
    425 }
    426 
    427 Decode_Status VideoDecoderAVCSecure::beginDecodingFrame(vbp_data_h264 *data) {
    428     VTRACE("VideoDecoderAVCSecure::beginDecodingFrame");
    429     Decode_Status status;
    430     VAPictureH264 *picture = &(data->pic_data[0].pic_parms->CurrPic);
    431     if ((picture->flags & VA_PICTURE_H264_SHORT_TERM_REFERENCE) ||
    432         (picture->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE)) {
    433         mAcquiredBuffer->referenceFrame = true;
    434     } else {
    435         mAcquiredBuffer->referenceFrame = false;
    436     }
    437 
    438     if (picture->flags & VA_PICTURE_H264_TOP_FIELD) {
    439         mAcquiredBuffer->renderBuffer.scanFormat = VA_BOTTOM_FIELD | VA_TOP_FIELD;
    440     } else {
    441         mAcquiredBuffer->renderBuffer.scanFormat = VA_FRAME_PICTURE;
    442     }
    443 
    444     mAcquiredBuffer->renderBuffer.flag = 0;
    445     mAcquiredBuffer->renderBuffer.timeStamp = mCurrentPTS;
    446     mAcquiredBuffer->pictureOrder = getPOC(picture);
    447 
    448     if (mSizeChanged) {
    449         mAcquiredBuffer->renderBuffer.flag |= IS_RESOLUTION_CHANGE;
    450         mSizeChanged = false;
    451     }
    452 
    453     status  = continueDecodingFrame(data);
    454     return status;
    455 }
    456 
    457 Decode_Status VideoDecoderAVCSecure::continueDecodingFrame(vbp_data_h264 *data) {
    458     VTRACE("VideoDecoderAVCSecure::continueDecodingFrame");
    459     Decode_Status status;
    460     vbp_picture_data_h264 *picData = data->pic_data;
    461 
    462     if (mAcquiredBuffer == NULL || mAcquiredBuffer->renderBuffer.surface == VA_INVALID_SURFACE) {
    463         ETRACE("mAcquiredBuffer is NULL. Implementation bug.");
    464         return DECODE_FAIL;
    465     }
    466     VTRACE("data->num_pictures = %d", data->num_pictures);
    467     for (uint32_t picIndex = 0; picIndex < data->num_pictures; picIndex++, picData++) {
    468         if (picData == NULL || picData->pic_parms == NULL || picData->slc_data == NULL || picData->num_slices == 0) {
    469             return DECODE_PARSER_FAIL;
    470         }
    471 
    472         if (picIndex > 0 &&
    473             (picData->pic_parms->CurrPic.flags & (VA_PICTURE_H264_TOP_FIELD | VA_PICTURE_H264_BOTTOM_FIELD)) == 0) {
    474             ETRACE("Packed frame is not supported yet!");
    475             return DECODE_FAIL;
    476         }
    477         VTRACE("picData->num_slices = %d", picData->num_slices);
    478         for (uint32_t sliceIndex = 0; sliceIndex < picData->num_slices; sliceIndex++) {
    479             status = decodeSlice(data, picIndex, sliceIndex);
    480             if (status != DECODE_SUCCESS) {
    481                 endDecodingFrame(true);
    482                 // remove current frame from DPB as it can't be decoded.
    483                 removeReferenceFromDPB(picData->pic_parms);
    484                 return status;
    485             }
    486         }
    487     }
    488     mDecodingFrame = true;
    489 
    490     return DECODE_SUCCESS;
    491 }
    492 
    493 Decode_Status VideoDecoderAVCSecure::parseClassicSliceHeader(vbp_data_h264 *data) {
    494     Decode_Status status;
    495     VAStatus vaStatus;
    496 
    497     VABufferID sliceheaderbufferID;
    498     VABufferID pictureparameterparsingbufferID;
    499     VABufferID mSlicebufferID;
    500 
    501     if (mFrameSize <= 0) {
    502         return DECODE_SUCCESS;
    503     }
    504     vaStatus = vaBeginPicture(mVADisplay, mVAContext, mAcquiredBuffer->renderBuffer.surface);
    505     CHECK_VA_STATUS("vaBeginPicture");
    506 
    507     vaStatus = vaCreateBuffer(
    508         mVADisplay,
    509         mVAContext,
    510         VAParseSliceHeaderGroupBufferType,
    511         MAX_SLICEHEADER_BUFFER_SIZE,
    512         1,
    513         NULL,
    514         &sliceheaderbufferID);
    515     CHECK_VA_STATUS("vaCreateSliceHeaderGroupBuffer");
    516 
    517     void *sliceheaderbuf;
    518     vaStatus = vaMapBuffer(
    519         mVADisplay,
    520         sliceheaderbufferID,
    521         &sliceheaderbuf);
    522     CHECK_VA_STATUS("vaMapBuffer");
    523 
    524     memset(sliceheaderbuf, 0, MAX_SLICEHEADER_BUFFER_SIZE);
    525 
    526     vaStatus = vaUnmapBuffer(
    527         mVADisplay,
    528         sliceheaderbufferID);
    529     CHECK_VA_STATUS("vaUnmapBuffer");
    530 
    531 
    532     vaStatus = vaCreateBuffer(
    533         mVADisplay,
    534         mVAContext,
    535         VASliceDataBufferType,
    536         mFrameSize, //size
    537         1,        //num_elements
    538         mFrameData,
    539         &mSlicebufferID);
    540     CHECK_VA_STATUS("vaCreateSliceDataBuffer");
    541 
    542     data->pic_parse_buffer->frame_buf_id = mSlicebufferID;
    543     data->pic_parse_buffer->slice_headers_buf_id = sliceheaderbufferID;
    544     data->pic_parse_buffer->frame_size = mFrameSize;
    545     data->pic_parse_buffer->slice_headers_size = MAX_SLICEHEADER_BUFFER_SIZE;
    546 
    547 #if 0
    548 
    549     VTRACE("flags.bits.frame_mbs_only_flag = %d", data->pic_parse_buffer->flags.bits.frame_mbs_only_flag);
    550     VTRACE("flags.bits.pic_order_present_flag = %d", data->pic_parse_buffer->flags.bits.pic_order_present_flag);
    551     VTRACE("flags.bits.delta_pic_order_always_zero_flag = %d", data->pic_parse_buffer->flags.bits.delta_pic_order_always_zero_flag);
    552     VTRACE("flags.bits.redundant_pic_cnt_present_flag = %d", data->pic_parse_buffer->flags.bits.redundant_pic_cnt_present_flag);
    553     VTRACE("flags.bits.weighted_pred_flag = %d", data->pic_parse_buffer->flags.bits.weighted_pred_flag);
    554     VTRACE("flags.bits.entropy_coding_mode_flag = %d", data->pic_parse_buffer->flags.bits.entropy_coding_mode_flag);
    555     VTRACE("flags.bits.deblocking_filter_control_present_flag = %d", data->pic_parse_buffer->flags.bits.deblocking_filter_control_present_flag);
    556     VTRACE("flags.bits.weighted_bipred_idc = %d", data->pic_parse_buffer->flags.bits.weighted_bipred_idc);
    557 
    558     VTRACE("pic_parse_buffer->expected_pic_parameter_set_id = %d", data->pic_parse_buffer->expected_pic_parameter_set_id);
    559     VTRACE("pic_parse_buffer->num_slice_groups_minus1 = %d", data->pic_parse_buffer->num_slice_groups_minus1);
    560     VTRACE("pic_parse_buffer->chroma_format_idc = %d", data->pic_parse_buffer->chroma_format_idc);
    561     VTRACE("pic_parse_buffer->log2_max_pic_order_cnt_lsb_minus4 = %d", data->pic_parse_buffer->log2_max_pic_order_cnt_lsb_minus4);
    562     VTRACE("pic_parse_buffer->pic_order_cnt_type = %d", data->pic_parse_buffer->pic_order_cnt_type);
    563     VTRACE("pic_parse_buffer->residual_colour_transform_flag = %d", data->pic_parse_buffer->residual_colour_transform_flag);
    564     VTRACE("pic_parse_buffer->num_ref_idc_l0_active_minus1 = %d", data->pic_parse_buffer->num_ref_idc_l0_active_minus1);
    565     VTRACE("pic_parse_buffer->num_ref_idc_l1_active_minus1 = %d", data->pic_parse_buffer->num_ref_idc_l1_active_minus1);
    566 #endif
    567 
    568     vaStatus = vaCreateBuffer(
    569         mVADisplay,
    570         mVAContext,
    571         VAParsePictureParameterBufferType,
    572         sizeof(VAParsePictureParameterBuffer),
    573         1,
    574         data->pic_parse_buffer,
    575         &pictureparameterparsingbufferID);
    576     CHECK_VA_STATUS("vaCreatePictureParameterParsingBuffer");
    577 
    578     vaStatus = vaRenderPicture(
    579         mVADisplay,
    580         mVAContext,
    581         &pictureparameterparsingbufferID,
    582         1);
    583     CHECK_VA_STATUS("vaRenderPicture");
    584 
    585     vaStatus = vaMapBuffer(
    586         mVADisplay,
    587         sliceheaderbufferID,
    588         &sliceheaderbuf);
    589     CHECK_VA_STATUS("vaMapBuffer");
    590 
    591     status = updateSliceParameter(data,sliceheaderbuf);
    592     CHECK_STATUS("processSliceHeader");
    593 
    594     vaStatus = vaUnmapBuffer(
    595         mVADisplay,
    596         sliceheaderbufferID);
    597     CHECK_VA_STATUS("vaUnmapBuffer");
    598 
    599     return DECODE_SUCCESS;
    600 }
    601 
    602 Decode_Status VideoDecoderAVCSecure::parseModularSliceHeader(vbp_data_h264 *data) {
    603     Decode_Status status;
    604     VAStatus vaStatus;
    605 
    606     VABufferID sliceheaderbufferID;
    607     VABufferID pictureparameterparsingbufferID;
    608     VABufferID mSlicebufferID;
    609     int32_t sliceIdx;
    610 
    611     vaStatus = vaBeginPicture(mVADisplay, mVAContext, mAcquiredBuffer->renderBuffer.surface);
    612     CHECK_VA_STATUS("vaBeginPicture");
    613 
    614     if (mFrameSize <= 0 || mSliceNum <=0) {
    615         return DECODE_SUCCESS;
    616     }
    617     void *sliceheaderbuf;
    618     memset(mCachedHeader, 0, MAX_SLICEHEADER_BUFFER_SIZE);
    619     int32_t offset = 0;
    620     int32_t size = 0;
    621 
    622     for (sliceIdx = 0; sliceIdx < mSliceNum; sliceIdx++) {
    623         vaStatus = vaCreateBuffer(
    624             mVADisplay,
    625             mVAContext,
    626             VAParseSliceHeaderGroupBufferType,
    627             MAX_SLICEHEADER_BUFFER_SIZE,
    628             1,
    629             NULL,
    630             &sliceheaderbufferID);
    631         CHECK_VA_STATUS("vaCreateSliceHeaderGroupBuffer");
    632 
    633         vaStatus = vaMapBuffer(
    634             mVADisplay,
    635             sliceheaderbufferID,
    636             &sliceheaderbuf);
    637         CHECK_VA_STATUS("vaMapBuffer");
    638 
    639         memset(sliceheaderbuf, 0, MAX_SLICEHEADER_BUFFER_SIZE);
    640 
    641         vaStatus = vaUnmapBuffer(
    642             mVADisplay,
    643             sliceheaderbufferID);
    644         CHECK_VA_STATUS("vaUnmapBuffer");
    645 
    646         vaStatus = vaCreateBuffer(
    647             mVADisplay,
    648             mVAContext,
    649             VASliceDataBufferType,
    650             mSliceInfo[sliceIdx].sliceSize, //size
    651             1,        //num_elements
    652             mFrameData + mSliceInfo[sliceIdx].sliceStartOffset,
    653             &mSlicebufferID);
    654         CHECK_VA_STATUS("vaCreateSliceDataBuffer");
    655 
    656         data->pic_parse_buffer->frame_buf_id = mSlicebufferID;
    657         data->pic_parse_buffer->slice_headers_buf_id = sliceheaderbufferID;
    658         data->pic_parse_buffer->frame_size = mSliceInfo[sliceIdx].sliceLength;
    659         data->pic_parse_buffer->slice_headers_size = MAX_SLICEHEADER_BUFFER_SIZE;
    660         data->pic_parse_buffer->nalu_header.value = mSliceInfo[sliceIdx].sliceHeaderByte;
    661         data->pic_parse_buffer->slice_offset = mSliceInfo[sliceIdx].sliceByteOffset;
    662 
    663 #if 0
    664         VTRACE("data->pic_parse_buffer->slice_offset = 0x%x", data->pic_parse_buffer->slice_offset);
    665         VTRACE("pic_parse_buffer->nalu_header.value = %x", data->pic_parse_buffer->nalu_header.value = mSliceInfo[sliceIdx].sliceHeaderByte);
    666         VTRACE("flags.bits.frame_mbs_only_flag = %d", data->pic_parse_buffer->flags.bits.frame_mbs_only_flag);
    667         VTRACE("flags.bits.pic_order_present_flag = %d", data->pic_parse_buffer->flags.bits.pic_order_present_flag);
    668         VTRACE("flags.bits.delta_pic_order_always_zero_flag = %d", data->pic_parse_buffer->flags.bits.delta_pic_order_always_zero_flag);
    669         VTRACE("flags.bits.redundant_pic_cnt_present_flag = %d", data->pic_parse_buffer->flags.bits.redundant_pic_cnt_present_flag);
    670         VTRACE("flags.bits.weighted_pred_flag = %d", data->pic_parse_buffer->flags.bits.weighted_pred_flag);
    671         VTRACE("flags.bits.entropy_coding_mode_flag = %d", data->pic_parse_buffer->flags.bits.entropy_coding_mode_flag);
    672         VTRACE("flags.bits.deblocking_filter_control_present_flag = %d", data->pic_parse_buffer->flags.bits.deblocking_filter_control_present_flag);
    673         VTRACE("flags.bits.weighted_bipred_idc = %d", data->pic_parse_buffer->flags.bits.weighted_bipred_idc);
    674         VTRACE("pic_parse_buffer->expected_pic_parameter_set_id = %d", data->pic_parse_buffer->expected_pic_parameter_set_id);
    675         VTRACE("pic_parse_buffer->num_slice_groups_minus1 = %d", data->pic_parse_buffer->num_slice_groups_minus1);
    676         VTRACE("pic_parse_buffer->chroma_format_idc = %d", data->pic_parse_buffer->chroma_format_idc);
    677         VTRACE("pic_parse_buffer->log2_max_pic_order_cnt_lsb_minus4 = %d", data->pic_parse_buffer->log2_max_pic_order_cnt_lsb_minus4);
    678         VTRACE("pic_parse_buffer->pic_order_cnt_type = %d", data->pic_parse_buffer->pic_order_cnt_type);
    679         VTRACE("pic_parse_buffer->residual_colour_transform_flag = %d", data->pic_parse_buffer->residual_colour_transform_flag);
    680         VTRACE("pic_parse_buffer->num_ref_idc_l0_active_minus1 = %d", data->pic_parse_buffer->num_ref_idc_l0_active_minus1);
    681         VTRACE("pic_parse_buffer->num_ref_idc_l1_active_minus1 = %d", data->pic_parse_buffer->num_ref_idc_l1_active_minus1);
    682 #endif
    683         vaStatus = vaCreateBuffer(
    684             mVADisplay,
    685             mVAContext,
    686             VAParsePictureParameterBufferType,
    687             sizeof(VAParsePictureParameterBuffer),
    688             1,
    689             data->pic_parse_buffer,
    690             &pictureparameterparsingbufferID);
    691         CHECK_VA_STATUS("vaCreatePictureParameterParsingBuffer");
    692 
    693         vaStatus = vaRenderPicture(
    694             mVADisplay,
    695             mVAContext,
    696             &pictureparameterparsingbufferID,
    697             1);
    698         CHECK_VA_STATUS("vaRenderPicture");
    699 
    700         vaStatus = vaMapBuffer(
    701             mVADisplay,
    702             sliceheaderbufferID,
    703             &sliceheaderbuf);
    704         CHECK_VA_STATUS("vaMapBuffer");
    705 
    706         size = *(uint32 *)((uint8 *)sliceheaderbuf + 4) + 4;
    707         VTRACE("slice header size = 0x%x, offset = 0x%x", size, offset);
    708         if (offset + size <= MAX_SLICEHEADER_BUFFER_SIZE - 4) {
    709             memcpy(mCachedHeader+offset, sliceheaderbuf, size);
    710             offset += size;
    711         } else {
    712             WTRACE("Cached slice header is not big enough!");
    713         }
    714         vaStatus = vaUnmapBuffer(
    715             mVADisplay,
    716             sliceheaderbufferID);
    717         CHECK_VA_STATUS("vaUnmapBuffer");
    718     }
    719     memset(mCachedHeader + offset, 0xFF, 4);
    720     status = updateSliceParameter(data,mCachedHeader);
    721     CHECK_STATUS("processSliceHeader");
    722     return DECODE_SUCCESS;
    723 }
    724 
    725 
    726 Decode_Status VideoDecoderAVCSecure::updateSliceParameter(vbp_data_h264 *data, void *sliceheaderbuf) {
    727     VTRACE("VideoDecoderAVCSecure::updateSliceParameter");
    728     Decode_Status status;
    729     status =  VideoDecoderBase::updateBuffer(
    730             (uint8_t *)sliceheaderbuf,
    731             MAX_SLICEHEADER_BUFFER_SIZE,
    732             (void**)&data);
    733     CHECK_STATUS("updateBuffer");
    734     return DECODE_SUCCESS;
    735 }
    736 
    737 Decode_Status VideoDecoderAVCSecure::decodeSlice(vbp_data_h264 *data, uint32_t picIndex, uint32_t sliceIndex) {
    738     Decode_Status status;
    739     VAStatus vaStatus;
    740     uint32_t bufferIDCount = 0;
    741     // maximum 3 buffers to render a slice: picture parameter, IQMatrix, slice parameter
    742     VABufferID bufferIDs[3];
    743 
    744     vbp_picture_data_h264 *picData = &(data->pic_data[picIndex]);
    745     vbp_slice_data_h264 *sliceData = &(picData->slc_data[sliceIndex]);
    746     VAPictureParameterBufferH264 *picParam = picData->pic_parms;
    747     VASliceParameterBufferH264 *sliceParam = &(sliceData->slc_parms);
    748     uint32_t slice_data_size = 0;
    749     uint8_t* slice_data_addr = NULL;
    750 
    751     if (sliceParam->first_mb_in_slice == 0 || mDecodingFrame == false) {
    752         // either condition indicates start of a new frame
    753         if (sliceParam->first_mb_in_slice != 0) {
    754             WTRACE("The first slice is lost.");
    755         }
    756         VTRACE("Current frameidx = %d", mFrameIdx++);
    757         // Update  the reference frames and surface IDs for DPB and current frame
    758         status = updateDPB(picParam);
    759         CHECK_STATUS("updateDPB");
    760 
    761         //We have to provide a hacked DPB rather than complete DPB for libva as workaround
    762         status = updateReferenceFrames(picData);
    763         CHECK_STATUS("updateReferenceFrames");
    764 
    765         mDecodingFrame = true;
    766 
    767         vaStatus = vaCreateBuffer(
    768             mVADisplay,
    769             mVAContext,
    770             VAPictureParameterBufferType,
    771             sizeof(VAPictureParameterBufferH264),
    772             1,
    773             picParam,
    774             &bufferIDs[bufferIDCount]);
    775         CHECK_VA_STATUS("vaCreatePictureParameterBuffer");
    776         bufferIDCount++;
    777 
    778         vaStatus = vaCreateBuffer(
    779             mVADisplay,
    780             mVAContext,
    781             VAIQMatrixBufferType,
    782             sizeof(VAIQMatrixBufferH264),
    783             1,
    784             data->IQ_matrix_buf,
    785             &bufferIDs[bufferIDCount]);
    786         CHECK_VA_STATUS("vaCreateIQMatrixBuffer");
    787         bufferIDCount++;
    788     }
    789 
    790     status = setReference(sliceParam);
    791     CHECK_STATUS("setReference");
    792 
    793     if (mModularMode) {
    794         if (mIsEncryptData) {
    795             sliceParam->slice_data_size = mSliceInfo[sliceIndex].sliceSize;
    796             slice_data_size = mSliceInfo[sliceIndex].sliceSize;
    797             slice_data_addr = mFrameData + mSliceInfo[sliceIndex].sliceStartOffset;
    798         } else {
    799             slice_data_size = sliceData->slice_size;
    800             slice_data_addr = sliceData->buffer_addr + sliceData->slice_offset;
    801         }
    802     } else {
    803         sliceParam->slice_data_size = mFrameSize;
    804         slice_data_size = mFrameSize;
    805         slice_data_addr = mFrameData;
    806     }
    807 
    808     vaStatus = vaCreateBuffer(
    809         mVADisplay,
    810         mVAContext,
    811         VASliceParameterBufferType,
    812         sizeof(VASliceParameterBufferH264),
    813         1,
    814         sliceParam,
    815         &bufferIDs[bufferIDCount]);
    816     CHECK_VA_STATUS("vaCreateSliceParameterBuffer");
    817     bufferIDCount++;
    818 
    819     vaStatus = vaRenderPicture(
    820         mVADisplay,
    821         mVAContext,
    822         bufferIDs,
    823         bufferIDCount);
    824     CHECK_VA_STATUS("vaRenderPicture");
    825 
    826     VABufferID slicebufferID;
    827 
    828     vaStatus = vaCreateBuffer(
    829         mVADisplay,
    830         mVAContext,
    831         VASliceDataBufferType,
    832         slice_data_size, //size
    833         1,        //num_elements
    834         slice_data_addr,
    835         &slicebufferID);
    836     CHECK_VA_STATUS("vaCreateSliceDataBuffer");
    837 
    838     vaStatus = vaRenderPicture(
    839         mVADisplay,
    840         mVAContext,
    841         &slicebufferID,
    842         1);
    843     CHECK_VA_STATUS("vaRenderPicture");
    844 
    845     return DECODE_SUCCESS;
    846 
    847 }
    848 
    849 Decode_Status VideoDecoderAVCSecure::getCodecSpecificConfigs(
    850     VAProfile profile, VAConfigID *config)
    851 {
    852     VAStatus vaStatus;
    853     VAConfigAttrib attrib[2];
    854 
    855     if (config == NULL) {
    856         ETRACE("Invalid parameter!");
    857         return DECODE_FAIL;
    858     }
    859 
    860     attrib[0].type = VAConfigAttribRTFormat;
    861     attrib[0].value = VA_RT_FORMAT_YUV420;
    862     attrib[1].type = VAConfigAttribDecSliceMode;
    863     attrib[1].value = VA_DEC_SLICE_MODE_NORMAL;
    864     if (mModularMode) {
    865         attrib[1].value = VA_DEC_SLICE_MODE_SUBSAMPLE;
    866     }
    867 
    868     vaStatus = vaCreateConfig(
    869             mVADisplay,
    870             profile,
    871             VAEntrypointVLD,
    872             &attrib[0],
    873             2,
    874             config);
    875     CHECK_VA_STATUS("vaCreateConfig");
    876 
    877     return DECODE_SUCCESS;
    878 }
    879