xref: /hardware/qcom/media/mm-video/vidc/vdec/src/h264_utils.cpp

/*--------------------------------------------------------------------------
Copyright (c) 2010-2012, Code Aurora Forum. 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 Code Aurora 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.
--------------------------------------------------------------------------*/
/*========================================================================

                      O p e n M M
         V i d e o   U t i l i t i e s

*//** @file VideoUtils.cpp
  This module contains utilities and helper routines.

@par EXTERNALIZED FUNCTIONS

@par INITIALIZATION AND SEQUENCING REQUIREMENTS
  (none)

*//*====================================================================== */

/* =======================================================================

                     INCLUDE FILES FOR MODULE

========================================================================== */
#include "h264_utils.h"
#include "extra_data_handler.h"
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/time.h>
#ifdef _ANDROID_
#include <cutils/properties.h>
    extern "C"{
        #include<utils/Log.h>
    }

#endif

/* =======================================================================

                DEFINITIONS AND DECLARATIONS FOR MODULE

This section contains definitions for constants, macros, types, variables
and other items needed by this module.

========================================================================== */

#define SIZE_NAL_FIELD_MAX  4
#define BASELINE_PROFILE 66
#define MAIN_PROFILE     77
#define HIGH_PROFILE     100

#define MAX_SUPPORTED_LEVEL 32

RbspParser::RbspParser (const uint8 *_begin, const uint8 *_end)
: begin (_begin), end(_end), pos (- 1), bit (0),
cursor (0xFFFFFF), advanceNeeded (true)
{
}

// Destructor
/*lint -e{1540}  Pointer member neither freed nor zeroed by destructor
 * No problem
 */
RbspParser::~RbspParser () {}

// Return next RBSP byte as a word
uint32 RbspParser::next ()
{
    if (advanceNeeded) advance ();
    //return static_cast<uint32> (*pos);
    return static_cast<uint32> (begin[pos]);
}

// Advance RBSP decoder to next byte
void RbspParser::advance ()
{
    ++pos;
    //if (pos >= stop)
    if (begin + pos == end)
    {
        /*lint -e{730}  Boolean argument to function
         * I don't see a problem here
         */
        //throw false;
        ALOGV("H264Parser-->NEED TO THROW THE EXCEPTION...\n");
    }
    cursor <<= 8;
    //cursor |= static_cast<uint32> (*pos);
    cursor |= static_cast<uint32> (begin[pos]);
    if ((cursor & 0xFFFFFF) == 0x000003)
    {
        advance ();
    }
    advanceNeeded = false;
}

// Decode unsigned integer
uint32 RbspParser::u (uint32 n)
{
    uint32 i, s, x = 0;
    for (i = 0; i < n; i += s)
    {
        s = static_cast<uint32>STD_MIN(static_cast<int>(8 - bit),
            static_cast<int>(n - i));
        x <<= s;

        x |= ((next () >> ((8 - static_cast<uint32>(bit)) - s)) &
            ((1 << s) - 1));

        bit = (bit + s) % 8;
        if (!bit)
        {
            advanceNeeded = true;
        }
    }
    return x;
}

// Decode unsigned integer Exp-Golomb-coded syntax element
uint32 RbspParser::ue ()
{
    int leadingZeroBits = -1;
    for (uint32 b = 0; !b; ++leadingZeroBits)
    {
        b = u (1);
    }
    return ((1 << leadingZeroBits) - 1) +
        u (static_cast<uint32>(leadingZeroBits));
}

// Decode signed integer Exp-Golomb-coded syntax element
int32 RbspParser::se ()
{
    const uint32 x = ue ();
    if (!x) return 0;
    else if (x & 1) return static_cast<int32> ((x >> 1) + 1);
    else return - static_cast<int32> (x >> 1);
}

void H264_Utils::allocate_rbsp_buffer(uint32 inputBufferSize)
{
    m_rbspBytes = (byte *) calloc(1,inputBufferSize);
    m_prv_nalu.nal_ref_idc = 0;
    m_prv_nalu.nalu_type = NALU_TYPE_UNSPECIFIED;
}

H264_Utils::H264_Utils(): m_height(0),
                          m_width(0),
                          m_rbspBytes(NULL),
                          m_au_data (false)
{
    initialize_frame_checking_environment();
}

H264_Utils::~H264_Utils()
{
/*  if(m_pbits)
  {
    delete(m_pbits);
    m_pbits = NULL;
  }
*/
  if (m_rbspBytes)
  {
    free(m_rbspBytes);
    m_rbspBytes = NULL;
  }
}

/***********************************************************************/
/*
FUNCTION:
  H264_Utils::initialize_frame_checking_environment

DESCRIPTION:
  Extract RBSP data from a NAL

INPUT/OUTPUT PARAMETERS:
  None

RETURN VALUE:
  boolean

SIDE EFFECTS:
  None.
*/
/***********************************************************************/
void H264_Utils::initialize_frame_checking_environment()
{
  m_forceToStichNextNAL = false;
  m_au_data = false;
  m_prv_nalu.nal_ref_idc = 0;
  m_prv_nalu.nalu_type = NALU_TYPE_UNSPECIFIED;
}

/***********************************************************************/
/*
FUNCTION:
  H264_Utils::extract_rbsp

DESCRIPTION:
  Extract RBSP data from a NAL

INPUT/OUTPUT PARAMETERS:
  <In>
    buffer : buffer containing start code or nal length + NAL units
    buffer_length : the length of the NAL buffer
    start_code : If true, start code is detected,
                 otherwise size nal length is detected
    size_of_nal_length_field: size of nal length field

  <Out>
    rbsp_bistream : extracted RBSP bistream
    rbsp_length : the length of the RBSP bitstream
    nal_unit : decoded NAL header information

RETURN VALUE:
  boolean

SIDE EFFECTS:
  None.
*/
/***********************************************************************/

boolean H264_Utils::extract_rbsp(OMX_IN   OMX_U8  *buffer,
                                 OMX_IN   OMX_U32 buffer_length,
                                 OMX_IN   OMX_U32 size_of_nal_length_field,
                                 OMX_OUT  OMX_U8  *rbsp_bistream,
                                 OMX_OUT  OMX_U32 *rbsp_length,
                                 OMX_OUT  NALU    *nal_unit)
{
  byte coef1, coef2, coef3;
  uint32 pos = 0;
  uint32 nal_len = buffer_length;
  uint32 sizeofNalLengthField = 0;
  uint32 zero_count;
  boolean eRet = true;
  boolean start_code = (size_of_nal_length_field==0)?true:false;

  if(start_code) {
    // Search start_code_prefix_one_3bytes (0x000001)
    coef2 = buffer[pos++];
    coef3 = buffer[pos++];
    do {
      if(pos >= buffer_length)
      {
        ALOGE("ERROR: In %s() - line %d", __func__, __LINE__);
        return false;
      }

      coef1 = coef2;
      coef2 = coef3;
      coef3 = buffer[pos++];
    } while(coef1 || coef2 || coef3 != 1);
  }
  else if (size_of_nal_length_field)
  {
    /* This is the case to play multiple NAL units inside each access unit*/
    /* Extract the NAL length depending on sizeOfNALength field */
    sizeofNalLengthField = size_of_nal_length_field;
    nal_len = 0;
    while(size_of_nal_length_field--)
    {
      nal_len |= buffer[pos++]<<(size_of_nal_length_field<<3);
    }
    if (nal_len >= buffer_length)
    {
      ALOGE("ERROR: In %s() - line %d", __func__, __LINE__);
      return false;
    }
  }

  if (nal_len > buffer_length)
  {
    ALOGE("ERROR: In %s() - line %d", __func__, __LINE__);
    return false;
  }
  if(pos + 1 > (nal_len + sizeofNalLengthField))
  {
    ALOGE("ERROR: In %s() - line %d", __func__, __LINE__);
    return false;
  }
  if (nal_unit->forbidden_zero_bit = (buffer[pos] & 0x80))
  {
    ALOGE("ERROR: In %s() - line %d", __func__, __LINE__);
  }
  nal_unit->nal_ref_idc   = (buffer[pos] & 0x60) >> 5;
  nal_unit->nalu_type = buffer[pos++] & 0x1f;
  ALOGV("\n@#@# Pos = %x NalType = %x buflen = %d",
      pos-1, nal_unit->nalu_type, buffer_length);
  *rbsp_length = 0;


  if( nal_unit->nalu_type == NALU_TYPE_EOSEQ ||
      nal_unit->nalu_type == NALU_TYPE_EOSTREAM)
    return (nal_len + sizeofNalLengthField);

  zero_count = 0;
  while (pos < (nal_len+sizeofNalLengthField))    //similar to for in p-42
   {
    if( zero_count == 2 ) {
      if( buffer[pos] == 0x03 ) {
        pos ++;
        zero_count = 0;
        continue;
      }
      if( buffer[pos] <= 0x01 ) {
        if( start_code ) {
          *rbsp_length -= 2;
          pos -= 2;
          return pos;
        }
      }
      zero_count = 0;
    }
    zero_count ++;
    if( buffer[pos] != 0 )
      zero_count = 0;

    rbsp_bistream[(*rbsp_length)++] = buffer[pos++];
  }

  return eRet;
}

