diff options
Diffstat (limited to 'msmcobalt/mm-video-v4l2/vidc/common/src/extra_data_handler.cpp')
-rw-r--r-- | msmcobalt/mm-video-v4l2/vidc/common/src/extra_data_handler.cpp | 551 |
1 files changed, 551 insertions, 0 deletions
diff --git a/msmcobalt/mm-video-v4l2/vidc/common/src/extra_data_handler.cpp b/msmcobalt/mm-video-v4l2/vidc/common/src/extra_data_handler.cpp new file mode 100644 index 0000000..187eb77 --- /dev/null +++ b/msmcobalt/mm-video-v4l2/vidc/common/src/extra_data_handler.cpp @@ -0,0 +1,551 @@ +/*-------------------------------------------------------------------------- +Copyright (c) 2010-2014, The Linux Foundation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of The Linux Foundation nor + the names of its contributors may be used to endorse or promote + products derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +--------------------------------------------------------------------------*/ + +#include "extra_data_handler.h" + +int debug_level = PRIO_ERROR; + +extra_data_handler::extra_data_handler() +{ + rbsp_buf = (OMX_U8 *) calloc(1,100); + memset(&frame_packing_arrangement,0,sizeof(frame_packing_arrangement)); + frame_packing_arrangement.cancel_flag = 1; + pack_sei = false; + sei_payload_type = -1; +} + +extra_data_handler::~extra_data_handler() +{ + if (rbsp_buf) { + free(rbsp_buf); + rbsp_buf = NULL; + } +} + +OMX_U32 extra_data_handler::d_u(OMX_U32 num_bits) +{ + OMX_U32 rem_bits = num_bits, bins = 0, shift = 0; + + while (rem_bits >= bit_ptr) { + DEBUG_PRINT_LOW("In %s() bit_ptr/byte_ptr :%u/%u/%x", __func__, (unsigned int)bit_ptr, + (unsigned int)byte_ptr, rbsp_buf[byte_ptr]); + bins <<= shift; + shift = (8-bit_ptr); + bins |= ((rbsp_buf[byte_ptr] << shift) & 0xFF) >> shift; + rem_bits -= bit_ptr; + bit_ptr = 8; + byte_ptr ++; + } + + DEBUG_PRINT_LOW("In %s() bit_ptr/byte_ptr :%u/%u/%x", __func__, (unsigned int)bit_ptr, + (unsigned int)byte_ptr, rbsp_buf[byte_ptr]); + + if (rem_bits) { + bins <<= rem_bits; + bins |= ((rbsp_buf[byte_ptr] << (8-bit_ptr)) & 0xFF) >> (8-rem_bits); + bit_ptr -= rem_bits; + + if (bit_ptr == 0) { + bit_ptr = 8; + byte_ptr++; + } + } + + DEBUG_PRINT_LOW("In %s() bit_ptr/byte_ptr :%u/%u/%x", __func__, (unsigned int)bit_ptr, + (unsigned int)byte_ptr, rbsp_buf[byte_ptr]); + + DEBUG_PRINT_LOW("In %s() bin/num_bits : %x/%u", __func__, (unsigned)bins, (unsigned int)num_bits); + return bins; +} + +OMX_U32 extra_data_handler::d_ue() +{ + OMX_S32 lead_zeros = -1; + OMX_U32 symbol, bit; + + do { + bit = d_u(1); + lead_zeros++; + } while (!bit); + + symbol = ((1 << lead_zeros) - 1) + d_u(lead_zeros); + + DEBUG_PRINT_LOW("In %s() symbol : %u", __func__, (unsigned int)symbol); + return symbol; +} + +OMX_U32 extra_data_handler::parse_frame_pack(void) +{ + frame_packing_arrangement.id = d_ue(); + frame_packing_arrangement.cancel_flag = d_u(1); + + if (!frame_packing_arrangement.cancel_flag) { + frame_packing_arrangement.type = d_u(7); + frame_packing_arrangement.quincunx_sampling_flag = d_u(1); + frame_packing_arrangement.content_interpretation_type = d_u(6); + frame_packing_arrangement.spatial_flipping_flag = d_u(1); + frame_packing_arrangement.frame0_flipped_flag = d_u(1); + frame_packing_arrangement.field_views_flag = d_u(1); + frame_packing_arrangement.current_frame_is_frame0_flag = d_u(1); + frame_packing_arrangement.frame0_self_contained_flag = d_u(1); + frame_packing_arrangement.frame1_self_contained_flag = d_u(1); + + if (!frame_packing_arrangement.quincunx_sampling_flag && + frame_packing_arrangement.type != 5) { + frame_packing_arrangement.frame0_grid_position_x = d_u(4); + frame_packing_arrangement.frame0_grid_position_y = d_u(4); + frame_packing_arrangement.frame1_grid_position_x = d_u(4); + frame_packing_arrangement.frame1_grid_position_y = d_u(4); + } + + frame_packing_arrangement.reserved_byte = d_u(8); + frame_packing_arrangement.repetition_period = d_ue(); + } + + frame_packing_arrangement.extension_flag = d_u(1); + + return 1; +} + +OMX_S32 extra_data_handler::parse_rbsp(OMX_U8 *buf, OMX_U32 len) +{ + OMX_U32 i = 3, j=0, startcode; + OMX_U32 nal_unit_type, nal_ref_idc, forbidden_zero_bit; + + bit_ptr = 8; + byte_ptr = 0; + + startcode = buf[0] << 16 | buf[1] <<8 | buf[2]; + + if (!startcode) { + startcode |= buf[i++]; + } + + if (startcode != H264_START_CODE) { + DEBUG_PRINT_ERROR("ERROR: In %s() Start code not found", __func__); + return -1; + } + + forbidden_zero_bit = (buf[i] & 0x80) >>7; + + if (forbidden_zero_bit) { + DEBUG_PRINT_ERROR("ERROR: In %s() Non-zero forbidden bit", __func__); + return -1; + } + + nal_ref_idc = (buf[i] & 0x60) >>5; + DEBUG_PRINT_LOW("In %s() nal_ref_idc ; %u", __func__, (unsigned int)nal_ref_idc); + + nal_unit_type = (buf[i++] & 0x1F); + + while (i<len) { + if (!(buf[i] + buf[i+1]) && (buf[i+2] == H264_EMULATION_BYTE) && + (i+2 < len)) { + rbsp_buf[j++] = buf[i++]; + rbsp_buf[j++] = buf[i++]; + i++; + } else + rbsp_buf[j++] = buf[i++]; + } + + return nal_unit_type; +} +OMX_S32 extra_data_handler::parse_sei(OMX_U8 *buffer, OMX_U32 buffer_length) +{ + OMX_U32 nal_unit_type, payload_type = 0, payload_size = 0; + OMX_U32 marker = 0, pad = 0xFF; + + nal_unit_type = parse_rbsp(buffer, buffer_length); + + if (nal_unit_type != NAL_TYPE_SEI) { + DEBUG_PRINT_ERROR("ERROR: In %s() - Non SEI NAL ", __func__); + return -1; + } else { + + while (rbsp_buf[byte_ptr] == 0xFF) + payload_type += rbsp_buf[byte_ptr++]; + + payload_type += rbsp_buf[byte_ptr++]; + + DEBUG_PRINT_LOW("In %s() payload_type : %u", __func__, (unsigned int)payload_type); + + while (rbsp_buf[byte_ptr] == 0xFF) + payload_size += rbsp_buf[byte_ptr++]; + + payload_size += rbsp_buf[byte_ptr++]; + + DEBUG_PRINT_LOW("In %s() payload_size : %u", __func__, (unsigned int)payload_size); + + switch (payload_type) { + case SEI_PAYLOAD_FRAME_PACKING_ARRANGEMENT: + DEBUG_PRINT_LOW("In %s() Frame Packing SEI ", __func__); + parse_frame_pack(); + break; + default: + DEBUG_PRINT_LOW("INFO: In %s() Not Supported SEI NAL ", __func__); + break; + } + } + + if (bit_ptr != 8) { + marker = d_u(1); + + if (marker) { + if (bit_ptr != 8) { + pad = d_u(bit_ptr); + + if (pad) { + DEBUG_PRINT_ERROR("ERROR: In %s() padding Bits Error in SEI", + __func__); + return -1; + } + } + } else { + DEBUG_PRINT_ERROR("ERROR: In %s() Marker Bit Error in SEI", + __func__); + return -1; + } + } + + DEBUG_PRINT_LOW("In %s() payload_size : %u/%u", __func__, + (unsigned int)payload_size, (unsigned int)byte_ptr); + return 1; +} + +OMX_S32 extra_data_handler::parse_ltrinfo(OMX_OTHER_EXTRADATATYPE *pExtra) +{ + OMX_U32 *pLTR; + pExtra->eType = (OMX_EXTRADATATYPE)OMX_ExtraDataVideoLTRInfo; + pLTR = (OMX_U32* )pExtra + 5; + DEBUG_PRINT_HIGH("ExtraData LTR ID %u", (unsigned int)*pLTR); + return 0; +} +/*====================================================================== + Slice Information will be available as below (each line is of 4 bytes) + | number of slices | + | 1st slice offset | + | 1st slice size | + | .. | + | Nth slice offset | + | Nth slice size | + ======================================================================*/ +OMX_S32 extra_data_handler::parse_sliceinfo( + OMX_BUFFERHEADERTYPE *pBufHdr, OMX_OTHER_EXTRADATATYPE *pExtra) +{ + OMX_U32 slice_offset = 0, slice_size = 0, total_size = 0; + OMX_U8 *pBuffer = (OMX_U8 *)pBufHdr->pBuffer; + OMX_U32 *data = (OMX_U32 *)(void *)pExtra->data; + OMX_U32 num_slices = *data; + DEBUG_PRINT_LOW("number of slices = %u", (unsigned int)num_slices); + + if ((4 + num_slices * 8) != (OMX_U32)pExtra->nDataSize) { + DEBUG_PRINT_ERROR("unknown error in slice info extradata"); + return -1; + } + + for (unsigned i = 0; i < num_slices; i++) { + slice_offset = (OMX_U32)(*(data + (i*2 + 1))); + + if ((*(pBuffer + slice_offset + 0) != 0x00) || + (*(pBuffer + slice_offset + 1) != 0x00) || + (*(pBuffer + slice_offset + 2) != 0x00) || + (*(pBuffer + slice_offset + 3) != H264_START_CODE)) { + DEBUG_PRINT_ERROR("found 0x%x instead of start code at offset[%u] " + "for slice[%u]", (unsigned)(*(OMX_U32 *)(pBuffer + slice_offset)), + (unsigned int)slice_offset, i); + return -1; + } + + if (slice_offset != total_size) { + DEBUG_PRINT_ERROR("offset of slice number %d is not correct " + "or previous slice size is not correct", i); + return -1; + } + + slice_size = (OMX_U32)(*(data + (i*2 + 2))); + total_size += slice_size; + DEBUG_PRINT_LOW("slice number %d offset/size = %u/%u", + i, (unsigned int)slice_offset, (unsigned int)slice_size); + } + + if (pBufHdr->nFilledLen != total_size) { + DEBUG_PRINT_ERROR("frame_size[%u] is not equal to " + "total slices size[%u]", (unsigned int)pBufHdr->nFilledLen, (unsigned int)total_size); + return -1; + } + + return 0; +} + +OMX_U32 extra_data_handler::parse_extra_data(OMX_BUFFERHEADERTYPE *buf_hdr) +{ + DEBUG_PRINT_LOW("In %s() flags: 0x%x", __func__, (unsigned)buf_hdr->nFlags); + + if (buf_hdr->nFlags & OMX_BUFFERFLAG_EXTRADATA) { + + OMX_OTHER_EXTRADATATYPE *extra_data = (OMX_OTHER_EXTRADATATYPE *) + ((unsigned long)(buf_hdr->pBuffer + buf_hdr->nOffset + + buf_hdr->nFilledLen + 3)&(~3)); + + while (extra_data && + ((unsigned long)extra_data > (unsigned long)buf_hdr->pBuffer) && + ((unsigned long)extra_data < (unsigned long)buf_hdr->pBuffer + buf_hdr->nAllocLen)) { + + DEBUG_PRINT_LOW("extradata(%p): nSize = 0x%x, eType = 0x%x," + " nDataSize = 0x%x", extra_data, (unsigned int)extra_data->nSize, + extra_data->eType, (unsigned int)extra_data->nDataSize); + + if ((extra_data->eType == VDEC_EXTRADATA_NONE) || + (extra_data->eType == VEN_EXTRADATA_NONE)) { + DEBUG_PRINT_LOW("No more extradata available"); + extra_data->eType = OMX_ExtraDataNone; + break; + } else if (extra_data->eType == VDEC_EXTRADATA_SEI) { + DEBUG_PRINT_LOW("Extradata SEI of size %u found, " + "parsing it", (unsigned int)extra_data->nDataSize); + parse_sei(extra_data->data, extra_data->nDataSize); + } else if (extra_data->eType == VEN_EXTRADATA_QCOMFILLER) { + DEBUG_PRINT_LOW("Extradata Qcom Filler found, skip %u bytes", + (unsigned int)extra_data->nSize); + } else if (extra_data->eType == VEN_EXTRADATA_SLICEINFO) { + DEBUG_PRINT_LOW("Extradata SliceInfo of size %u found, " + "parsing it", (unsigned int)extra_data->nDataSize); + parse_sliceinfo(buf_hdr, extra_data); + } + +#ifndef _MSM8974_ + else if (extra_data->eType == VEN_EXTRADATA_LTRINFO) { + DEBUG_PRINT_LOW("Extradata LTRInfo of size %d found, " + "parsing it", extra_data->nDataSize); + parse_ltrinfo(extra_data); + } + +#endif + else { + DEBUG_PRINT_ERROR("Unknown extradata(%p) found, nSize = 0x%x, " + "eType = 0x%x, nDataSize = 0x%x", extra_data, + (unsigned int)extra_data->nSize, extra_data->eType, (unsigned int)extra_data->nDataSize); + buf_hdr->nFlags &= ~(OMX_BUFFERFLAG_EXTRADATA); + break; + } + + extra_data = (OMX_OTHER_EXTRADATATYPE *) (((OMX_U8 *) extra_data) + + extra_data->nSize); + } + } + + return 1; +} + +OMX_U32 extra_data_handler::get_frame_pack_data( + OMX_QCOM_FRAME_PACK_ARRANGEMENT *frame_pack) +{ + DEBUG_PRINT_LOW("%s:%d get frame data", __func__, __LINE__); + memcpy(&frame_pack->id,&frame_packing_arrangement.id, + FRAME_PACK_SIZE*sizeof(OMX_U32)); + return 1; +} + +OMX_U32 extra_data_handler::set_frame_pack_data(OMX_QCOM_FRAME_PACK_ARRANGEMENT + *frame_pack) +{ + DEBUG_PRINT_LOW("%s:%d set frame data", __func__, __LINE__); + memcpy(&frame_packing_arrangement.id, &frame_pack->id, + FRAME_PACK_SIZE*sizeof(OMX_U32)); + pack_sei = true; + sei_payload_type = SEI_PAYLOAD_FRAME_PACKING_ARRANGEMENT; + return 1; +} + +OMX_U32 extra_data_handler::e_u(OMX_U32 symbol, OMX_U32 num_bits) +{ + OMX_U32 rem_bits = num_bits, shift; + + DEBUG_PRINT_LOW("%s bin : %x/%u", __func__, (unsigned)symbol, (unsigned int)num_bits); + + while (rem_bits >= bit_ptr) { + shift = rem_bits - bit_ptr; + rbsp_buf[byte_ptr] |= (symbol >> shift); + symbol = (symbol << (32 - shift)) >> (32 - shift); + rem_bits -= bit_ptr; + DEBUG_PRINT_LOW("%sstream byte/rem_bits %x/%u", __func__, + (unsigned)rbsp_buf[byte_ptr], (unsigned int)rem_bits); + byte_ptr ++; + bit_ptr = 8; + } + + if (rem_bits) { + shift = bit_ptr - rem_bits; + rbsp_buf[byte_ptr] |= (symbol << shift); + bit_ptr -= rem_bits; + DEBUG_PRINT_LOW("%s 2 stream byte/rem_bits %x/%u", __func__, + (unsigned)rbsp_buf[byte_ptr], (unsigned int)rem_bits); + + if (bit_ptr == 0) { + bit_ptr = 8; + byte_ptr++; + } + } + + return 1; +} + +OMX_U32 extra_data_handler::e_ue(OMX_U32 symbol) +{ + OMX_U32 i, sym_len, sufix_len, info; + OMX_U32 nn =(symbol + 1) >> 1; + + DEBUG_PRINT_LOW("%s bin : %x", __func__, (unsigned)symbol); + + for (i=0; i < 33 && nn != 0; i++) + nn >>= 1; + + sym_len = ((i << 1) + 1); + info = symbol + 1 - (1 << i); + sufix_len = (1 << (sym_len >>1)); + info = sufix_len | (info & (sufix_len - 1)); + e_u(info, sym_len); + return 1; +} + +OMX_U32 extra_data_handler::create_frame_pack() +{ + e_ue(frame_packing_arrangement.id); + e_u(frame_packing_arrangement.cancel_flag, 1); + + if (!frame_packing_arrangement.cancel_flag) { + e_u(frame_packing_arrangement.type, 7); + e_u(frame_packing_arrangement.quincunx_sampling_flag, 1); + e_u(frame_packing_arrangement.content_interpretation_type, 6); + e_u(frame_packing_arrangement.spatial_flipping_flag, 1); + e_u(frame_packing_arrangement.frame0_flipped_flag, 1); + e_u(frame_packing_arrangement.field_views_flag, 1); + e_u(frame_packing_arrangement.current_frame_is_frame0_flag, 1); + e_u(frame_packing_arrangement.frame0_self_contained_flag, 1); + e_u(frame_packing_arrangement.frame1_self_contained_flag, 1); + + if (!frame_packing_arrangement.quincunx_sampling_flag && + frame_packing_arrangement.type != 5) { + e_u(frame_packing_arrangement.frame0_grid_position_x, 4); + e_u(frame_packing_arrangement.frame0_grid_position_y, 4); + e_u(frame_packing_arrangement.frame1_grid_position_x, 4); + e_u(frame_packing_arrangement.frame1_grid_position_y, 4); + } + + e_u(frame_packing_arrangement.reserved_byte, 8); + e_ue(frame_packing_arrangement.repetition_period); + } + + e_u(frame_packing_arrangement.extension_flag, 1); + return 1; +} + +OMX_S32 extra_data_handler::create_rbsp(OMX_U8 *buf, OMX_U32 nalu_type) +{ + OMX_U32 i, j = 7; + + for (i = 0; i < 3; i++) + *buf++ = 0x00; + + *buf++ = H264_START_CODE; + *buf++ = nalu_type; + *buf++ = (sei_payload_type & 0x000000FF); + *buf++ = byte_ptr - 1; //payload will contain 1 byte of rbsp_trailing_bits + //that shouldn't be taken into account + + for (i = 0; i < byte_ptr ; i += 2) { + *buf++ = rbsp_buf[i]; + j++; + + if (i+1 < byte_ptr) { + *buf++ = rbsp_buf[i+1]; + j++; + + if (!(rbsp_buf[i] + rbsp_buf[i+1])) { + *buf++ = H264_EMULATION_BYTE; + j++; + } + } + } + + DEBUG_PRINT_LOW("%s rbsp length %u", __func__, (unsigned int)j); + return j; +} + +OMX_U32 extra_data_handler::create_sei(OMX_U8 *buffer) +{ + OMX_U32 i, ret_val = 0; + + byte_ptr = 0; + bit_ptr = 8; + + if (sei_payload_type == SEI_PAYLOAD_FRAME_PACKING_ARRANGEMENT) { + create_frame_pack(); + + if (bit_ptr != 8) { + e_u(1,1); + + if (bit_ptr != 8) + e_u(0,bit_ptr); + } + + //Payload will have been byte aligned by now, + //insert the rbsp trailing bits + e_u(1, 1); + e_u(0, 7); + + ret_val = create_rbsp(buffer, NAL_TYPE_SEI); + } + + pack_sei = false; + sei_payload_type = -1; + + return ret_val; +} + +OMX_U32 extra_data_handler::create_extra_data(OMX_BUFFERHEADERTYPE *buf_hdr) +{ + OMX_U8 *buffer = (OMX_U8 *) (buf_hdr->pBuffer + + buf_hdr->nOffset + buf_hdr->nFilledLen); + OMX_U32 msg_size; + + if (buf_hdr->nFlags & OMX_BUFFERFLAG_CODECCONFIG) { + DEBUG_PRINT_LOW("%s:%d create extra data with config", __func__, + __LINE__); + + if (pack_sei) { + msg_size = create_sei(buffer); + + if ( msg_size > 0) + buf_hdr->nFilledLen += msg_size; + } + } + + return 1; +} + |