Home | History | Annotate | Download | only in src
      1 /*--------------------------------------------------------------------------
      2 Copyright (c) 2010 - 2013, The Linux Foundation. All rights reserved.
      3 
      4 Redistribution and use in source and binary forms, with or without
      5 modification, are permitted provided that the following conditions are met:
      6     * Redistributions of source code must retain the above copyright
      7       notice, this list of conditions and the following disclaimer.
      8     * Redistributions in binary form must reproduce the above copyright
      9       notice, this list of conditions and the following disclaimer in the
     10       documentation and/or other materials provided with the distribution.
     11     * Neither the name of  The Linux Foundation nor
     12       the names of its contributors may be used to endorse or promote
     13       products derived from this software without specific prior written
     14       permission.
     15 
     16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
     17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     18 IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
     19 NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     20 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     21 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     22 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
     23 OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     24 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
     25 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
     26 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 --------------------------------------------------------------------------*/
     28 /*========================================================================
     29 
     30                       O p e n M M
     31          V i d e o   U t i l i t i e s
     32 
     33 *//** @file VideoUtils.cpp
     34   This module contains utilities and helper routines.
     35 
     36 @par EXTERNALIZED FUNCTIONS
     37 
     38 @par INITIALIZATION AND SEQUENCING REQUIREMENTS
     39   (none)
     40 
     41 *//*====================================================================== */
     42 
     43 /* =======================================================================
     44 
     45                      INCLUDE FILES FOR MODULE
     46 
     47 ========================================================================== */
     48 #include "h264_utils.h"
     49 #include "extra_data_handler.h"
     50 #include <string.h>
     51 #include <stdlib.h>
     52 #include <limits.h>
     53 #include <sys/time.h>
     54 #ifdef _ANDROID_
     55 #include <cutils/properties.h>
     56 extern "C" {
     57 #include<utils/Log.h>
     58 }
     59 
     60 #endif
     61 
     62 /* =======================================================================
     63 
     64    DEFINITIONS AND DECLARATIONS FOR MODULE
     65 
     66    This section contains definitions for constants, macros, types, variables
     67    and other items needed by this module.
     68 
     69    ========================================================================== */
     70 
     71 
     72 #define MAX_SUPPORTED_LEVEL 32
     73 
     74     RbspParser::RbspParser (const uint8 *_begin, const uint8 *_end)
     75 : begin (_begin), end(_end), pos (- 1), bit (0),
     76     cursor (0xFFFFFF), advanceNeeded (true)
     77 {
     78 }
     79 
     80 // Destructor
     81 /*lint -e{1540}  Pointer member neither freed nor zeroed by destructor
     82  * No problem
     83  */
     84 RbspParser::~RbspParser () {}
     85 
     86 // Return next RBSP byte as a word
     87 uint32 RbspParser::next ()
     88 {
     89     if (advanceNeeded) advance ();
     90     //return static_cast<uint32> (*pos);
     91     return static_cast<uint32> (begin[pos]);
     92 }
     93 
     94 // Advance RBSP decoder to next byte
     95 void RbspParser::advance ()
     96 {
     97     ++pos;
     98     //if (pos >= stop)
     99     if (begin + pos == end) {
    100         /*lint -e{730}  Boolean argument to function
    101          * I don't see a problem here
    102          */
    103         //throw false;
    104         ALOGV("H264Parser-->NEED TO THROW THE EXCEPTION...");
    105     }
    106     cursor <<= 8;
    107     //cursor |= static_cast<uint32> (*pos);
    108     cursor |= static_cast<uint32> (begin[pos]);
    109     if ((cursor & 0xFFFFFF) == 0x000003) {
    110         advance ();
    111     }
    112     advanceNeeded = false;
    113 }
    114 
    115 // Decode unsigned integer
    116 uint32 RbspParser::u (uint32 n)
    117 {
    118     uint32 i, s, x = 0;
    119     for (i = 0; i < n; i += s) {
    120         s = static_cast<uint32>STD_MIN(static_cast<int>(8 - bit),
    121                 static_cast<int>(n - i));
    122         x <<= s;
    123 
    124         x |= ((next () >> ((8 - static_cast<uint32>(bit)) - s)) &
    125                 ((1 << s) - 1));
    126 
    127         bit = (bit + s) % 8;
    128         if (!bit) {
    129             advanceNeeded = true;
    130         }
    131     }
    132     return x;
    133 }
    134 
    135 // Decode unsigned integer Exp-Golomb-coded syntax element
    136 uint32 RbspParser::ue ()
    137 {
    138     int leadingZeroBits = -1;
    139     for (uint32 b = 0; !b; ++leadingZeroBits) {
    140         b = u (1);
    141     }
    142     return ((1 << leadingZeroBits) - 1) +
    143         u (static_cast<uint32>(leadingZeroBits));
    144 }
    145 
    146 // Decode signed integer Exp-Golomb-coded syntax element
    147 int32 RbspParser::se ()
    148 {
    149     const uint32 x = ue ();
    150     if (!x) return 0;
    151     else if (x & 1) return static_cast<int32> ((x >> 1) + 1);
    152     else return - static_cast<int32> (x >> 1);
    153 }
    154 
    155 void H264_Utils::allocate_rbsp_buffer(uint32 inputBufferSize)
    156 {
    157     m_rbspBytes = (byte *) calloc(1,inputBufferSize);
    158     m_prv_nalu.nal_ref_idc = 0;
    159     m_prv_nalu.nalu_type = NALU_TYPE_UNSPECIFIED;
    160 }
    161 
    162 H264_Utils::H264_Utils(): m_height(0),
    163     m_width(0),
    164     m_rbspBytes(NULL),
    165     m_au_data (false)
    166 {
    167     initialize_frame_checking_environment();
    168 }
    169 
    170 H264_Utils::~H264_Utils()
    171 {
    172     /*  if(m_pbits)
    173         {
    174         delete(m_pbits);
    175         m_pbits = NULL;
    176         }
    177      */
    178     if (m_rbspBytes) {
    179         free(m_rbspBytes);
    180         m_rbspBytes = NULL;
    181     }
    182 }
    183 
    184 /***********************************************************************/
    185 /*
    186 FUNCTION:
    187 H264_Utils::initialize_frame_checking_environment
    188 
    189 DESCRIPTION:
    190 Extract RBSP data from a NAL
    191 
    192 INPUT/OUTPUT PARAMETERS:
    193 None
    194 
    195 RETURN VALUE:
    196 boolean
    197 
    198 SIDE EFFECTS:
    199 None.
    200  */
    201 /***********************************************************************/
    202 void H264_Utils::initialize_frame_checking_environment()
    203 {
    204     m_forceToStichNextNAL = false;
    205     m_au_data = false;
    206     m_prv_nalu.nal_ref_idc = 0;
    207     m_prv_nalu.nalu_type = NALU_TYPE_UNSPECIFIED;
    208 }
    209 
    210 /***********************************************************************/
    211 /*
    212 FUNCTION:
    213 H264_Utils::extract_rbsp
    214 
    215 DESCRIPTION:
    216 Extract RBSP data from a NAL
    217 
    218 INPUT/OUTPUT PARAMETERS:
    219 <In>
    220 buffer : buffer containing start code or nal length + NAL units
    221 buffer_length : the length of the NAL buffer
    222 start_code : If true, start code is detected,
    223 otherwise size nal length is detected
    224 size_of_nal_length_field: size of nal length field
    225 
    226 <Out>
    227 rbsp_bistream : extracted RBSP bistream
    228 rbsp_length : the length of the RBSP bitstream
    229 nal_unit : decoded NAL header information
    230 
    231 RETURN VALUE:
    232 boolean
    233 
    234 SIDE EFFECTS:
    235 None.
    236  */
    237 /***********************************************************************/
    238 
    239 boolean H264_Utils::extract_rbsp(OMX_IN   OMX_U8  *buffer,
    240         OMX_IN   OMX_U32 buffer_length,
    241         OMX_IN   OMX_U32 size_of_nal_length_field,
    242         OMX_OUT  OMX_U8  *rbsp_bistream,
    243         OMX_OUT  OMX_U32 *rbsp_length,
    244         OMX_OUT  NALU    *nal_unit)
    245 {
    246     byte coef1, coef2, coef3;
    247     uint32 pos = 0;
    248     uint32 nal_len = buffer_length;
    249     uint32 sizeofNalLengthField = 0;
    250     uint32 zero_count;
    251     boolean eRet = true;
    252     boolean start_code = (size_of_nal_length_field==0)?true:false;
    253 
    254     if (start_code) {
    255         // Search start_code_prefix_one_3bytes (0x000001)
    256         coef2 = buffer[pos++];
    257         coef3 = buffer[pos++];
    258         do {
    259             if (pos >= buffer_length) {
    260                 ALOGE("ERROR: In %s() - line %d", __func__, __LINE__);
    261                 return false;
    262             }
    263 
    264             coef1 = coef2;
    265             coef2 = coef3;
    266             coef3 = buffer[pos++];
    267         } while (coef1 || coef2 || coef3 != 1);
    268     } else if (size_of_nal_length_field) {
    269         /* This is the case to play multiple NAL units inside each access unit*/
    270         /* Extract the NAL length depending on sizeOfNALength field */
    271         sizeofNalLengthField = size_of_nal_length_field;
    272         nal_len = 0;
    273         while (size_of_nal_length_field--) {
    274             nal_len |= buffer[pos++]<<(size_of_nal_length_field<<3);
    275         }
    276         if (nal_len >= buffer_length) {
    277             ALOGE("ERROR: In %s() - line %d", __func__, __LINE__);
    278             return false;
    279         }
    280     }
    281 
    282     if (nal_len > buffer_length) {
    283         ALOGE("ERROR: In %s() - line %d", __func__, __LINE__);
    284         return false;
    285     }
    286     if (pos + 1 > (nal_len + sizeofNalLengthField)) {
    287         ALOGE("ERROR: In %s() - line %d", __func__, __LINE__);
    288         return false;
    289     }
    290     if ((nal_unit->forbidden_zero_bit = (buffer[pos] & 0x80)) != 0) {
    291         ALOGE("ERROR: In %s() - line %d", __func__, __LINE__);
    292     }
    293     nal_unit->nal_ref_idc   = (buffer[pos] & 0x60) >> 5;
    294     nal_unit->nalu_type = buffer[pos++] & 0x1f;
    295     ALOGV("@#@# Pos = %x NalType = %x buflen = %d",
    296             pos-1, nal_unit->nalu_type, buffer_length);
    297     *rbsp_length = 0;
    298 
    299 
    300     if ( nal_unit->nalu_type == NALU_TYPE_EOSEQ ||
    301             nal_unit->nalu_type == NALU_TYPE_EOSTREAM)
    302         return (nal_len + sizeofNalLengthField);
    303 
    304     zero_count = 0;
    305     while (pos < (nal_len+sizeofNalLengthField)) {  //similar to for in p-42
    306         if ( zero_count == 2 ) {
    307             if ( buffer[pos] == 0x03 ) {
    308                 pos ++;
    309                 zero_count = 0;
    310                 continue;
    311             }
    312             if ( buffer[pos] <= 0x01 ) {
    313                 if ( start_code ) {
    314                     *rbsp_length -= 2;
    315                     pos -= 2;
    316                     return pos;
    317                 }
    318             }
    319             zero_count = 0;
    320         }
    321         zero_count ++;
    322         if ( buffer[pos] != 0 )
    323             zero_count = 0;
    324 
    325         rbsp_bistream[(*rbsp_length)++] = buffer[pos++];
    326     }
    327 
    328     return eRet;
    329 }
    330 
    331 /*===========================================================================
    332 FUNCTION:
    333 H264_Utils::iSNewFrame
    334 
    335 DESCRIPTION:
    336 Returns true if NAL parsing successfull otherwise false.
    337 
    338 INPUT/OUTPUT PARAMETERS:
    339 <In>
    340 buffer : buffer containing start code or nal length + NAL units
    341 buffer_length : the length of the NAL buffer
    342 start_code : If true, start code is detected,
    343 otherwise size nal length is detected
    344 size_of_nal_length_field: size of nal length field
    345 <out>
    346 isNewFrame: true if the NAL belongs to a differenet frame
    347 false if the NAL belongs to a current frame
    348 
    349 RETURN VALUE:
    350 boolean  true, if nal parsing is successful
    351 false, if the nal parsing has errors
    352 
    353 SIDE EFFECTS:
    354 None.
    355 ===========================================================================*/
    356 bool H264_Utils::isNewFrame(OMX_BUFFERHEADERTYPE *p_buf_hdr,
    357         OMX_IN OMX_U32 size_of_nal_length_field,
    358         OMX_OUT OMX_BOOL &isNewFrame)
    359 {
    360     NALU nal_unit;
    361     uint16 first_mb_in_slice = 0;
    362     OMX_IN OMX_U32 numBytesInRBSP = 0;
    363     OMX_IN OMX_U8 *buffer = p_buf_hdr->pBuffer;
    364     OMX_IN OMX_U32 buffer_length = p_buf_hdr->nFilledLen;
    365     bool eRet = true;
    366 
    367     ALOGV("isNewFrame: buffer %p buffer_length %d "
    368             "size_of_nal_length_field %d", buffer, buffer_length,
    369             size_of_nal_length_field);
    370 
    371     if ( false == extract_rbsp(buffer, buffer_length, size_of_nal_length_field,
    372                 m_rbspBytes, &numBytesInRBSP, &nal_unit) ) {
    373         ALOGE("ERROR: In %s() - extract_rbsp() failed", __func__);
    374         isNewFrame = OMX_FALSE;
    375         eRet = false;
    376     } else {
    377         nalu_type = nal_unit.nalu_type;
    378         switch (nal_unit.nalu_type) {
    379             case NALU_TYPE_IDR:
    380             case NALU_TYPE_NON_IDR: {
    381                             ALOGV("AU Boundary with NAL type %d ",nal_unit.nalu_type);
    382                             if (m_forceToStichNextNAL) {
    383                                 isNewFrame = OMX_FALSE;
    384                             } else {
    385                                 RbspParser rbsp_parser(m_rbspBytes, (m_rbspBytes+numBytesInRBSP));
    386                                 first_mb_in_slice = rbsp_parser.ue();
    387 
    388                                 if ((!first_mb_in_slice) || /*(slice.prv_frame_num != slice.frame_num ) ||*/
    389                                         ( (m_prv_nalu.nal_ref_idc != nal_unit.nal_ref_idc) && ( nal_unit.nal_ref_idc * m_prv_nalu.nal_ref_idc == 0 ) ) ||
    390                                         /*( ((m_prv_nalu.nalu_type == NALU_TYPE_IDR) && (nal_unit.nalu_type == NALU_TYPE_IDR)) && (slice.idr_pic_id != slice.prv_idr_pic_id) ) || */
    391                                         ( (m_prv_nalu.nalu_type != nal_unit.nalu_type ) && ((m_prv_nalu.nalu_type == NALU_TYPE_IDR) || (nal_unit.nalu_type == NALU_TYPE_IDR)) ) ) {
    392                                     //ALOGV("Found a New Frame due to NALU_TYPE_IDR/NALU_TYPE_NON_IDR");
    393                                     isNewFrame = OMX_TRUE;
    394                                 } else {
    395                                     isNewFrame = OMX_FALSE;
    396                                 }
    397                             }
    398                             m_au_data = true;
    399                             m_forceToStichNextNAL = false;
    400                             break;
    401                         }
    402             case NALU_TYPE_SPS:
    403             case NALU_TYPE_PPS:
    404             case NALU_TYPE_SEI: {
    405                             ALOGV("Non-AU boundary with NAL type %d", nal_unit.nalu_type);
    406                             if (m_au_data) {
    407                                 isNewFrame = OMX_TRUE;
    408                                 m_au_data = false;
    409                             } else {
    410                                 isNewFrame =  OMX_FALSE;
    411                             }
    412 
    413                             m_forceToStichNextNAL = true;
    414                             break;
    415                         }
    416             case NALU_TYPE_ACCESS_DELIM:
    417             case NALU_TYPE_UNSPECIFIED:
    418             case NALU_TYPE_EOSEQ:
    419             case NALU_TYPE_EOSTREAM:
    420             default: {
    421                      isNewFrame =  OMX_FALSE;
    422                      // Do not update m_forceToStichNextNAL
    423                      break;
    424                  }
    425         } // end of switch
    426     } // end of if
    427     m_prv_nalu = nal_unit;
    428     ALOGV("get_h264_nal_type - newFrame value %d",isNewFrame);
    429     return eRet;
    430 }
    431 
    432 void perf_metrics::start()
    433 {
    434     if (!active) {
    435         start_time = get_act_time();
    436         active = true;
    437     }
    438 }
    439 
    440 void perf_metrics::stop()
    441 {
    442     OMX_U64 stop_time = get_act_time();
    443     if (active) {
    444         proc_time += (stop_time - start_time);
    445         active = false;
    446     }
    447 }
    448 
    449 void perf_metrics::end(OMX_U32 units_cntr)
    450 {
    451     stop();
    452     ALOGV("--> Processing time : [%.2f] Sec", (float)proc_time / 1e6);
    453     if (units_cntr) {
    454         ALOGV("--> Avrg proc time  : [%.2f] mSec", proc_time / (float)(units_cntr * 1e3));
    455     }
    456 }
    457 
    458 void perf_metrics::reset()
    459 {
    460     start_time = 0;
    461     proc_time = 0;
    462     active = false;
    463 }
    464 
    465 OMX_U64 perf_metrics::get_act_time()
    466 {
    467     struct timeval act_time = {0, 0};
    468     gettimeofday(&act_time, NULL);
    469     return (act_time.tv_usec + act_time.tv_sec * 1e6);
    470 }
    471 
    472 OMX_U64 perf_metrics::processing_time_us()
    473 {
    474     return proc_time;
    475 }
    476 
    477 h264_stream_parser::h264_stream_parser()
    478 {
    479     reset();
    480 #ifdef PANSCAN_HDLR
    481     panscan_hdl = new panscan_handler();
    482     if (!panscan_hdl) {
    483         ALOGE("ERROR: Panscan hdl was not allocated!");
    484     } else if (!panscan_hdl->initialize(10)) {
    485         ALOGE("ERROR: Allocating memory for panscan!");
    486         delete panscan_hdl;
    487         panscan_hdl = NULL;
    488     }
    489 #else
    490     memset(&panscan_param, 0, sizeof(panscan_param));
    491     panscan_param.rect_id = NO_PAN_SCAN_BIT;
    492 #endif
    493 }
    494 
    495 h264_stream_parser::~h264_stream_parser()
    496 {
    497 #ifdef PANSCAN_HDLR
    498     if (panscan_hdl) {
    499         delete panscan_hdl;
    500         panscan_hdl = NULL;
    501     }
    502 #endif
    503 }
    504 
    505 void h264_stream_parser::reset()
    506 {
    507     curr_32_bit = 0;
    508     bits_read = 0;
    509     zero_cntr = 0;
    510     emulation_code_skip_cntr = 0;
    511     emulation_sc_enabled = true;
    512     bitstream = NULL;
    513     bitstream_bytes = 0;
    514     memset(&vui_param, 0, sizeof(vui_param));
    515     vui_param.fixed_fps_prev_ts = LLONG_MAX;
    516     memset(&sei_buf_period, 0, sizeof(sei_buf_period));
    517     memset(&sei_pic_timing, 0, sizeof(sei_pic_timing));
    518     memset(&frame_packing_arrangement,0,sizeof(frame_packing_arrangement));
    519     frame_packing_arrangement.cancel_flag = 1;
    520     mbaff_flag = 0;
    521 }
    522 
    523 void h264_stream_parser::init_bitstream(OMX_U8* data, OMX_U32 size)
    524 {
    525     bitstream = data;
    526     bitstream_bytes = size;
    527     curr_32_bit = 0;
    528     bits_read = 0;
    529     zero_cntr = 0;
    530     emulation_code_skip_cntr = 0;
    531 }
    532 
    533 void h264_stream_parser::parse_vui(bool vui_in_extradata)
    534 {
    535     OMX_U32 value = 0;
    536     ALOGV("parse_vui: IN");
    537     if (vui_in_extradata)
    538         while (!extract_bits(1) && more_bits()); // Discard VUI enable flag
    539     if (!more_bits())
    540         return;
    541 
    542     vui_param.aspect_ratio_info_present_flag = extract_bits(1); //aspect_ratio_info_present_flag
    543     if (vui_param.aspect_ratio_info_present_flag) {
    544         ALOGV("Aspect Ratio Info present!");
    545         aspect_ratio_info();
    546     }
    547 
    548     if (extract_bits(1)) //overscan_info_present_flag
    549         extract_bits(1); //overscan_appropriate_flag
    550     if (extract_bits(1)) { //video_signal_type_present_flag
    551         extract_bits(3); //video_format
    552         extract_bits(1); //video_full_range_flag
    553         if (extract_bits(1)) { //colour_description_present_flag
    554             extract_bits(8); //colour_primaries
    555             extract_bits(8); //transfer_characteristics
    556             extract_bits(8); //matrix_coefficients
    557         }
    558     }
    559     if (extract_bits(1)) { //chroma_location_info_present_flag
    560         uev(); //chroma_sample_loc_type_top_field
    561         uev(); //chroma_sample_loc_type_bottom_field
    562     }
    563     vui_param.timing_info_present_flag = extract_bits(1);
    564     if (vui_param.timing_info_present_flag) {
    565         vui_param.num_units_in_tick = extract_bits(32);
    566         vui_param.time_scale = extract_bits(32);
    567         vui_param.fixed_frame_rate_flag = extract_bits(1);
    568         ALOGV("Timing info present in VUI!");
    569         ALOGV("  num units in tick  : %u", vui_param.num_units_in_tick);
    570         ALOGV("  time scale         : %u", vui_param.time_scale);
    571         ALOGV("  fixed frame rate   : %u", vui_param.fixed_frame_rate_flag);
    572     }
    573     vui_param.nal_hrd_parameters_present_flag = extract_bits(1);
    574     if (vui_param.nal_hrd_parameters_present_flag) {
    575         ALOGV("nal hrd params present!");
    576         hrd_parameters(&vui_param.nal_hrd_parameters);
    577     }
    578     vui_param.vcl_hrd_parameters_present_flag = extract_bits(1);
    579     if (vui_param.vcl_hrd_parameters_present_flag) {
    580         ALOGV("vcl hrd params present!");
    581         hrd_parameters(&vui_param.vcl_hrd_parameters);
    582     }
    583     if (vui_param.nal_hrd_parameters_present_flag ||
    584             vui_param.vcl_hrd_parameters_present_flag)
    585         vui_param.low_delay_hrd_flag = extract_bits(1);
    586     vui_param.pic_struct_present_flag = extract_bits(1);
    587     ALOGV("pic_struct_present_flag : %u", vui_param.pic_struct_present_flag);
    588     if (extract_bits(1)) { //bitstream_restriction_flag
    589         extract_bits(1); //motion_vectors_over_pic_boundaries_flag
    590         uev(); //max_bytes_per_pic_denom
    591         uev(); //max_bits_per_mb_denom
    592         uev(); //log2_max_mv_length_vertical
    593         uev(); //log2_max_mv_length_horizontal
    594         uev(); //num_reorder_frames
    595         uev(); //max_dec_frame_buffering
    596     }
    597     ALOGV("parse_vui: OUT");
    598 }
    599 
    600 void h264_stream_parser::aspect_ratio_info()
    601 {
    602     ALOGV("aspect_ratio_info: IN");
    603     OMX_U32  aspect_ratio_idc = 0;
    604     OMX_U32  aspect_ratio_x = 0;
    605     OMX_U32  aspect_ratio_y = 0;
    606     aspect_ratio_idc = extract_bits(8); //aspect_ratio_idc
    607     switch (aspect_ratio_idc) {
    608         case 1:
    609             aspect_ratio_x = 1;
    610             aspect_ratio_y = 1;
    611             break;
    612         case 2:
    613             aspect_ratio_x = 12;
    614             aspect_ratio_y = 11;
    615             break;
    616         case 3:
    617             aspect_ratio_x = 10;
    618             aspect_ratio_y = 11;
    619             break;
    620         case 4:
    621             aspect_ratio_x = 16;
    622             aspect_ratio_y = 11;
    623             break;
    624         case 5:
    625             aspect_ratio_x = 40;
    626             aspect_ratio_y = 33;
    627             break;
    628         case 6:
    629             aspect_ratio_x = 24;
    630             aspect_ratio_y = 11;
    631             break;
    632         case 7:
    633             aspect_ratio_x = 20;
    634             aspect_ratio_y = 11;
    635             break;
    636         case 8:
    637             aspect_ratio_x = 32;
    638             aspect_ratio_y = 11;
    639             break;
    640         case 9:
    641             aspect_ratio_x = 80;
    642             aspect_ratio_y = 33;
    643             break;
    644         case 10:
    645             aspect_ratio_x = 18;
    646             aspect_ratio_y = 11;
    647             break;
    648         case 11:
    649             aspect_ratio_x = 15;
    650             aspect_ratio_y = 11;
    651             break;
    652         case 12:
    653             aspect_ratio_x = 64;
    654             aspect_ratio_y = 33;
    655             break;
    656         case 13:
    657             aspect_ratio_x = 160;
    658             aspect_ratio_y = 99;
    659             break;
    660         case 14:
    661             aspect_ratio_x = 4;
    662             aspect_ratio_y = 3;
    663             break;
    664         case 15:
    665             aspect_ratio_x = 3;
    666             aspect_ratio_y = 2;
    667             break;
    668         case 16:
    669             aspect_ratio_x = 2;
    670             aspect_ratio_y = 1;
    671             break;
    672         case 255:
    673             aspect_ratio_x = extract_bits(16); //sar_width
    674             aspect_ratio_y = extract_bits(16); //sar_height
    675             break;
    676         default:
    677             ALOGV("-->aspect_ratio_idc: Reserved Value ");
    678             break;
    679     }
    680     ALOGV("-->aspect_ratio_idc        : %u", aspect_ratio_idc);
    681     ALOGV("-->aspect_ratio_x          : %u", aspect_ratio_x);
    682     ALOGV("-->aspect_ratio_y          : %u", aspect_ratio_y);
    683     vui_param.aspect_ratio_info.aspect_ratio_idc = aspect_ratio_idc;
    684     vui_param.aspect_ratio_info.aspect_ratio_x = aspect_ratio_x;
    685     vui_param.aspect_ratio_info.aspect_ratio_y = aspect_ratio_y;
    686     ALOGV("aspect_ratio_info: OUT");
    687 }
    688 
    689 void h264_stream_parser::hrd_parameters(h264_hrd_param *hrd_param)
    690 {
    691     OMX_U32 idx;
    692     ALOGV("hrd_parameters: IN");
    693     hrd_param->cpb_cnt = uev() + 1;
    694     hrd_param->bit_rate_scale = extract_bits(4);
    695     hrd_param->cpb_size_scale = extract_bits(4);
    696     ALOGV("-->cpb_cnt        : %u", hrd_param->cpb_cnt);
    697     ALOGV("-->bit_rate_scale : %u", hrd_param->bit_rate_scale);
    698     ALOGV("-->cpb_size_scale : %u", hrd_param->cpb_size_scale);
    699     if (hrd_param->cpb_cnt > MAX_CPB_COUNT) {
    700         ALOGV("ERROR: Invalid hrd_param->cpb_cnt [%u]!", hrd_param->cpb_cnt);
    701         return;
    702     }
    703     for (idx = 0; idx < hrd_param->cpb_cnt && more_bits(); idx++) {
    704         hrd_param->bit_rate_value[idx] = uev() + 1;
    705         hrd_param->cpb_size_value[idx] = uev() + 1;
    706         hrd_param->cbr_flag[idx] = extract_bits(1);
    707         ALOGV("-->bit_rate_value [%d] : %u", idx, hrd_param->bit_rate_value[idx]);
    708         ALOGV("-->cpb_size_value [%d] : %u", idx, hrd_param->cpb_size_value[idx]);
    709         ALOGV("-->cbr_flag       [%d] : %u", idx, hrd_param->cbr_flag[idx]);
    710     }
    711     hrd_param->initial_cpb_removal_delay_length = extract_bits(5) + 1;
    712     hrd_param->cpb_removal_delay_length = extract_bits(5) + 1;
    713     hrd_param->dpb_output_delay_length = extract_bits(5) + 1;
    714     hrd_param->time_offset_length = extract_bits(5);
    715     ALOGV("-->initial_cpb_removal_delay_length : %u", hrd_param->initial_cpb_removal_delay_length);
    716     ALOGV("-->cpb_removal_delay_length         : %u", hrd_param->cpb_removal_delay_length);
    717     ALOGV("-->dpb_output_delay_length          : %u", hrd_param->dpb_output_delay_length);
    718     ALOGV("-->time_offset_length               : %u", hrd_param->time_offset_length);
    719     ALOGV("hrd_parameters: OUT");
    720 }
    721 
    722 void h264_stream_parser::parse_sei()
    723 {
    724     OMX_U32 value = 0, processed_bytes = 0;
    725     OMX_U8 *sei_msg_start = bitstream;
    726     OMX_U32 sei_unit_size = bitstream_bytes;
    727     ALOGV("@@parse_sei: IN sei_unit_size(%u)", sei_unit_size);
    728     while ((processed_bytes + 2) < sei_unit_size && more_bits()) {
    729         init_bitstream(sei_msg_start + processed_bytes, sei_unit_size - processed_bytes);
    730         ALOGV("-->NALU_TYPE_SEI");
    731         OMX_U32 payload_type = 0, payload_size = 0, aux = 0;
    732         do {
    733             value = extract_bits(8);
    734             payload_type += value;
    735             processed_bytes++;
    736         } while (value == 0xFF);
    737         ALOGV("-->payload_type   : %u", payload_type);
    738         do {
    739             value = extract_bits(8);
    740             payload_size += value;
    741             processed_bytes++;
    742         } while (value == 0xFF);
    743         ALOGV("-->payload_size   : %u", payload_size);
    744         if (payload_size > 0) {
    745             switch (payload_type) {
    746                 case BUFFERING_PERIOD:
    747                     sei_buffering_period();
    748                     break;
    749                 case PIC_TIMING:
    750                     sei_picture_timing();
    751                     break;
    752                 case PAN_SCAN_RECT:
    753                     sei_pan_scan();
    754                     break;
    755                 case SEI_PAYLOAD_FRAME_PACKING_ARRANGEMENT:
    756                     parse_frame_pack();
    757                     break;
    758                 default:
    759                     ALOGV("-->SEI payload type [%u] not implemented! size[%u]", payload_type, payload_size);
    760             }
    761         }
    762         processed_bytes += (payload_size + emulation_code_skip_cntr);
    763         ALOGV("-->SEI processed_bytes[%u]", processed_bytes);
    764     }
    765     ALOGV("@@parse_sei: OUT");
    766 }
    767 
    768 void h264_stream_parser::sei_buffering_period()
    769 {
    770     OMX_U32 idx;
    771     OMX_U32 value = 0;
    772     h264_hrd_param *hrd_param = NULL;
    773     ALOGV("@@sei_buffering_period: IN");
    774     value = uev(); // seq_parameter_set_id
    775     ALOGV("-->seq_parameter_set_id : %u", value);
    776     if (value > 31) {
    777         ALOGV("ERROR: Invalid seq_parameter_set_id [%u]!", value);
    778         return;
    779     }
    780     sei_buf_period.is_valid = false;
    781     if (vui_param.nal_hrd_parameters_present_flag) {
    782         hrd_param = &vui_param.nal_hrd_parameters;
    783         if (hrd_param->cpb_cnt > MAX_CPB_COUNT) {
    784             ALOGV("ERROR: Invalid hrd_param->cpb_cnt [%u]!", hrd_param->cpb_cnt);
    785             return;
    786         }
    787         for (idx = 0; idx < hrd_param->cpb_cnt ; idx++) {
    788             sei_buf_period.is_valid = true;
    789             sei_buf_period.initial_cpb_removal_delay[idx] = extract_bits(hrd_param->initial_cpb_removal_delay_length);
    790             sei_buf_period.initial_cpb_removal_delay_offset[idx] = extract_bits(hrd_param->initial_cpb_removal_delay_length);
    791             ALOGV("-->initial_cpb_removal_delay        : %u", sei_buf_period.initial_cpb_removal_delay[idx]);
    792             ALOGV("-->initial_cpb_removal_delay_offset : %u", sei_buf_period.initial_cpb_removal_delay_offset[idx]);
    793         }
    794     }
    795     if (vui_param.vcl_hrd_parameters_present_flag) {
    796         hrd_param = &vui_param.vcl_hrd_parameters;
    797         if (hrd_param->cpb_cnt > MAX_CPB_COUNT) {
    798             ALOGV("ERROR: Invalid hrd_param->cpb_cnt [%u]!", hrd_param->cpb_cnt);
    799             return;
    800         }
    801         for (idx = 0; idx < hrd_param->cpb_cnt ; idx++) {
    802             sei_buf_period.is_valid = true;
    803             sei_buf_period.initial_cpb_removal_delay[idx] = extract_bits(hrd_param->initial_cpb_removal_delay_length);
    804             sei_buf_period.initial_cpb_removal_delay_offset[idx] = extract_bits(hrd_param->initial_cpb_removal_delay_length);
    805             ALOGV("-->initial_cpb_removal_delay        : %u", sei_buf_period.initial_cpb_removal_delay[idx]);
    806             ALOGV("-->initial_cpb_removal_delay_offset : %u", sei_buf_period.initial_cpb_removal_delay_offset[idx]);
    807         }
    808     }
    809     sei_buf_period.au_cntr = 0;
    810     ALOGV("@@sei_buffering_period: OUT");
    811 }
    812 
    813 void h264_stream_parser::sei_picture_timing()
    814 {
    815     ALOGV("@@sei_picture_timing: IN");
    816     OMX_U32 time_offset_len = 0, cpb_removal_len = 24, dpb_output_len  = 24;
    817     OMX_U8 cbr_flag = 0;
    818     sei_pic_timing.is_valid = true;
    819     if (vui_param.nal_hrd_parameters_present_flag) {
    820         cpb_removal_len = vui_param.nal_hrd_parameters.cpb_removal_delay_length;
    821         dpb_output_len = vui_param.nal_hrd_parameters.dpb_output_delay_length;
    822         time_offset_len = vui_param.nal_hrd_parameters.time_offset_length;
    823         cbr_flag = vui_param.nal_hrd_parameters.cbr_flag[0];
    824     } else if (vui_param.vcl_hrd_parameters_present_flag) {
    825         cpb_removal_len = vui_param.vcl_hrd_parameters.cpb_removal_delay_length;
    826         dpb_output_len = vui_param.vcl_hrd_parameters.dpb_output_delay_length;
    827         time_offset_len = vui_param.vcl_hrd_parameters.time_offset_length;
    828         cbr_flag = vui_param.vcl_hrd_parameters.cbr_flag[0];
    829     }
    830     sei_pic_timing.cpb_removal_delay = extract_bits(cpb_removal_len);
    831     sei_pic_timing.dpb_output_delay = extract_bits(dpb_output_len);
    832     ALOGV("-->cpb_removal_len : %u", cpb_removal_len);
    833     ALOGV("-->dpb_output_len  : %u", dpb_output_len);
    834     ALOGV("-->cpb_removal_delay : %u", sei_pic_timing.cpb_removal_delay);
    835     ALOGV("-->dpb_output_delay  : %u", sei_pic_timing.dpb_output_delay);
    836     if (vui_param.pic_struct_present_flag) {
    837         sei_pic_timing.pic_struct = extract_bits(4);
    838         sei_pic_timing.num_clock_ts = 0;
    839         switch (sei_pic_timing.pic_struct) {
    840             case 0:
    841             case 1:
    842             case 2:
    843                 sei_pic_timing.num_clock_ts = 1;
    844                 break;
    845             case 3:
    846             case 4:
    847             case 7:
    848                 sei_pic_timing.num_clock_ts = 2;
    849                 break;
    850             case 5:
    851             case 6:
    852             case 8:
    853                 sei_pic_timing.num_clock_ts = 3;
    854                 break;
    855             default:
    856                 ALOGE("sei_picture_timing: pic_struct invalid!");
    857         }
    858         ALOGV("-->num_clock_ts      : %u", sei_pic_timing.num_clock_ts);
    859         for (OMX_U32 i = 0; i < sei_pic_timing.num_clock_ts && more_bits(); i++) {
    860             sei_pic_timing.clock_ts_flag = extract_bits(1);
    861             if (sei_pic_timing.clock_ts_flag) {
    862                 ALOGV("-->clock_timestamp present!");
    863                 sei_pic_timing.ct_type = extract_bits(2);
    864                 sei_pic_timing.nuit_field_based_flag = extract_bits(1);
    865                 sei_pic_timing.counting_type = extract_bits(5);
    866                 sei_pic_timing.full_timestamp_flag = extract_bits(1);
    867                 sei_pic_timing.discontinuity_flag = extract_bits(1);
    868                 sei_pic_timing.cnt_dropped_flag = extract_bits(1);
    869                 sei_pic_timing.n_frames = extract_bits(8);
    870                 ALOGV("-->f_timestamp_flg   : %u", sei_pic_timing.full_timestamp_flag);
    871                 ALOGV("-->n_frames          : %u", sei_pic_timing.n_frames);
    872                 sei_pic_timing.seconds_value = 0;
    873                 sei_pic_timing.minutes_value = 0;
    874                 sei_pic_timing.hours_value = 0;
    875                 if (sei_pic_timing.full_timestamp_flag) {
    876                     sei_pic_timing.seconds_value = extract_bits(6);
    877                     sei_pic_timing.minutes_value = extract_bits(6);
    878                     sei_pic_timing.hours_value = extract_bits(5);
    879                 } else if (extract_bits(1)) {
    880                     ALOGV("-->seconds_flag enabled!");
    881                     sei_pic_timing.seconds_value = extract_bits(6);
    882                     if (extract_bits(1)) {
    883                         ALOGV("-->minutes_flag enabled!");
    884                         sei_pic_timing.minutes_value = extract_bits(6);
    885                         if (extract_bits(1)) {
    886                             ALOGV("-->hours_flag enabled!");
    887                             sei_pic_timing.hours_value = extract_bits(5);
    888                         }
    889                     }
    890                 }
    891                 sei_pic_timing.time_offset = 0;
    892                 if (time_offset_len > 0)
    893                     sei_pic_timing.time_offset = iv(time_offset_len);
    894                 ALOGV("-->seconds_value     : %u", sei_pic_timing.seconds_value);
    895                 ALOGV("-->minutes_value     : %u", sei_pic_timing.minutes_value);
    896                 ALOGV("-->hours_value       : %u", sei_pic_timing.hours_value);
    897                 ALOGV("-->time_offset       : %d", sei_pic_timing.time_offset);
    898             }
    899         }
    900     }
    901     ALOGV("@@sei_picture_timing: OUT");
    902 }
    903 
    904 void h264_stream_parser::sei_pan_scan()
    905 {
    906 #ifdef _ANDROID_
    907     char property_value[PROPERTY_VALUE_MAX] = {0};
    908     OMX_S32 enable_panscan_log = 0;
    909     property_get("vidc.dec.debug.panframedata", property_value, "0");
    910     enable_panscan_log = atoi(property_value);
    911 #endif
    912 #ifdef PANSCAN_HDLR
    913     h264_pan_scan *pan_scan_param = panscan_hdl->get_free();
    914 #else
    915     h264_pan_scan *pan_scan_param = &panscan_param;
    916 #endif
    917 
    918     if (!pan_scan_param) {
    919         ALOGE("sei_pan_scan: ERROR: Invalid pointer!");
    920         return;
    921     }
    922 
    923     pan_scan_param->rect_id = uev();
    924     if (pan_scan_param->rect_id > 0xFF) {
    925         ALOGE("sei_pan_scan: ERROR: Invalid rect_id[%u]!", (unsigned int)pan_scan_param->rect_id);
    926         pan_scan_param->rect_id = NO_PAN_SCAN_BIT;
    927         return;
    928     }
    929 
    930     pan_scan_param->rect_cancel_flag = extract_bits(1);
    931 
    932     if (pan_scan_param->rect_cancel_flag)
    933         pan_scan_param->rect_id = NO_PAN_SCAN_BIT;
    934     else {
    935         pan_scan_param->cnt = uev() + 1;
    936         if (pan_scan_param->cnt > MAX_PAN_SCAN_RECT) {
    937             ALOGE("sei_pan_scan: ERROR: Invalid num of rect [%u]!", (unsigned int)pan_scan_param->cnt);
    938             pan_scan_param->rect_id = NO_PAN_SCAN_BIT;
    939             return;
    940         }
    941 
    942         for (OMX_U32 i = 0; i < pan_scan_param->cnt; i++) {
    943             pan_scan_param->rect_left_offset[i] = sev();
    944             pan_scan_param->rect_right_offset[i] = sev();
    945             pan_scan_param->rect_top_offset[i] = sev();
    946             pan_scan_param->rect_bottom_offset[i] = sev();
    947 
    948         }
    949         pan_scan_param->rect_repetition_period = uev();
    950 #ifdef PANSCAN_HDLR
    951         if (pan_scan_param->rect_repetition_period > 1)
    952             // Repetition period is decreased by 2 each time panscan data is used
    953             pan_scan_param->rect_repetition_period *= 2;
    954 #endif
    955 #ifdef _ANDROID_
    956         if (enable_panscan_log) {
    957             print_pan_data(pan_scan_param);
    958         }
    959 #endif
    960     }
    961 }
    962 
    963 void h264_stream_parser::print_pan_data(h264_pan_scan *pan_scan_param)
    964 {
    965     ALOGE("@@print_pan_data: IN");
    966 
    967     ALOGE("-->rect_id            : %u", (unsigned int)pan_scan_param->rect_id);
    968     ALOGE("-->rect_cancel_flag   : %u", pan_scan_param->rect_cancel_flag);
    969 
    970     ALOGE("-->cnt                : %u", (unsigned int)pan_scan_param->cnt);
    971 
    972     for (OMX_U32 i = 0; i < pan_scan_param->cnt; i++) {
    973         ALOGE("-->rect_left_offset   : %d", (int)pan_scan_param->rect_left_offset[i]);
    974         ALOGE("-->rect_right_offset  : %d", (int)pan_scan_param->rect_right_offset[i]);
    975         ALOGE("-->rect_top_offset    : %d", (int)pan_scan_param->rect_top_offset[i]);
    976         ALOGE("-->rect_bottom_offset : %d", (int)pan_scan_param->rect_bottom_offset[i]);
    977     }
    978     ALOGE("-->repetition_period  : %u", (unsigned int)pan_scan_param->rect_repetition_period);
    979 
    980     ALOGE("@@print_pan_data: OUT");
    981 }
    982 
    983 void h264_stream_parser::parse_sps()
    984 {
    985     OMX_U32 value = 0, scaling_matrix_limit;
    986     ALOGV("@@parse_sps: IN");
    987     value = extract_bits(8); //profile_idc
    988     profile = value;
    989     extract_bits(8); //constraint flags and reserved bits
    990     extract_bits(8); //level_idc
    991     uev(); //sps id
    992     if (value == 100 || value == 110 || value == 122 || value == 244 ||
    993             value ==  44 || value ==  83 || value ==  86 || value == 118) {
    994         if (uev() == 3) { //chroma_format_idc
    995             extract_bits(1); //separate_colour_plane_flag
    996             scaling_matrix_limit = 12;
    997         } else
    998             scaling_matrix_limit = 12;
    999         uev(); //bit_depth_luma_minus8
   1000         uev(); //bit_depth_chroma_minus8
   1001         extract_bits(1); //qpprime_y_zero_transform_bypass_flag
   1002         if (extract_bits(1)) { //seq_scaling_matrix_present_flag
   1003             for (unsigned int i = 0; i < scaling_matrix_limit && more_bits(); i++) {
   1004                 if (extract_bits(1)) { ////seq_scaling_list_present_flag[ i ]
   1005                     if (i < 6)
   1006                         scaling_list(16);
   1007                     else
   1008                         scaling_list(64);
   1009                 }
   1010             }
   1011         }
   1012     }
   1013     uev(); //log2_max_frame_num_minus4
   1014     value = uev(); //pic_order_cnt_type
   1015     if (value == 0)
   1016         uev(); //log2_max_pic_order_cnt_lsb_minus4
   1017     else if (value == 1) {
   1018         extract_bits(1); //delta_pic_order_always_zero_flag
   1019         sev(); //offset_for_non_ref_pic
   1020         sev(); //offset_for_top_to_bottom_field
   1021         value = uev(); // num_ref_frames_in_pic_order_cnt_cycle
   1022         for (unsigned int i = 0; i < value; i++)
   1023             sev(); //offset_for_ref_frame[ i ]
   1024     }
   1025     uev(); //max_num_ref_frames
   1026     extract_bits(1); //gaps_in_frame_num_value_allowed_flag
   1027     value = uev(); //pic_width_in_mbs_minus1
   1028     value = uev(); //pic_height_in_map_units_minus1
   1029     if (!extract_bits(1)) //frame_mbs_only_flag
   1030         mbaff_flag = extract_bits(1); //mb_adaptive_frame_field_flag
   1031     extract_bits(1); //direct_8x8_inference_flag
   1032     if (extract_bits(1)) { //frame_cropping_flag
   1033         uev(); //frame_crop_left_offset
   1034         uev(); //frame_crop_right_offset
   1035         uev(); //frame_crop_top_offset
   1036         uev(); //frame_crop_bottom_offset
   1037     }
   1038     if (extract_bits(1)) //vui_parameters_present_flag
   1039         parse_vui(false);
   1040     ALOGV("@@parse_sps: OUT");
   1041 }
   1042 
   1043 void h264_stream_parser::scaling_list(OMX_U32 size_of_scaling_list)
   1044 {
   1045     OMX_S32 last_scale = 8, next_scale = 8, delta_scale;
   1046     for (unsigned int j = 0; j < size_of_scaling_list; j++) {
   1047         if (next_scale != 0) {
   1048             delta_scale = sev();
   1049             next_scale = (last_scale + delta_scale + 256) % 256;
   1050         }
   1051         last_scale = (next_scale == 0)? last_scale : next_scale;
   1052     }
   1053 }
   1054 
   1055 OMX_U32 h264_stream_parser::extract_bits(OMX_U32 n)
   1056 {
   1057     OMX_U32 value = 0;
   1058     if (n > 32) {
   1059         ALOGE("ERROR: extract_bits limit to 32 bits!");
   1060         return value;
   1061     }
   1062     value = curr_32_bit >> (32 - n);
   1063     if (bits_read < n) {
   1064         n -= bits_read;
   1065         read_word();
   1066         value |= (curr_32_bit >> (32 - n));
   1067         if (bits_read < n) {
   1068             ALOGV("ERROR: extract_bits underflow!");
   1069             value >>= (n - bits_read);
   1070             n = bits_read;
   1071         }
   1072     }
   1073     bits_read -= n;
   1074     curr_32_bit <<= n;
   1075     return value;
   1076 }
   1077 
   1078 void h264_stream_parser::read_word()
   1079 {
   1080     curr_32_bit = 0;
   1081     bits_read = 0;
   1082     while (bitstream_bytes && bits_read < 32) {
   1083         if (*bitstream == EMULATION_PREVENTION_THREE_BYTE &&
   1084                 zero_cntr >= 2 && emulation_sc_enabled) {
   1085             ALOGV("EMULATION_PREVENTION_THREE_BYTE: Skip 0x03 byte aligned!");
   1086             emulation_code_skip_cntr++;
   1087         } else {
   1088             curr_32_bit <<= 8;
   1089             curr_32_bit |= *bitstream;
   1090             bits_read += 8;
   1091         }
   1092         if (*bitstream == 0)
   1093             zero_cntr++;
   1094         else
   1095             zero_cntr = 0;
   1096         bitstream++;
   1097         bitstream_bytes--;
   1098     }
   1099     curr_32_bit <<= (32 - bits_read);
   1100 }
   1101 
   1102 OMX_U32 h264_stream_parser::uev()
   1103 {
   1104     OMX_U32 lead_zero_bits = 0, code_num = 0;
   1105     while (!extract_bits(1) && more_bits())
   1106         lead_zero_bits++;
   1107     code_num = lead_zero_bits == 0 ? 0 :
   1108         (1 << lead_zero_bits) - 1 + extract_bits(lead_zero_bits);
   1109     return code_num;
   1110 }
   1111 
   1112 bool h264_stream_parser::more_bits()
   1113 {
   1114     return (bitstream_bytes > 0 || bits_read > 0);
   1115 }
   1116 
   1117 OMX_S32 h264_stream_parser::sev()
   1118 {
   1119     OMX_U32 code_num = uev();
   1120     OMX_S32 ret;
   1121     ret = (code_num + 1) >> 1;
   1122     return ((code_num & 1) ? ret : -ret);
   1123 }
   1124 
   1125 OMX_S32 h264_stream_parser::iv(OMX_U32 n_bits)
   1126 {
   1127     OMX_U32 code_num = extract_bits(n_bits);
   1128     OMX_S32 ret = (code_num >> (n_bits - 1))? (-1)*(~(code_num & ~(0x1 << (n_bits - 1))) + 1) : code_num;
   1129     return ret;
   1130 }
   1131 
   1132 OMX_U32 h264_stream_parser::get_nal_unit_type(OMX_U32 *nal_unit_type)
   1133 {
   1134     OMX_U32 value = 0, consumed_bytes = 3;
   1135     *nal_unit_type = NALU_TYPE_UNSPECIFIED;
   1136     ALOGV("-->get_nal_unit_type: IN");
   1137     value = extract_bits(24);
   1138     while (value != 0x00000001 && more_bits()) {
   1139         value <<= 8;
   1140         value |= extract_bits(8);
   1141         consumed_bytes++;
   1142     }
   1143     if (value != 0x00000001) {
   1144         ALOGE("ERROR in get_nal_unit_type: Start code not found!");
   1145     } else {
   1146         if (extract_bits(1)) { // forbidden_zero_bit
   1147             ALOGE("WARNING: forbidden_zero_bit should be zero!");
   1148         }
   1149         value = extract_bits(2);
   1150         ALOGV("-->nal_ref_idc    : %x", value);
   1151         *nal_unit_type = extract_bits(5);
   1152         ALOGV("-->nal_unit_type  : %x", *nal_unit_type);
   1153         consumed_bytes++;
   1154         if (consumed_bytes > 5) {
   1155             ALOGE("-->WARNING: Startcode was found after the first 4 bytes!");
   1156         }
   1157     }
   1158     ALOGV("-->get_nal_unit_type: OUT");
   1159     return consumed_bytes;
   1160 }
   1161 
   1162 OMX_U32 h264_stream_parser::get_profile()
   1163 {
   1164     return profile;
   1165 }
   1166 
   1167 OMX_S64 h264_stream_parser::calculate_buf_period_ts(OMX_S64 timestamp)
   1168 {
   1169     OMX_S64 clock_ts = timestamp;
   1170     ALOGV("calculate_ts(): IN");
   1171     if (sei_buf_period.au_cntr == 0)
   1172         clock_ts = sei_buf_period.reference_ts = timestamp;
   1173     else if (sei_pic_timing.is_valid && VALID_TS(sei_buf_period.reference_ts)) {
   1174         clock_ts = sei_buf_period.reference_ts + sei_pic_timing.cpb_removal_delay *
   1175             1e6 * vui_param.num_units_in_tick / vui_param.time_scale;
   1176     }
   1177     sei_buf_period.au_cntr++;
   1178     ALOGV("calculate_ts(): OUT");
   1179     return clock_ts;
   1180 }
   1181 
   1182 OMX_S64 h264_stream_parser::calculate_fixed_fps_ts(OMX_S64 timestamp, OMX_U32 DeltaTfiDivisor)
   1183 {
   1184     if (VALID_TS(timestamp))
   1185         vui_param.fixed_fps_prev_ts = timestamp;
   1186     else if (VALID_TS(vui_param.fixed_fps_prev_ts))
   1187         vui_param.fixed_fps_prev_ts += DeltaTfiDivisor * 1e6 *
   1188             vui_param.num_units_in_tick / vui_param.time_scale;
   1189     return vui_param.fixed_fps_prev_ts;
   1190 }
   1191 
   1192 void h264_stream_parser::parse_frame_pack()
   1193 {
   1194 #ifdef _ANDROID_
   1195     char property_value[PROPERTY_VALUE_MAX] = {0};
   1196     OMX_S32 enable_framepack_log = 0;
   1197 
   1198     property_get("vidc.dec.debug.panframedata", property_value, "0");
   1199     enable_framepack_log = atoi(property_value);
   1200 #endif
   1201     ALOGV("%s:%d parse_frame_pack", __func__, __LINE__);
   1202 
   1203     frame_packing_arrangement.id = uev();
   1204 
   1205     frame_packing_arrangement.cancel_flag = extract_bits(1);
   1206     if (!frame_packing_arrangement.cancel_flag) {
   1207         frame_packing_arrangement.type = extract_bits(7);
   1208         frame_packing_arrangement.quincunx_sampling_flag = extract_bits(1);
   1209         frame_packing_arrangement.content_interpretation_type = extract_bits(6);
   1210         frame_packing_arrangement.spatial_flipping_flag = extract_bits(1);
   1211         frame_packing_arrangement.frame0_flipped_flag = extract_bits(1);
   1212         frame_packing_arrangement.field_views_flag = extract_bits(1);
   1213         frame_packing_arrangement.current_frame_is_frame0_flag = extract_bits(1);
   1214         frame_packing_arrangement.frame0_self_contained_flag = extract_bits(1);
   1215         frame_packing_arrangement.frame1_self_contained_flag = extract_bits(1);
   1216 
   1217         if (!frame_packing_arrangement.quincunx_sampling_flag &&
   1218                 frame_packing_arrangement.type != 5) {
   1219             frame_packing_arrangement.frame0_grid_position_x = extract_bits(4);
   1220             frame_packing_arrangement.frame0_grid_position_y = extract_bits(4);
   1221             frame_packing_arrangement.frame1_grid_position_x = extract_bits(4);
   1222             frame_packing_arrangement.frame1_grid_position_y = extract_bits(4);
   1223         }
   1224         frame_packing_arrangement.reserved_byte = extract_bits(8);
   1225         frame_packing_arrangement.repetition_period = uev();
   1226     }
   1227     frame_packing_arrangement.extension_flag = extract_bits(1);
   1228 
   1229 #ifdef _ANDROID_
   1230     if (enable_framepack_log) {
   1231         print_frame_pack();
   1232     }
   1233 #endif
   1234 }
   1235 
   1236 void h264_stream_parser::print_frame_pack()
   1237 {
   1238     ALOGV("## frame_packing_arrangement.id = %u", frame_packing_arrangement.id);
   1239     ALOGV("## frame_packing_arrangement.cancel_flag = %u",
   1240             frame_packing_arrangement.cancel_flag);
   1241     if (!frame_packing_arrangement.cancel_flag) {
   1242         ALOGV("## frame_packing_arrangement.type = %u",
   1243                 frame_packing_arrangement.type);
   1244         ALOGV("## frame_packing_arrangement.quincunx_sampling_flag = %u",
   1245                 frame_packing_arrangement.quincunx_sampling_flag);
   1246         ALOGV("## frame_packing_arrangement.content_interpretation_type = %u",
   1247                 frame_packing_arrangement.content_interpretation_type);
   1248         ALOGV("## frame_packing_arrangement.spatial_flipping_flag = %u",
   1249                 frame_packing_arrangement.spatial_flipping_flag);
   1250         ALOGV("## frame_packing_arrangement.frame0_flipped_flag = %u",
   1251                 frame_packing_arrangement.frame0_flipped_flag);
   1252         ALOGV("## frame_packing_arrangement.field_views_flag = %u",
   1253                 frame_packing_arrangement.field_views_flag);
   1254         ALOGV("## frame_packing_arrangement.current_frame_is_frame0_flag = %u",
   1255                 frame_packing_arrangement.current_frame_is_frame0_flag);
   1256         ALOGV("## frame_packing_arrangement.frame0_self_contained_flag = %u",
   1257                 frame_packing_arrangement.frame0_self_contained_flag);
   1258         ALOGV("## frame_packing_arrangement.frame1_self_contained_flag = %u",
   1259                 frame_packing_arrangement.frame1_self_contained_flag);
   1260         ALOGV("## frame_packing_arrangement.reserved_byte = %u",
   1261                 frame_packing_arrangement.reserved_byte);
   1262         ALOGV("## frame_packing_arrangement.repetition_period = %u",
   1263                 frame_packing_arrangement.repetition_period);
   1264         ALOGV("## frame_packing_arrangement.extension_flag = %u",
   1265                 frame_packing_arrangement.extension_flag);
   1266     }
   1267 }
   1268 /* API'S EXPOSED TO OMX COMPONENT */
   1269 
   1270 void h264_stream_parser::get_frame_pack_data(
   1271         OMX_QCOM_FRAME_PACK_ARRANGEMENT *frame_pack)
   1272 {
   1273     ALOGV("%s:%d get frame data", __func__, __LINE__);
   1274     memcpy(&frame_pack->id,&frame_packing_arrangement.id,
   1275             FRAME_PACK_SIZE*sizeof(OMX_U32));
   1276     return;
   1277 }
   1278 
   1279 
   1280 bool h264_stream_parser::is_mbaff()
   1281 {
   1282     ALOGV("%s:%d MBAFF flag=%d", __func__, __LINE__,mbaff_flag);
   1283     return mbaff_flag;
   1284 }
   1285 
   1286 void h264_stream_parser::get_frame_rate(OMX_U32 *frame_rate)
   1287 {
   1288     if (vui_param.num_units_in_tick != 0)
   1289         *frame_rate = vui_param.time_scale / (2 * vui_param.num_units_in_tick);
   1290 }
   1291 
   1292 void h264_stream_parser::parse_nal(OMX_U8* data_ptr, OMX_U32 data_len, OMX_U32 nal_type, bool enable_emu_sc)
   1293 {
   1294     OMX_U32 nal_unit_type = NALU_TYPE_UNSPECIFIED, cons_bytes = 0;
   1295     ALOGV("parse_nal(): IN nal_type(%u)", nal_type);
   1296     if (!data_len)
   1297         return;
   1298     init_bitstream(data_ptr, data_len);
   1299     emulation_sc_enabled = enable_emu_sc;
   1300     if (nal_type != NALU_TYPE_VUI) {
   1301         cons_bytes = get_nal_unit_type(&nal_unit_type);
   1302         if (nal_type != nal_unit_type && nal_type != NALU_TYPE_UNSPECIFIED) {
   1303             ALOGV("Unexpected nal_type(%x) expected(%x)", nal_unit_type, nal_type);
   1304             return;
   1305         }
   1306     }
   1307     switch (nal_type) {
   1308         case NALU_TYPE_SPS:
   1309             if (more_bits())
   1310                 parse_sps();
   1311 #ifdef PANSCAN_HDLR
   1312             panscan_hdl->get_free();
   1313 #endif
   1314             break;
   1315         case NALU_TYPE_SEI:
   1316             init_bitstream(data_ptr + cons_bytes, data_len - cons_bytes);
   1317             parse_sei();
   1318             break;
   1319         case NALU_TYPE_VUI:
   1320             parse_vui(true);
   1321             break;
   1322         default:
   1323             ALOGV("nal_unit_type received : %u", nal_type);
   1324     }
   1325     ALOGV("parse_nal(): OUT");
   1326 }
   1327 
   1328 #ifdef PANSCAN_HDLR
   1329 void h264_stream_parser::update_panscan_data(OMX_S64 timestamp)
   1330 {
   1331     panscan_hdl->update_last(timestamp);
   1332 }
   1333 #endif
   1334 
   1335 void h264_stream_parser::fill_aspect_ratio_info(OMX_QCOM_ASPECT_RATIO *dest_aspect_ratio)
   1336 {
   1337     if (dest_aspect_ratio && vui_param.aspect_ratio_info_present_flag) {
   1338         dest_aspect_ratio->aspectRatioX = vui_param.aspect_ratio_info.aspect_ratio_x;
   1339         dest_aspect_ratio->aspectRatioY = vui_param.aspect_ratio_info.aspect_ratio_y;
   1340     }
   1341 }
   1342 
   1343 void h264_stream_parser::fill_pan_scan_data(OMX_QCOM_PANSCAN *dest_pan_scan, OMX_S64 timestamp)
   1344 {
   1345 #ifdef PANSCAN_HDLR
   1346     h264_pan_scan *pan_scan_param = panscan_hdl->get_populated(timestamp);
   1347 #else
   1348     h264_pan_scan *pan_scan_param = &panscan_param;
   1349 #endif
   1350     if (pan_scan_param) {
   1351         if (!(pan_scan_param->rect_id & NO_PAN_SCAN_BIT)) {
   1352             PRINT_PANSCAN_PARAM(*pan_scan_param);
   1353             dest_pan_scan->numWindows = pan_scan_param->cnt;
   1354             for (unsigned int i = 0; i < dest_pan_scan->numWindows; i++) {
   1355                 dest_pan_scan->window[i].x = pan_scan_param->rect_left_offset[i];
   1356                 dest_pan_scan->window[i].y = pan_scan_param->rect_top_offset[i];
   1357                 dest_pan_scan->window[i].dx = pan_scan_param->rect_right_offset[i];
   1358                 dest_pan_scan->window[i].dy = pan_scan_param->rect_bottom_offset[i];
   1359             }
   1360 #ifndef PANSCAN_HDLR
   1361             if (pan_scan_param->rect_repetition_period == 0)
   1362                 pan_scan_param->rect_id = NO_PAN_SCAN_BIT;
   1363             else if (pan_scan_param->rect_repetition_period > 1)
   1364                 pan_scan_param->rect_repetition_period =
   1365                     (pan_scan_param->rect_repetition_period == 2)? 0 :
   1366                     (pan_scan_param->rect_repetition_period - 1);
   1367 #endif
   1368         } else
   1369             pan_scan_param->rect_repetition_period = 0;
   1370     }
   1371 }
   1372 
   1373 OMX_S64 h264_stream_parser::process_ts_with_sei_vui(OMX_S64 timestamp)
   1374 {
   1375     bool clock_ts_flag = false;
   1376     OMX_S64 clock_ts = timestamp;
   1377     OMX_U32 deltaTfiDivisor = 2;
   1378     if (vui_param.timing_info_present_flag) {
   1379         if (vui_param.pic_struct_present_flag) {
   1380             if (sei_pic_timing.clock_ts_flag) {
   1381                 clock_ts = ((sei_pic_timing.hours_value * 60 + sei_pic_timing.minutes_value) * 60 + sei_pic_timing.seconds_value) * 1e6 +
   1382                     (sei_pic_timing.n_frames * (vui_param.num_units_in_tick * (1 + sei_pic_timing.nuit_field_based_flag)) + sei_pic_timing.time_offset) *
   1383                     1e6 / vui_param.time_scale;
   1384                 ALOGV("-->CLOCK TIMESTAMP   : %lld", clock_ts);
   1385                 clock_ts_flag = true;
   1386             }
   1387             if (vui_param.fixed_frame_rate_flag) {
   1388                 switch (sei_pic_timing.pic_struct) {
   1389                     case 1:
   1390                     case 2:
   1391                         deltaTfiDivisor = 1;
   1392                         break;
   1393                     case 0:
   1394                     case 3:
   1395                     case 4:
   1396                         deltaTfiDivisor = 2;
   1397                         break;
   1398                     case 5:
   1399                     case 6:
   1400                         deltaTfiDivisor = 3;
   1401                         break;
   1402                     case 7:
   1403                         deltaTfiDivisor = 4;
   1404                         break;
   1405                     case 8:
   1406                         deltaTfiDivisor = 6;
   1407                         break;
   1408                     default:
   1409                         ALOGE("process_ts_with_sei_vui: pic_struct invalid!");
   1410                 }
   1411             }
   1412         }
   1413         if (!clock_ts_flag) {
   1414             if (vui_param.fixed_frame_rate_flag)
   1415                 clock_ts = calculate_fixed_fps_ts(timestamp, deltaTfiDivisor);
   1416             else if (sei_buf_period.is_valid)
   1417                 clock_ts = calculate_buf_period_ts(timestamp);
   1418         }
   1419     } else {
   1420         ALOGV("NO TIMING information present in VUI!");
   1421     }
   1422     sei_pic_timing.is_valid = false; // SEI data is valid only for current frame
   1423     return clock_ts;
   1424 }
   1425 
   1426 #ifdef PANSCAN_HDLR
   1427 
   1428 panscan_handler::panscan_handler() : panscan_data(NULL) {}
   1429 
   1430 panscan_handler::~panscan_handler()
   1431 {
   1432     if (panscan_data) {
   1433         free(panscan_data);
   1434         panscan_data = NULL;
   1435     }
   1436 }
   1437 
   1438 bool panscan_handler::initialize(int num_data)
   1439 {
   1440     bool ret = false;
   1441     if (!panscan_data) {
   1442         panscan_data = (PANSCAN_NODE *) malloc (sizeof(PANSCAN_NODE) * num_data);
   1443         if (panscan_data) {
   1444             panscan_free.add_multiple(panscan_data, num_data);
   1445             ret = true;
   1446         }
   1447     } else {
   1448         ALOGE("ERROR: Old panscan memory must be freed to allocate new");
   1449     }
   1450     return ret;
   1451 }
   1452 
   1453 h264_pan_scan *panscan_handler::get_free()
   1454 {
   1455     h264_pan_scan *data = NULL;
   1456     PANSCAN_NODE *panscan_node = panscan_used.watch_last();
   1457     panscan_node = (!panscan_node || VALID_TS(panscan_node->start_ts))?
   1458         panscan_free.remove_first() :
   1459         panscan_used.remove_last();
   1460     if (panscan_node) {
   1461         panscan_node->start_ts = LLONG_MAX;
   1462         panscan_node->end_ts = LLONG_MAX;
   1463         panscan_node->pan_scan_param.rect_id = NO_PAN_SCAN_BIT;
   1464         panscan_node->active = false;
   1465         panscan_used.add_last(panscan_node);
   1466         data = &panscan_node->pan_scan_param;
   1467     }
   1468     return data;
   1469 }
   1470 
   1471 h264_pan_scan *panscan_handler::get_populated(OMX_S64 frame_ts)
   1472 {
   1473     h264_pan_scan *data = NULL;
   1474     PANSCAN_NODE *panscan_node = panscan_used.watch_first();
   1475     while (panscan_node && !data) {
   1476         if (VALID_TS(panscan_node->start_ts)) {
   1477             if (panscan_node->active && frame_ts < panscan_node->start_ts)
   1478                 panscan_node->start_ts = frame_ts;
   1479             if (frame_ts >= panscan_node->start_ts)
   1480                 if (frame_ts < panscan_node->end_ts) {
   1481                     data = &panscan_node->pan_scan_param;
   1482                     panscan_node->active = true;
   1483                 } else {
   1484                     panscan_free.add_last(panscan_used.remove_first());
   1485                     panscan_node = panscan_used.watch_first();
   1486                 }
   1487                 else
   1488                     // Finish search if current timestamp has not reached
   1489                     // start timestamp of first panscan data.
   1490                     panscan_node = NULL;
   1491         } else {
   1492             // Only one panscan data is stored for clips
   1493             // with invalid timestamps in every frame
   1494             data = &panscan_node->pan_scan_param;
   1495             panscan_node->active = true;
   1496         }
   1497     }
   1498     if (data) {
   1499         if (data->rect_repetition_period == 0)
   1500             panscan_free.add_last(panscan_used.remove_first());
   1501         else if (data->rect_repetition_period > 1)
   1502             data->rect_repetition_period -= 2;
   1503     }
   1504     PRINT_PANSCAN_DATA(panscan_node);
   1505     return data;
   1506 }
   1507 
   1508 void panscan_handler::update_last(OMX_S64 frame_ts)
   1509 {
   1510     PANSCAN_NODE *panscan_node = panscan_used.watch_last();
   1511     if (panscan_node && !VALID_TS(panscan_node->start_ts)) {
   1512         panscan_node->start_ts = frame_ts;
   1513         PRINT_PANSCAN_DATA(panscan_node);
   1514         if (panscan_node->prev) {
   1515             if (frame_ts < panscan_node->prev->end_ts)
   1516                 panscan_node->prev->end_ts = frame_ts;
   1517             else if (!VALID_TS(frame_ts))
   1518                 panscan_node->prev->pan_scan_param.rect_repetition_period = 0;
   1519             PRINT_PANSCAN_DATA(panscan_node->prev);
   1520         }
   1521     }
   1522 }
   1523 
   1524     template <class NODE_STRUCT>
   1525 void omx_dl_list<NODE_STRUCT>::add_multiple(NODE_STRUCT *data_arr, int data_num)
   1526 {
   1527     for (int idx = 0; idx < data_num; idx++)
   1528         add_last(&data_arr[idx]);
   1529 }
   1530 
   1531     template <class NODE_STRUCT>
   1532 NODE_STRUCT *omx_dl_list<NODE_STRUCT>::remove_first()
   1533 {
   1534     NODE_STRUCT *data = head;
   1535     if (head) {
   1536         if (head->next) {
   1537             head = head->next;
   1538             head->prev = NULL;
   1539         } else
   1540             head = tail = NULL;
   1541         data->next = data->prev = NULL;
   1542     }
   1543     return data;
   1544 }
   1545 
   1546     template <class NODE_STRUCT>
   1547 NODE_STRUCT *omx_dl_list<NODE_STRUCT>::remove_last()
   1548 {
   1549     NODE_STRUCT *data = tail;
   1550     if (tail) {
   1551         if (tail->prev) {
   1552             tail = tail->prev;
   1553             tail->next = NULL;
   1554         } else
   1555             head = tail = NULL;
   1556         data->next = data->prev = NULL;
   1557     }
   1558     return data;
   1559 }
   1560 
   1561     template <class NODE_STRUCT>
   1562 void omx_dl_list<NODE_STRUCT>::add_last(NODE_STRUCT* data_ptr)
   1563 {
   1564     if (data_ptr) {
   1565         data_ptr->next = NULL;
   1566         data_ptr->prev = tail;
   1567         if (tail) {
   1568             tail->next = data_ptr;
   1569             tail = data_ptr;
   1570         } else
   1571             head = tail = data_ptr;
   1572     }
   1573 }
   1574 
   1575     template <class NODE_STRUCT>
   1576 NODE_STRUCT* omx_dl_list<NODE_STRUCT>::watch_first()
   1577 {
   1578     return head;
   1579 }
   1580 
   1581     template <class NODE_STRUCT>
   1582 NODE_STRUCT* omx_dl_list<NODE_STRUCT>::watch_last()
   1583 {
   1584     return tail;
   1585 }
   1586 
   1587 #endif
   1588