/*===========================================================================
FUNCTION:
  H264_Utils::iSNewFrame

DESCRIPTION:
  Returns true if NAL parsing successfull otherwise false.

INPUT/OUTPUT PARAMETERS:
  <In>
    buffer : buffer containing start code or nal length + NAL units
    buffer_length : the length of the NAL buffer
    start_code : If true, start code is detected,
                 otherwise size nal length is detected
    size_of_nal_length_field: size of nal length field
  <out>
    isNewFrame: true if the NAL belongs to a differenet frame
                false if the NAL belongs to a current frame

RETURN VALUE:
  boolean  true, if nal parsing is successful
           false, if the nal parsing has errors

SIDE EFFECTS:
  None.
===========================================================================*/
bool H264_Utils::isNewFrame(OMX_BUFFERHEADERTYPE *p_buf_hdr,
                            OMX_IN OMX_U32 size_of_nal_length_field,
                            OMX_OUT OMX_BOOL &isNewFrame)
{
    NALU nal_unit;
    uint16 first_mb_in_slice = 0;
    OMX_IN OMX_U32 numBytesInRBSP = 0;
    OMX_IN OMX_U8 *buffer = p_buf_hdr->pBuffer;
    OMX_IN OMX_U32 buffer_length = p_buf_hdr->nFilledLen;
    bool eRet = true;

    ALOGV("isNewFrame: buffer %p buffer_length %d "
        "size_of_nal_length_field %d\n", buffer, buffer_length,
        size_of_nal_length_field);

    if ( false == extract_rbsp(buffer, buffer_length, size_of_nal_length_field,
                               m_rbspBytes, &numBytesInRBSP, &nal_unit) )
    {
        ALOGE("ERROR: In %s() - extract_rbsp() failed", __func__);
        isNewFrame = OMX_FALSE;
        eRet = false;
    }
    else
    {
      nalu_type = nal_unit.nalu_type;
      switch (nal_unit.nalu_type)
      {
        case NALU_TYPE_IDR:
        case NALU_TYPE_NON_IDR:
        {
          ALOGV("\n AU Boundary with NAL type %d ",nal_unit.nalu_type);
          if (m_forceToStichNextNAL)
          {
            isNewFrame = OMX_FALSE;
          }
          else
          {
            RbspParser rbsp_parser(m_rbspBytes, (m_rbspBytes+numBytesInRBSP));
            first_mb_in_slice = rbsp_parser.ue();

            if((!first_mb_in_slice) || /*(slice.prv_frame_num != slice.frame_num ) ||*/
               ( (m_prv_nalu.nal_ref_idc != nal_unit.nal_ref_idc) && ( nal_unit.nal_ref_idc * m_prv_nalu.nal_ref_idc == 0 ) ) ||
               /*( ((m_prv_nalu.nalu_type == NALU_TYPE_IDR) && (nal_unit.nalu_type == NALU_TYPE_IDR)) && (slice.idr_pic_id != slice.prv_idr_pic_id) ) || */
               ( (m_prv_nalu.nalu_type != nal_unit.nalu_type ) && ((m_prv_nalu.nalu_type == NALU_TYPE_IDR) || (nal_unit.nalu_type == NALU_TYPE_IDR)) ) )
            {
              //ALOGV("Found a New Frame due to NALU_TYPE_IDR/NALU_TYPE_NON_IDR");
              isNewFrame = OMX_TRUE;
            }
            else
            {
              isNewFrame = OMX_FALSE;
            }
          }
          m_au_data = true;
          m_forceToStichNextNAL = false;
          break;
        }
        case NALU_TYPE_SPS:
        case NALU_TYPE_PPS:
        case NALU_TYPE_SEI:
        {
          ALOGV("\n Non-AU boundary with NAL type %d", nal_unit.nalu_type);
          if(m_au_data)
          {
            isNewFrame = OMX_TRUE;
            m_au_data = false;
          }
          else
          {
            isNewFrame =  OMX_FALSE;
          }

          m_forceToStichNextNAL = true;
          break;
        }
        case NALU_TYPE_ACCESS_DELIM:
        case NALU_TYPE_UNSPECIFIED:
        case NALU_TYPE_EOSEQ:
        case NALU_TYPE_EOSTREAM:
        default:
        {
          isNewFrame =  OMX_FALSE;
          // Do not update m_forceToStichNextNAL
          break;
        }
      } // end of switch
    } // end of if
    m_prv_nalu = nal_unit;
    ALOGV("get_h264_nal_type - newFrame value %d\n",isNewFrame);
    return eRet;
}

void perf_metrics::start()
{
  if (!active)
  {
    start_time = get_act_time();
    active = true;
  }
}

void perf_metrics::stop()
{
  OMX_U64 stop_time = get_act_time();
  if (active)
  {
    proc_time += (stop_time - start_time);
    active = false;
  }
}

void perf_metrics::end(OMX_U32 units_cntr)
{
  stop();
  ALOGV("--> Processing time : [%.2f] Sec", (float)proc_time / 1e6);
  if (units_cntr)
  {
    ALOGV("--> Avrg proc time  : [%.2f] mSec", proc_time / (float)(units_cntr * 1e3));
  }
}

void perf_metrics::reset()
{
  start_time = 0;
  proc_time = 0;
  active = false;
}

OMX_U64 perf_metrics::get_act_time()
{
  struct timeval act_time = {0, 0};
  gettimeofday(&act_time, NULL);
  return (act_time.tv_usec + act_time.tv_sec * 1e6);
}

OMX_U64 perf_metrics::processing_time_us()
{
  return proc_time;
}

h264_stream_parser::h264_stream_parser()
{
  reset();
#ifdef PANSCAN_HDLR
  panscan_hdl = new panscan_handler();
  if (!panscan_hdl)
  {
    ALOGE("ERROR: Panscan hdl was not allocated!");
  }
  else if (!panscan_hdl->initialize(10))
  {
    ALOGE("ERROR: Allocating memory for panscan!");
    delete panscan_hdl;
    panscan_hdl = NULL;
  }
#else
  memset(&panscan_param, 0, sizeof(panscan_param));
  panscan_param.rect_id = NO_PAN_SCAN_BIT;
#endif
}

h264_stream_parser::~h264_stream_parser()
{
#ifdef PANSCAN_HDLR
  if (panscan_hdl)
  {
    delete panscan_hdl;
    panscan_hdl = NULL;
  }
#endif
}

void h264_stream_parser::reset()
{
  curr_32_bit = 0;
  bits_read = 0;
  zero_cntr = 0;
  emulation_code_skip_cntr = 0;
  emulation_sc_enabled = true;
  bitstream = NULL;
  bitstream_bytes = 0;
  memset(&vui_param, 0, sizeof(vui_param));
  vui_param.fixed_fps_prev_ts = LLONG_MAX;
  memset(&sei_buf_period, 0, sizeof(sei_buf_period));
  memset(&sei_pic_timing, 0, sizeof(sei_pic_timing));
  memset(&frame_packing_arrangement,0,sizeof(frame_packing_arrangement));
  frame_packing_arrangement.cancel_flag = 1;
  mbaff_flag = 0;
}

void h264_stream_parser::init_bitstream(OMX_U8* data, OMX_U32 size)
{
  bitstream = data;
  bitstream_bytes = size;
  curr_32_bit = 0;
  bits_read = 0;
  zero_cntr = 0;
  emulation_code_skip_cntr = 0;
}

void h264_stream_parser::parse_vui(bool vui_in_extradata)
{
  OMX_U32 value = 0;
  ALOGV("parse_vui: IN");
  if (vui_in_extradata)
    while (!extract_bits(1) && more_bits()); // Discard VUI enable flag
  if (!more_bits())
    return;

  vui_param.aspect_ratio_info_present_flag = extract_bits(1); //aspect_ratio_info_present_flag
  if (vui_param.aspect_ratio_info_present_flag)
  {
      ALOGV("Aspect Ratio Info present!");
      aspect_ratio_info();
  }

  if (extract_bits(1)) //overscan_info_present_flag
    extract_bits(1); //overscan_appropriate_flag
  if (extract_bits(1)) //video_signal_type_present_flag
  {
    extract_bits(3); //video_format
    extract_bits(1); //video_full_range_flag
    if (extract_bits(1)) //colour_description_present_flag
    {
      extract_bits(8); //colour_primaries
      extract_bits(8); //transfer_characteristics
      extract_bits(8); //matrix_coefficients
    }
  }
  if (extract_bits(1)) //chroma_location_info_present_flag
  {
    uev(); //chroma_sample_loc_type_top_field
    uev(); //chroma_sample_loc_type_bottom_field
  }
  vui_param.timing_info_present_flag = extract_bits(1);
  if (vui_param.timing_info_present_flag)
  {
    vui_param.num_units_in_tick = extract_bits(32);
    vui_param.time_scale = extract_bits(32);
    vui_param.fixed_frame_rate_flag = extract_bits(1);
    ALOGV("Timing info present in VUI!");
    ALOGV("  num units in tick  : %u", vui_param.num_units_in_tick);
    ALOGV("  time scale         : %u", vui_param.time_scale);
    ALOGV("  fixed frame rate   : %u", vui_param.fixed_frame_rate_flag);
  }
  vui_param.nal_hrd_parameters_present_flag = extract_bits(1);
  if (vui_param.nal_hrd_parameters_present_flag)
  {
    ALOGV("nal hrd params present!");
    hrd_parameters(&vui_param.nal_hrd_parameters);
  }
  vui_param.vcl_hrd_parameters_present_flag = extract_bits(1);
  if (vui_param.vcl_hrd_parameters_present_flag)
  {
    ALOGV("vcl hrd params present!");
    hrd_parameters(&vui_param.vcl_hrd_parameters);
  }
  if (vui_param.nal_hrd_parameters_present_flag ||
      vui_param.vcl_hrd_parameters_present_flag)
    vui_param.low_delay_hrd_flag = extract_bits(1);
  vui_param.pic_struct_present_flag = extract_bits(1);
  ALOGV("pic_struct_present_flag : %u", vui_param.pic_struct_present_flag);
  if (extract_bits(1)) //bitstream_restriction_flag
  {
    extract_bits(1); //motion_vectors_over_pic_boundaries_flag
    uev(); //max_bytes_per_pic_denom
    uev(); //max_bits_per_mb_denom
    uev(); //log2_max_mv_length_vertical
    uev(); //log2_max_mv_length_horizontal
    uev(); //num_reorder_frames
    uev(); //max_dec_frame_buffering
  }
  ALOGV("parse_vui: OUT");
}

void h264_stream_parser::aspect_ratio_info()
{
  ALOGV("aspect_ratio_info: IN");
  OMX_U32  aspect_ratio_idc = 0;
  OMX_U32  aspect_ratio_x = 0;
  OMX_U32  aspect_ratio_y = 0;
  aspect_ratio_idc = extract_bits(8); //aspect_ratio_idc
  switch (aspect_ratio_idc)
  {
    case 1:
      aspect_ratio_x = 1;
      aspect_ratio_y = 1;
      break;
    case 2:
      aspect_ratio_x = 12;
      aspect_ratio_y = 11;
      break;
    case 3:
      aspect_ratio_x = 10;
      aspect_ratio_y = 11;
      break;
    case 4:
      aspect_ratio_x = 16;
      aspect_ratio_y = 11;
      break;
    case 5:
      aspect_ratio_x = 40;
      aspect_ratio_y = 33;
      break;
    case 6:
      aspect_ratio_x = 24;
      aspect_ratio_y = 11;
      break;
    case 7:
      aspect_ratio_x = 20;
      aspect_ratio_y = 11;
      break;
    case 8:
      aspect_ratio_x = 32;
      aspect_ratio_y = 11;
      break;
    case 9:
      aspect_ratio_x = 80;
      aspect_ratio_y = 33;
      break;
    case 10:
      aspect_ratio_x = 18;
      aspect_ratio_y = 11;
      break;
    case 11:
      aspect_ratio_x = 15;
      aspect_ratio_y = 11;
      break;
    case 12:
      aspect_ratio_x = 64;
      aspect_ratio_y = 33;
      break;
    case 13:
      aspect_ratio_x = 160;
      aspect_ratio_y = 99;
      break;
    case 14:
      aspect_ratio_x = 4;
      aspect_ratio_y = 3;
      break;
    case 15:
      aspect_ratio_x = 3;
      aspect_ratio_y = 2;
      break;
    case 16:
      aspect_ratio_x = 2;
      aspect_ratio_y = 1;
      break;
    case 255:
      aspect_ratio_x = extract_bits(16); //sar_width
      aspect_ratio_y = extract_bits(16); //sar_height
      break;
    default:
      ALOGV("-->aspect_ratio_idc: Reserved Value ");
      break;
  }
  ALOGV("-->aspect_ratio_idc        : %u", aspect_ratio_idc);
  ALOGV("-->aspect_ratio_x          : %u", aspect_ratio_x);
  ALOGV("-->aspect_ratio_y          : %u", aspect_ratio_y);
  vui_param.aspect_ratio_info.aspect_ratio_idc = aspect_ratio_idc;
  vui_param.aspect_ratio_info.aspect_ratio_x = aspect_ratio_x;
  vui_param.aspect_ratio_info.aspect_ratio_y = aspect_ratio_y;
  ALOGV("aspect_ratio_info: OUT");
}

void h264_stream_parser::hrd_parameters(h264_hrd_param *hrd_param)
{
  int idx;
  ALOGV("hrd_parameters: IN");
  hrd_param->cpb_cnt = uev() + 1;
  hrd_param->bit_rate_scale = extract_bits(4);
  hrd_param->cpb_size_scale = extract_bits(4);
  ALOGV("-->cpb_cnt        : %u", hrd_param->cpb_cnt);
  ALOGV("-->bit_rate_scale : %u", hrd_param->bit_rate_scale);
  ALOGV("-->cpb_size_scale : %u", hrd_param->cpb_size_scale);
  if (hrd_param->cpb_cnt > MAX_CPB_COUNT)
  {
    ALOGV("ERROR: Invalid hrd_param->cpb_cnt [%u]!", hrd_param->cpb_cnt);
    return;
  }
  for (idx = 0; idx < hrd_param->cpb_cnt && more_bits(); idx++)
  {
    hrd_param->bit_rate_value[idx] = uev() + 1;
    hrd_param->cpb_size_value[idx] = uev() + 1;
    hrd_param->cbr_flag[idx] = extract_bits(1);
    ALOGV("-->bit_rate_value [%d] : %u", idx, hrd_param->bit_rate_value[idx]);
    ALOGV("-->cpb_size_value [%d] : %u", idx, hrd_param->cpb_size_value[idx]);
    ALOGV("-->cbr_flag       [%d] : %u", idx, hrd_param->cbr_flag[idx]);
  }
  hrd_param->initial_cpb_removal_delay_length = extract_bits(5) + 1;
  hrd_param->cpb_removal_delay_length = extract_bits(5) + 1;
  hrd_param->dpb_output_delay_length = extract_bits(5) + 1;
  hrd_param->time_offset_length = extract_bits(5);
  ALOGV("-->initial_cpb_removal_delay_length : %u", hrd_param->initial_cpb_removal_delay_length);
  ALOGV("-->cpb_removal_delay_length         : %u", hrd_param->cpb_removal_delay_length);
  ALOGV("-->dpb_output_delay_length          : %u", hrd_param->dpb_output_delay_length);
  ALOGV("-->time_offset_length               : %u", hrd_param->time_offset_length);
  ALOGV("hrd_parameters: OUT");
}

void h264_stream_parser::parse_sei()
{
  OMX_U32 value = 0, processed_bytes = 0;
  OMX_U8 *sei_msg_start = bitstream;
  OMX_U32 sei_unit_size = bitstream_bytes;
  ALOGV("@@parse_sei: IN sei_unit_size(%u)", sei_unit_size);
  while ((processed_bytes + 2) < sei_unit_size && more_bits())
  {
    init_bitstream(sei_msg_start + processed_bytes, sei_unit_size - processed_bytes);
    ALOGV("-->NALU_TYPE_SEI");
    OMX_U32 payload_type = 0, payload_size = 0, aux = 0;
    do {
      value = extract_bits(8);
      payload_type += value;
      processed_bytes++;
    } while (value == 0xFF);
    ALOGV("-->payload_type   : %u", payload_type);
    do {
      value = extract_bits(8);
      payload_size += value;
      processed_bytes++;
    } while (value == 0xFF);
    ALOGV("-->payload_size   : %u", payload_size);
    if (payload_size > 0)
    {
      switch (payload_type)
      {
        case BUFFERING_PERIOD:
          sei_buffering_period();
        break;
        case PIC_TIMING:
          sei_picture_timing();
        break;
        case PAN_SCAN_RECT:
          sei_pan_scan();
        break;
        case SEI_PAYLOAD_FRAME_PACKING_ARRANGEMENT:
          parse_frame_pack();
        break;
        default:
          ALOGV("-->SEI payload type [%u] not implemented! size[%u]", payload_type, payload_size);
      }
    }
    processed_bytes += (payload_size + emulation_code_skip_cntr);
    ALOGV("-->SEI processed_bytes[%u]", processed_bytes);
  }
  ALOGV("@@parse_sei: OUT");
}

void h264_stream_parser::sei_buffering_period()
{
  int idx;
  OMX_U32 value = 0;
  h264_hrd_param *hrd_param = NULL;
  ALOGV("@@sei_buffering_period: IN");
  value = uev(); // seq_parameter_set_id
  ALOGV("-->seq_parameter_set_id : %u", value);
  if (value > 31)
  {
    ALOGV("ERROR: Invalid seq_parameter_set_id [%u]!", value);
    return;
  }
  sei_buf_period.is_valid = false;
  if (vui_param.nal_hrd_parameters_present_flag)
  {
    hrd_param = &vui_param.nal_hrd_parameters;
    if (hrd_param->cpb_cnt > MAX_CPB_COUNT)
    {
      ALOGV("ERROR: Invalid hrd_param->cpb_cnt [%u]!", hrd_param->cpb_cnt);
      return;
    }
    for (idx = 0; idx < hrd_param->cpb_cnt ; idx++)
    {
      sei_buf_period.is_valid = true;
      sei_buf_period.initial_cpb_removal_delay[idx] = extract_bits(hrd_param->initial_cpb_removal_delay_length);
      sei_buf_period.initial_cpb_removal_delay_offset[idx] = extract_bits(hrd_param->initial_cpb_removal_delay_length);
      ALOGV("-->initial_cpb_removal_delay        : %u", sei_buf_period.initial_cpb_removal_delay[idx]);
      ALOGV("-->initial_cpb_removal_delay_offset : %u", sei_buf_period.initial_cpb_removal_delay_offset[idx]);
    }
  }
  if (vui_param.vcl_hrd_parameters_present_flag)
  {
    hrd_param = &vui_param.vcl_hrd_parameters;
    if (hrd_param->cpb_cnt > MAX_CPB_COUNT)
    {
      ALOGV("ERROR: Invalid hrd_param->cpb_cnt [%u]!", hrd_param->cpb_cnt);
      return;
    }
    for (idx = 0; idx < hrd_param->cpb_cnt ; idx++)
    {
      sei_buf_period.is_valid = true;
      sei_buf_period.initial_cpb_removal_delay[idx] = extract_bits(hrd_param->initial_cpb_removal_delay_length);
      sei_buf_period.initial_cpb_removal_delay_offset[idx] = extract_bits(hrd_param->initial_cpb_removal_delay_length);
      ALOGV("-->initial_cpb_removal_delay        : %u", sei_buf_period.initial_cpb_removal_delay[idx]);
      ALOGV("-->initial_cpb_removal_delay_offset : %u", sei_buf_period.initial_cpb_removal_delay_offset[idx]);
    }
  }
  sei_buf_period.au_cntr = 0;
  ALOGV("@@sei_buffering_period: OUT");
}

void h264_stream_parser::sei_picture_timing()
{
  ALOGV("@@sei_picture_timing: IN");
  OMX_U32 time_offset_len = 0, cpb_removal_len = 24, dpb_output_len  = 24;
  OMX_U8 cbr_flag = 0;
  sei_pic_timing.is_valid = true;
  if (vui_param.nal_hrd_parameters_present_flag)
  {
    cpb_removal_len = vui_param.nal_hrd_parameters.cpb_removal_delay_length;
    dpb_output_len = vui_param.nal_hrd_parameters.dpb_output_delay_length;
    time_offset_len = vui_param.nal_hrd_parameters.time_offset_length;
    cbr_flag = vui_param.nal_hrd_parameters.cbr_flag[0];
  }
  else if (vui_param.vcl_hrd_parameters_present_flag)
  {
    cpb_removal_len = vui_param.vcl_hrd_parameters.cpb_removal_delay_length;
    dpb_output_len = vui_param.vcl_hrd_parameters.dpb_output_delay_length;
    time_offset_len = vui_param.vcl_hrd_parameters.time_offset_length;
    cbr_flag = vui_param.vcl_hrd_parameters.cbr_flag[0];
  }
  sei_pic_timing.cpb_removal_delay = extract_bits(cpb_removal_len);
  sei_pic_timing.dpb_output_delay = extract_bits(dpb_output_len);
  ALOGV("-->cpb_removal_len : %u", cpb_removal_len);
  ALOGV("-->dpb_output_len  : %u", dpb_output_len);
  ALOGV("-->cpb_removal_delay : %u", sei_pic_timing.cpb_removal_delay);
  ALOGV("-->dpb_output_delay  : %u", sei_pic_timing.dpb_output_delay);
  if (vui_param.pic_struct_present_flag)
  {
    sei_pic_timing.pic_struct = extract_bits(4);
    sei_pic_timing.num_clock_ts = 0;
    switch (sei_pic_timing.pic_struct)
    {
      case 0: case 1: case 2: sei_pic_timing.num_clock_ts = 1; break;
      case 3: case 4: case 7: sei_pic_timing.num_clock_ts = 2; break;
      case 5: case 6: case 8: sei_pic_timing.num_clock_ts = 3; break;
      default:
        ALOGE("sei_picture_timing: pic_struct invalid!");
    }
    ALOGV("-->num_clock_ts      : %u", sei_pic_timing.num_clock_ts);
    for (int i = 0; i < sei_pic_timing.num_clock_ts && more_bits(); i++)
    {
      sei_pic_timing.clock_ts_flag = extract_bits(1);
      if(sei_pic_timing.clock_ts_flag)
      {
        ALOGV("-->clock_timestamp present!");
        sei_pic_timing.ct_type = extract_bits(2);
        sei_pic_timing.nuit_field_based_flag = extract_bits(1);
        sei_pic_timing.counting_type = extract_bits(5);
        sei_pic_timing.full_timestamp_flag = extract_bits(1);
        sei_pic_timing.discontinuity_flag = extract_bits(1);
        sei_pic_timing.cnt_dropped_flag = extract_bits(1);
        sei_pic_timing.n_frames = extract_bits(8);
        ALOGV("-->f_timestamp_flg   : %u", sei_pic_timing.full_timestamp_flag);
        ALOGV("-->n_frames          : %u", sei_pic_timing.n_frames);
        sei_pic_timing.seconds_value = 0;
        sei_pic_timing.minutes_value = 0;
        sei_pic_timing.hours_value = 0;
        if (sei_pic_timing.full_timestamp_flag)
        {
          sei_pic_timing.seconds_value = extract_bits(6);
          sei_pic_timing.minutes_value = extract_bits(6);
          sei_pic_timing.hours_value = extract_bits(5);
        }
        else if (extract_bits(1))
        {
          ALOGV("-->seconds_flag enabled!");
          sei_pic_timing.seconds_value = extract_bits(6);
          if (extract_bits(1))
          {
            ALOGV("-->minutes_flag enabled!");
            sei_pic_timing.minutes_value = extract_bits(6);
            if (extract_bits(1))
            {
              ALOGV("-->hours_flag enabled!");
              sei_pic_timing.hours_value = extract_bits(5);
            }
          }
        }
        sei_pic_timing.time_offset = 0;
        if (time_offset_len > 0)
          sei_pic_timing.time_offset = iv(time_offset_len);
        ALOGV("-->seconds_value     : %u", sei_pic_timing.seconds_value);
        ALOGV("-->minutes_value     : %u", sei_pic_timing.minutes_value);
        ALOGV("-->hours_value       : %u", sei_pic_timing.hours_value);
        ALOGV("-->time_offset       : %d", sei_pic_timing.time_offset);
      }
    }
  }
  ALOGV("@@sei_picture_timing: OUT");
}

void h264_stream_parser::sei_pan_scan()
{
#ifdef _ANDROID_
  char property_value[PROPERTY_VALUE_MAX] = {0};
  OMX_S32 enable_panscan_log = 0;
  property_get("vidc.dec.debug.panframedata", property_value, "0");
  enable_panscan_log = atoi(property_value);
#endif
#ifdef PANSCAN_HDLR
  h264_pan_scan *pan_scan_param = panscan_hdl->get_free();
#else
  h264_pan_scan *pan_scan_param = &panscan_param;
#endif

  if (!pan_scan_param)
  {
    ALOGE("sei_pan_scan: ERROR: Invalid pointer!");
    return;
  }

  pan_scan_param->rect_id = uev();
  if (pan_scan_param->rect_id > 0xFF)
  {
    ALOGE("sei_pan_scan: ERROR: Invalid rect_id[%u]!", pan_scan_param->rect_id);
    pan_scan_param->rect_id = NO_PAN_SCAN_BIT;
    return;
  }

  pan_scan_param->rect_cancel_flag = extract_bits(1);

  if (pan_scan_param->rect_cancel_flag)
    pan_scan_param->rect_id = NO_PAN_SCAN_BIT;
  else
  {
    pan_scan_param->cnt = uev() + 1;
    if (pan_scan_param->cnt > MAX_PAN_SCAN_RECT)
    {
      ALOGE("sei_pan_scan: ERROR: Invalid num of rect [%u]!", pan_scan_param->cnt);
      pan_scan_param->rect_id = NO_PAN_SCAN_BIT;
      return;
    }

    for (int i = 0; i < pan_scan_param->cnt; i++)
    {
      pan_scan_param->rect_left_offset[i] = sev();
      pan_scan_param->rect_right_offset[i] = sev();
      pan_scan_param->rect_top_offset[i] = sev();
      pan_scan_param->rect_bottom_offset[i] = sev();

    }
    pan_scan_param->rect_repetition_period = uev();
#ifdef PANSCAN_HDLR
    if (pan_scan_param->rect_repetition_period > 1)
      // Repetition period is decreased by 2 each time panscan data is used
      pan_scan_param->rect_repetition_period *= 2;
#endif
#ifdef _ANDROID_
     if (enable_panscan_log)
     {
       print_pan_data(pan_scan_param);
     }
#endif
  }
}

void h264_stream_parser::print_pan_data(h264_pan_scan *pan_scan_param)
{
  ALOGV("@@print_pan_data: IN");

  ALOGV("-->rect_id            : %u", pan_scan_param->rect_id);
  ALOGV("-->rect_cancel_flag   : %u", pan_scan_param->rect_cancel_flag);

  ALOGV("-->cnt                : %u", pan_scan_param->cnt);

  for (int i = 0; i < pan_scan_param->cnt; i++)
  {
    ALOGV("-->rect_left_offset   : %d", pan_scan_param->rect_left_offset[i]);
    ALOGV("-->rect_right_offset  : %d", pan_scan_param->rect_right_offset[i]);
    ALOGV("-->rect_top_offset    : %d", pan_scan_param->rect_top_offset[i]);
    ALOGV("-->rect_bottom_offset : %d", pan_scan_param->rect_bottom_offset[i]);
  }
  ALOGV("-->repetition_period  : %u", pan_scan_param->rect_repetition_period);

  ALOGV("@@print_pan_data: OUT");
}

void h264_stream_parser::parse_sps()
{
  OMX_U32 value = 0, scaling_matrix_limit;
  ALOGV("@@parse_sps: IN");
  value = extract_bits(8); //profile_idc
  extract_bits(8); //constraint flags and reserved bits
  extract_bits(8); //level_idc
  uev(); //sps id
  if (value == 100 || value == 110 || value == 122 || value == 244 ||
      value ==  44 || value ==  83 || value ==  86 || value == 118)
  {
    if (uev() == 3) //chroma_format_idc
    {
      extract_bits(1); //separate_colour_plane_flag
      scaling_matrix_limit = 12;
    }
    else
      scaling_matrix_limit = 12;
    uev(); //bit_depth_luma_minus8
    uev(); //bit_depth_chroma_minus8
    extract_bits(1); //qpprime_y_zero_transform_bypass_flag
    if (extract_bits(1)) //seq_scaling_matrix_present_flag
      for (int i = 0; i < scaling_matrix_limit && more_bits(); i++)
      {
        if (extract_bits(1)) ////seq_scaling_list_present_flag[ i ]
          if (i < 6)
            scaling_list(16);
          else
            scaling_list(64);
      }
  }
  uev(); //log2_max_frame_num_minus4
  value = uev(); //pic_order_cnt_type
  if (value == 0)
    uev(); //log2_max_pic_order_cnt_lsb_minus4
  else if (value == 1)
  {
    extract_bits(1); //delta_pic_order_always_zero_flag
    sev(); //offset_for_non_ref_pic
    sev(); //offset_for_top_to_bottom_field
    value = uev(); // num_ref_frames_in_pic_order_cnt_cycle
    for (int i = 0; i < value; i++)
      sev(); //offset_for_ref_frame[ i ]
  }
  uev(); //max_num_ref_frames
  extract_bits(1); //gaps_in_frame_num_value_allowed_flag
  value = uev(); //pic_width_in_mbs_minus1
  value = uev(); //pic_height_in_map_units_minus1
  if (!extract_bits(1)) //frame_mbs_only_flag
    mbaff_flag = extract_bits(1); //mb_adaptive_frame_field_flag
  extract_bits(1); //direct_8x8_inference_flag
  if (extract_bits(1)) //frame_cropping_flag
  {
    uev(); //frame_crop_left_offset
    uev(); //frame_crop_right_offset
    uev(); //frame_crop_top_offset
    uev(); //frame_crop_bottom_offset
  }
  if (extract_bits(1)) //vui_parameters_present_flag
    parse_vui(false);
  ALOGV("@@parse_sps: OUT");
}

void h264_stream_parser::scaling_list(OMX_U32 size_of_scaling_list)
{
  OMX_S32 last_scale = 8, next_scale = 8, delta_scale;
  for (int j = 0; j < size_of_scaling_list; j++)
  {
    if (next_scale != 0)
    {
      delta_scale = sev();
      next_scale = (last_scale + delta_scale + 256) % 256;
    }
    last_scale = (next_scale == 0)? last_scale : next_scale;
  }
}

OMX_U32 h264_stream_parser::extract_bits(OMX_U32 n)
{
  OMX_U32 value = 0;
  if (n > 32)
  {
    ALOGE("ERROR: extract_bits limit to 32 bits!");
    return value;
  }
  value = curr_32_bit >> (32 - n);
  if (bits_read < n)
  {
    n -= bits_read;
    read_word();
    value |= (curr_32_bit >> (32 - n));
    if (bits_read < n)
    {
      ALOGV("ERROR: extract_bits underflow!");
      value >>= (n - bits_read);
      n = bits_read;
    }
  }
  bits_read -= n;
  curr_32_bit <<= n;
  return value;
}

void h264_stream_parser::read_word()
{
  curr_32_bit = 0;
  bits_read = 0;
  while (bitstream_bytes && bits_read < 32)
  {
    if (*bitstream == EMULATION_PREVENTION_THREE_BYTE &&
        zero_cntr >= 2 && emulation_sc_enabled)
    {
      ALOGV("EMULATION_PREVENTION_THREE_BYTE: Skip 0x03 byte aligned!");
      emulation_code_skip_cntr++;
    }
    else
    {
      curr_32_bit <<= 8;
      curr_32_bit |= *bitstream;
      bits_read += 8;
    }
    if (*bitstream == 0)
      zero_cntr++;
    else
      zero_cntr = 0;
    bitstream++;
    bitstream_bytes--;
  }
  curr_32_bit <<= (32 - bits_read);
}

OMX_U32 h264_stream_parser::uev()
{
  OMX_U32 lead_zero_bits = 0, code_num = 0;
  while(!extract_bits(1) && more_bits())
    lead_zero_bits++;
  code_num = lead_zero_bits == 0 ? 0 :
    (1 << lead_zero_bits) - 1 + extract_bits(lead_zero_bits);
  return code_num;
}

bool h264_stream_parser::more_bits()
{
  return (bitstream_bytes > 0 || bits_read > 0);
}

OMX_S32 h264_stream_parser::sev()
{
  OMX_U32 code_num = uev();
  OMX_S32 ret;
  ret = (code_num + 1) >> 1;
  return ((code_num & 1) ? ret : -ret);
}

OMX_S32 h264_stream_parser::iv(OMX_U32 n_bits)
{
  OMX_U32 code_num = extract_bits(n_bits);
  OMX_S32 ret = (code_num >> (n_bits - 1))? (-1)*(~(code_num & ~(0x1 << (n_bits - 1))) + 1) : code_num;
  return ret;
}

OMX_U32 h264_stream_parser::get_nal_unit_type(OMX_U32 *nal_unit_type)
{
  OMX_U32 value = 0, consumed_bytes = 3;
  *nal_unit_type = NALU_TYPE_UNSPECIFIED;
  ALOGV("-->get_nal_unit_type: IN");
  value = extract_bits(24);
  while (value != 0x00000001 && more_bits())
  {
    value <<= 8;
    value |= extract_bits(8);
    consumed_bytes++;
  }
  if (value != 0x00000001)
  {
    ALOGE("ERROR in get_nal_unit_type: Start code not found!");
  }
  else
  {
    if (extract_bits(1)) // forbidden_zero_bit
    {
      ALOGE("WARNING: forbidden_zero_bit should be zero!");
    }
    value = extract_bits(2);
    ALOGV("-->nal_ref_idc    : %x", value);
    *nal_unit_type = extract_bits(5);
    ALOGV("-->nal_unit_type  : %x", *nal_unit_type);
    consumed_bytes++;
    if (consumed_bytes > 5)
    {
      ALOGE("-->WARNING: Startcode was found after the first 4 bytes!");
    }
  }
  ALOGV("-->get_nal_unit_type: OUT");
  return consumed_bytes;
}

OMX_S64 h264_stream_parser::calculate_buf_period_ts(OMX_S64 timestamp)
{
  OMX_S64 clock_ts = timestamp;
  ALOGV("calculate_ts(): IN");
  if (sei_buf_period.au_cntr == 0)
    clock_ts = sei_buf_period.reference_ts = timestamp;
  else if (sei_pic_timing.is_valid && VALID_TS(sei_buf_period.reference_ts))
  {
    clock_ts = sei_buf_period.reference_ts + sei_pic_timing.cpb_removal_delay *
               1e6 * vui_param.num_units_in_tick / vui_param.time_scale;
  }
  sei_buf_period.au_cntr++;
  ALOGV("calculate_ts(): OUT");
  return clock_ts;
}

OMX_S64 h264_stream_parser::calculate_fixed_fps_ts(OMX_S64 timestamp, OMX_U32 DeltaTfiDivisor)
{
  if (VALID_TS(timestamp))
    vui_param.fixed_fps_prev_ts = timestamp;
  else if (VALID_TS(vui_param.fixed_fps_prev_ts))
    vui_param.fixed_fps_prev_ts += DeltaTfiDivisor * 1e6 *
                                   vui_param.num_units_in_tick / vui_param.time_scale;
  return vui_param.fixed_fps_prev_ts;
}

void h264_stream_parser::parse_frame_pack()
{
#ifdef _ANDROID_
  char property_value[PROPERTY_VALUE_MAX] = {0};
  OMX_S32 enable_framepack_log = 0;

  property_get("vidc.dec.debug.panframedata", property_value, "0");
  enable_framepack_log = atoi(property_value);
#endif
  ALOGV("\n%s:%d parse_frame_pack", __func__, __LINE__);

  frame_packing_arrangement.id = uev();

  frame_packing_arrangement.cancel_flag = extract_bits(1);
  if(!frame_packing_arrangement.cancel_flag) {
     frame_packing_arrangement.type = extract_bits(7);
     frame_packing_arrangement.quincunx_sampling_flag = extract_bits(1);
     frame_packing_arrangement.content_interpretation_type = extract_bits(6);
     frame_packing_arrangement.spatial_flipping_flag = extract_bits(1);
     frame_packing_arrangement.frame0_flipped_flag = extract_bits(1);
     frame_packing_arrangement.field_views_flag = extract_bits(1);
     frame_packing_arrangement.current_frame_is_frame0_flag = extract_bits(1);
     frame_packing_arrangement.frame0_self_contained_flag = extract_bits(1);
     frame_packing_arrangement.frame1_self_contained_flag = extract_bits(1);

     if(!frame_packing_arrangement.quincunx_sampling_flag &&
        frame_packing_arrangement.type != 5) {
        frame_packing_arrangement.frame0_grid_position_x = extract_bits(4);
        frame_packing_arrangement.frame0_grid_position_y = extract_bits(4);
        frame_packing_arrangement.frame1_grid_position_x = extract_bits(4);
        frame_packing_arrangement.frame1_grid_position_y = extract_bits(4);
     }
     frame_packing_arrangement.reserved_byte = extract_bits(8);
     frame_packing_arrangement.repetition_period = uev();
   }
   frame_packing_arrangement.extension_flag = extract_bits(1);

#ifdef _ANDROID_
   if (enable_framepack_log)
   {
     print_frame_pack();
   }
#endif
}

void h264_stream_parser::print_frame_pack()
{
  ALOGV("\n ## frame_packing_arrangement.id = %u", frame_packing_arrangement.id);
  ALOGV("\n ## frame_packing_arrangement.cancel_flag = %u",
                       frame_packing_arrangement.cancel_flag);
  if(!frame_packing_arrangement.cancel_flag)
  {
    ALOGV("\n ## frame_packing_arrangement.type = %u",
                         frame_packing_arrangement.type);
    ALOGV("\n ## frame_packing_arrangement.quincunx_sampling_flag = %u",
                         frame_packing_arrangement.quincunx_sampling_flag);
    ALOGV("\n ## frame_packing_arrangement.content_interpretation_type = %u",
                         frame_packing_arrangement.content_interpretation_type);
    ALOGV("\n ## frame_packing_arrangement.spatial_flipping_flag = %u",
                         frame_packing_arrangement.spatial_flipping_flag);
    ALOGV("\n ## frame_packing_arrangement.frame0_flipped_flag = %u",
                         frame_packing_arrangement.frame0_flipped_flag);
    ALOGV("\n ## frame_packing_arrangement.field_views_flag = %u",
                         frame_packing_arrangement.field_views_flag);
    ALOGV("\n ## frame_packing_arrangement.current_frame_is_frame0_flag = %u",
                         frame_packing_arrangement.current_frame_is_frame0_flag);
    ALOGV("\n ## frame_packing_arrangement.frame0_self_contained_flag = %u",
                         frame_packing_arrangement.frame0_self_contained_flag);
    ALOGV("\n ## frame_packing_arrangement.frame1_self_contained_flag = %u",
                         frame_packing_arrangement.frame1_self_contained_flag);
    ALOGV("\n ## frame_packing_arrangement.reserved_byte = %u",
                         frame_packing_arrangement.reserved_byte);
    ALOGV("\n ## frame_packing_arrangement.repetition_period = %u",
                         frame_packing_arrangement.repetition_period);
    ALOGV("\n ## frame_packing_arrangement.extension_flag = %u",
                         frame_packing_arrangement.extension_flag);
  }
}
/* API'S EXPOSED TO OMX COMPONENT */

void h264_stream_parser::get_frame_pack_data(
  OMX_QCOM_FRAME_PACK_ARRANGEMENT *frame_pack)
{
   ALOGV("\n%s:%d get frame data", __func__, __LINE__);
   memcpy(&frame_pack->id,&frame_packing_arrangement.id,
   FRAME_PACK_SIZE*sizeof(OMX_U32));
   return;
}


bool h264_stream_parser::is_mbaff()
{
   ALOGV("\n%s:%d MBAFF flag=%d", __func__, __LINE__,mbaff_flag);
   return mbaff_flag;
}

void h264_stream_parser::get_frame_rate(OMX_U32 *frame_rate)
{
  if (vui_param.num_units_in_tick != 0)
    *frame_rate = vui_param.time_scale / (2 * vui_param.num_units_in_tick);
}

void h264_stream_parser::parse_nal(OMX_U8* data_ptr, OMX_U32 data_len, OMX_U32 nal_type, bool enable_emu_sc)
{
  OMX_U32 nal_unit_type = NALU_TYPE_UNSPECIFIED, cons_bytes = 0;
  ALOGV("parse_nal(): IN nal_type(%lu)", nal_type);
  if (!data_len)
    return;
  init_bitstream(data_ptr, data_len);
  emulation_sc_enabled = enable_emu_sc;
  if (nal_type != NALU_TYPE_VUI)
  {
    cons_bytes = get_nal_unit_type(&nal_unit_type);
    if (nal_type != nal_unit_type && nal_type != NALU_TYPE_UNSPECIFIED)
    {
      ALOGV("Unexpected nal_type(%x) expected(%x)", nal_unit_type, nal_type);
      return;
    }
  }
  switch (nal_type)
  {
    case NALU_TYPE_SPS:
      if (more_bits())
        parse_sps();
#ifdef PANSCAN_HDLR
      panscan_hdl->get_free();
#endif
    break;
    case NALU_TYPE_SEI:
      init_bitstream(data_ptr + cons_bytes, data_len - cons_bytes);
      parse_sei();
    break;
    case NALU_TYPE_VUI:
      parse_vui(true);
    break;
    default:
      ALOGV("nal_unit_type received : %lu", nal_type);
  }
  ALOGV("parse_nal(): OUT");
}

#ifdef PANSCAN_HDLR
void h264_stream_parser::update_panscan_data(OMX_S64 timestamp)
{
  panscan_hdl->update_last(timestamp);
}
#endif

void h264_stream_parser::fill_aspect_ratio_info(OMX_QCOM_ASPECT_RATIO *dest_aspect_ratio)
{
  if(dest_aspect_ratio && vui_param.aspect_ratio_info_present_flag)
  {
    dest_aspect_ratio->aspectRatioX = vui_param.aspect_ratio_info.aspect_ratio_x;
    dest_aspect_ratio->aspectRatioY = vui_param.aspect_ratio_info.aspect_ratio_y;
  }
}

void h264_stream_parser::fill_pan_scan_data(OMX_QCOM_PANSCAN *dest_pan_scan, OMX_S64 timestamp)
{
#ifdef PANSCAN_HDLR
  h264_pan_scan *pan_scan_param = panscan_hdl->get_populated(timestamp);
#else
  h264_pan_scan *pan_scan_param = &panscan_param;
#endif
  if (pan_scan_param)
    if (!(pan_scan_param->rect_id & NO_PAN_SCAN_BIT))
    {
      PRINT_PANSCAN_PARAM(*pan_scan_param);
      dest_pan_scan->numWindows = pan_scan_param->cnt;
      for (int i = 0; i < dest_pan_scan->numWindows; i++)
      {
        dest_pan_scan->window[i].x = pan_scan_param->rect_left_offset[i];
        dest_pan_scan->window[i].y = pan_scan_param->rect_top_offset[i];
        dest_pan_scan->window[i].dx = pan_scan_param->rect_right_offset[i];
        dest_pan_scan->window[i].dy = pan_scan_param->rect_bottom_offset[i];
      }
#ifndef PANSCAN_HDLR
      if (pan_scan_param->rect_repetition_period == 0)
        pan_scan_param->rect_id = NO_PAN_SCAN_BIT;
      else if (pan_scan_param->rect_repetition_period > 1)
        pan_scan_param->rect_repetition_period =
        (pan_scan_param->rect_repetition_period == 2)? 0 :
        (pan_scan_param->rect_repetition_period - 1);
#endif
    }
    else
      pan_scan_param->rect_repetition_period = 0;
}

OMX_S64 h264_stream_parser::process_ts_with_sei_vui(OMX_S64 timestamp)
{
  bool clock_ts_flag = false;
  OMX_S64 clock_ts = timestamp;
  OMX_U32 deltaTfiDivisor = 2;
  if (vui_param.timing_info_present_flag)
  {
    if (vui_param.pic_struct_present_flag)
    {
      if(sei_pic_timing.clock_ts_flag)
      {
        clock_ts = ((sei_pic_timing.hours_value * 60 + sei_pic_timing.minutes_value) * 60 + sei_pic_timing.seconds_value) * 1e6 +
                    (sei_pic_timing.n_frames * (vui_param.num_units_in_tick * (1 + sei_pic_timing.nuit_field_based_flag)) + sei_pic_timing.time_offset) *
                    1e6 / vui_param.time_scale;
        ALOGV("-->CLOCK TIMESTAMP   : %lld", clock_ts);
        clock_ts_flag = true;
      }
      if (vui_param.fixed_frame_rate_flag)
      {
        switch (sei_pic_timing.pic_struct)
        {
          case 1: case 2:         deltaTfiDivisor = 1; break;
          case 0: case 3: case 4: deltaTfiDivisor = 2; break;
          case 5: case 6:         deltaTfiDivisor = 3; break;
          case 7:                 deltaTfiDivisor = 4; break;
          case 8:                 deltaTfiDivisor = 6; break;
          default:
            ALOGE("process_ts_with_sei_vui: pic_struct invalid!");
        }
      }
    }
    if (!clock_ts_flag)
    {
      if (vui_param.fixed_frame_rate_flag)
        clock_ts = calculate_fixed_fps_ts(timestamp, deltaTfiDivisor);
      else if (sei_buf_period.is_valid)
        clock_ts = calculate_buf_period_ts(timestamp);
    }
  }
  else
  {
    ALOGV("NO TIMING information present in VUI!");
  }
  sei_pic_timing.is_valid = false; // SEI data is valid only for current frame
  return clock_ts;
}

#ifdef PANSCAN_HDLR

panscan_handler::panscan_handler() : panscan_data(NULL) {}

panscan_handler::~panscan_handler()
{
  if (panscan_data)
  {
    free(panscan_data);
    panscan_data = NULL;
  }
}

bool panscan_handler::initialize(int num_data)
{
  bool ret = false;
  if (!panscan_data)
  {
    panscan_data = (PANSCAN_NODE *) malloc (sizeof(PANSCAN_NODE) * num_data);
    if (panscan_data)
    {
      panscan_free.add_multiple(panscan_data, num_data);
      ret = true;
    }
  }
  else
  {
    ALOGE("ERROR: Old panscan memory must be freed to allocate new");
  }
  return ret;
}

h264_pan_scan *panscan_handler::get_free()
{
  h264_pan_scan *data = NULL;
  PANSCAN_NODE *panscan_node = panscan_used.watch_last();
  panscan_node = (!panscan_node || VALID_TS(panscan_node->start_ts))?
                 panscan_free.remove_first() :
                 panscan_used.remove_last();
  if (panscan_node)
  {
    panscan_node->start_ts = LLONG_MAX;
    panscan_node->end_ts = LLONG_MAX;
    panscan_node->pan_scan_param.rect_id = NO_PAN_SCAN_BIT;
    panscan_node->active = false;
    panscan_used.add_last(panscan_node);
    data = &panscan_node->pan_scan_param;
  }
  return data;
}

h264_pan_scan *panscan_handler::get_populated(OMX_S64 frame_ts)
{
  h264_pan_scan *data = NULL;
  PANSCAN_NODE *panscan_node = panscan_used.watch_first();
  while (panscan_node && !data)
  {
    if (VALID_TS(panscan_node->start_ts))
    {
      if (panscan_node->active && frame_ts < panscan_node->start_ts)
        panscan_node->start_ts = frame_ts;
      if (frame_ts >= panscan_node->start_ts)
        if (frame_ts < panscan_node->end_ts)
        {
          data = &panscan_node->pan_scan_param;
          panscan_node->active = true;
        }
        else
        {
          panscan_free.add_last(panscan_used.remove_first());
          panscan_node = panscan_used.watch_first();
        }
      else
        // Finish search if current timestamp has not reached
        // start timestamp of first panscan data.
        panscan_node = NULL;
    }
    else
    {
      // Only one panscan data is stored for clips
      // with invalid timestamps in every frame
      data = &panscan_node->pan_scan_param;
      panscan_node->active = true;
    }
  }
  if (data)
    if (data->rect_repetition_period == 0)
      panscan_free.add_last(panscan_used.remove_first());
    else if (data->rect_repetition_period > 1)
      data->rect_repetition_period -= 2;
  PRINT_PANSCAN_DATA(panscan_node);
  return data;
}

void panscan_handler::update_last(OMX_S64 frame_ts)
{
  PANSCAN_NODE *panscan_node = panscan_used.watch_last();
  if (panscan_node && !VALID_TS(panscan_node->start_ts))
  {
    panscan_node->start_ts = frame_ts;
    PRINT_PANSCAN_DATA(panscan_node);
    if (panscan_node->prev)
    {
      if (frame_ts < panscan_node->prev->end_ts)
        panscan_node->prev->end_ts = frame_ts;
      else if (!VALID_TS(frame_ts))
        panscan_node->prev->pan_scan_param.rect_repetition_period = 0;
      PRINT_PANSCAN_DATA(panscan_node->prev);
    }
  }
}

template <class NODE_STRUCT>
void omx_dl_list<NODE_STRUCT>::add_multiple(NODE_STRUCT *data_arr, int data_num)
{
  for (int idx = 0; idx < data_num; idx++)
    add_last(&data_arr[idx]);
}

template <class NODE_STRUCT>
NODE_STRUCT *omx_dl_list<NODE_STRUCT>::remove_first()
{
  NODE_STRUCT *data = head;
  if (head)
  {
    if (head->next)
    {
      head = head->next;
      head->prev = NULL;
    }
    else
      head = tail = NULL;
    data->next = data->prev = NULL;
  }
  return data;
}

template <class NODE_STRUCT>
NODE_STRUCT *omx_dl_list<NODE_STRUCT>::remove_last()
{
  NODE_STRUCT *data = tail;
  if (tail)
  {
    if (tail->prev)
    {
      tail = tail->prev;
      tail->next = NULL;
    }
    else
      head = tail = NULL;
    data->next = data->prev = NULL;
  }
  return data;
}

template <class NODE_STRUCT>
void omx_dl_list<NODE_STRUCT>::add_last(NODE_STRUCT* data_ptr)
{
  if (data_ptr)
  {
    data_ptr->next = NULL;
    data_ptr->prev = tail;
    if (tail)
    {
      tail->next = data_ptr;
      tail = data_ptr;
    }
    else
      head = tail = data_ptr;
  }
}

template <class NODE_STRUCT>
NODE_STRUCT* omx_dl_list<NODE_STRUCT>::watch_first()
{
  return head;
}

template <class NODE_STRUCT>
NODE_STRUCT* omx_dl_list<NODE_STRUCT>::watch_last()
{
  return tail;
}

#endif