Home | History | Annotate | Download | only in src
      1 /*--------------------------------------------------------------------------
      2 Copyright (c) 2010-2012, Code Aurora Forum. 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 Code Aurora 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                             O p e n M A X   w r a p p e r s
     30                              O p e n  M A X   C o r e
     31 
     32 *//** @file omx_video_base.cpp
     33   This module contains the implementation of the OpenMAX core & component.
     34 
     35 *//*========================================================================*/
     36 
     37 //////////////////////////////////////////////////////////////////////////////
     38 //                             Include Files
     39 //////////////////////////////////////////////////////////////////////////////
     40 
     41 #include <string.h>
     42 #include "omx_video_base.h"
     43 #include <stdlib.h>
     44 #include <errno.h>
     45 #include <fcntl.h>
     46 #include <unistd.h>
     47 #include <sys/prctl.h>
     48 #ifdef _ANDROID_ICS_
     49 #include <media/hardware/HardwareAPI.h>
     50 #include <gralloc_priv.h>
     51 #endif
     52 #ifndef _ANDROID_
     53 #include <glib.h>
     54 #define strlcpy g_strlcpy
     55 #endif
     56 #define H264_SUPPORTED_WIDTH (480)
     57 #define H264_SUPPORTED_HEIGHT (368)
     58 
     59 #define MPEG4_SUPPORTED_WIDTH (480)
     60 #define MPEG4_SUPPORTED_HEIGHT (368)
     61 
     62 #define VC1_SP_MP_START_CODE        0xC5000000
     63 #define VC1_SP_MP_START_CODE_MASK   0xFF000000
     64 #define VC1_AP_START_CODE           0x00000100
     65 #define VC1_AP_START_CODE_MASK      0xFFFFFF00
     66 #define VC1_STRUCT_C_PROFILE_MASK   0xF0
     67 #define VC1_STRUCT_B_LEVEL_MASK     0xE0000000
     68 #define VC1_SIMPLE_PROFILE          0
     69 #define VC1_MAIN_PROFILE            1
     70 #define VC1_ADVANCE_PROFILE         3
     71 #define VC1_SIMPLE_PROFILE_LOW_LEVEL  0
     72 #define VC1_SIMPLE_PROFILE_MED_LEVEL  2
     73 #define VC1_STRUCT_C_LEN            4
     74 #define VC1_STRUCT_C_POS            8
     75 #define VC1_STRUCT_A_POS            12
     76 #define VC1_STRUCT_B_POS            24
     77 #define VC1_SEQ_LAYER_SIZE          36
     78 
     79 #define IS_NOT_ALIGNED( num, to) (num & (to-1))
     80 #define ALIGN( num, to ) (((num) + (to-1)) & (~(to-1)))
     81 #define SZ_2K (2048)
     82 
     83 typedef struct OMXComponentCapabilityFlagsType
     84 {
     85     ////////////////// OMX COMPONENT CAPABILITY RELATED MEMBERS
     86     OMX_BOOL iIsOMXComponentMultiThreaded;
     87     OMX_BOOL iOMXComponentSupportsExternalOutputBufferAlloc;
     88     OMX_BOOL iOMXComponentSupportsExternalInputBufferAlloc;
     89     OMX_BOOL iOMXComponentSupportsMovableInputBuffers;
     90     OMX_BOOL iOMXComponentSupportsPartialFrames;
     91     OMX_BOOL iOMXComponentUsesNALStartCodes;
     92     OMX_BOOL iOMXComponentCanHandleIncompleteFrames;
     93     OMX_BOOL iOMXComponentUsesFullAVCFrames;
     94 
     95 } OMXComponentCapabilityFlagsType;
     96 #define OMX_COMPONENT_CAPABILITY_TYPE_INDEX 0xFF7A347
     97 #ifdef OUTPUT_BUFFER_LOG
     98 extern FILE *outputBufferFile1;
     99 #endif
    100 
    101 void* message_thread(void *input)
    102 {
    103   omx_video* omx = reinterpret_cast<omx_video*>(input);
    104   unsigned char id;
    105   int n;
    106 
    107   DEBUG_PRINT_LOW("omx_venc: message thread start\n");
    108   prctl(PR_SET_NAME, (unsigned long)"VideoEncMsgThread", 0, 0, 0);
    109   while(1)
    110   {
    111     n = read(omx->m_pipe_in, &id, 1);
    112     if(0 == n)
    113     {
    114       break;
    115     }
    116 
    117     if(1 == n)
    118     {
    119       omx->process_event_cb(omx, id);
    120     }
    121 #ifdef QLE_BUILD
    122     if(n < 0) break;
    123 #else
    124     if((n < 0) && (errno != EINTR)) break;
    125 #endif
    126   }
    127   DEBUG_PRINT_LOW("omx_venc: message thread stop\n");
    128   return 0;
    129 }
    130 
    131 void post_message(omx_video *omx, unsigned char id)
    132 {
    133   DEBUG_PRINT_LOW("omx_venc: post_message %d\n", id);
    134   write(omx->m_pipe_out, &id, 1);
    135 }
    136 
    137 // omx_cmd_queue destructor
    138 omx_video::omx_cmd_queue::~omx_cmd_queue()
    139 {
    140   // Nothing to do
    141 }
    142 
    143 // omx cmd queue constructor
    144 omx_video::omx_cmd_queue::omx_cmd_queue(): m_read(0),m_write(0),m_size(0)
    145 {
    146   memset(m_q,0,sizeof(omx_event)*OMX_CORE_CONTROL_CMDQ_SIZE);
    147 }
    148 
    149 // omx cmd queue insert
    150 bool omx_video::omx_cmd_queue::insert_entry(unsigned p1, unsigned p2, unsigned id)
    151 {
    152   bool ret = true;
    153   if(m_size < OMX_CORE_CONTROL_CMDQ_SIZE)
    154   {
    155     m_q[m_write].id       = id;
    156     m_q[m_write].param1   = p1;
    157     m_q[m_write].param2   = p2;
    158     m_write++;
    159     m_size ++;
    160     if(m_write >= OMX_CORE_CONTROL_CMDQ_SIZE)
    161     {
    162       m_write = 0;
    163     }
    164   }
    165   else
    166   {
    167     ret = false;
    168     DEBUG_PRINT_ERROR("ERROR!!! Command Queue Full\n");
    169   }
    170   return ret;
    171 }
    172 
    173 // omx cmd queue pop
    174 bool omx_video::omx_cmd_queue::pop_entry(unsigned *p1, unsigned *p2, unsigned *id)
    175 {
    176   bool ret = true;
    177   if(m_size > 0)
    178   {
    179     *id = m_q[m_read].id;
    180     *p1 = m_q[m_read].param1;
    181     *p2 = m_q[m_read].param2;
    182     // Move the read pointer ahead
    183     ++m_read;
    184     --m_size;
    185     if(m_read >= OMX_CORE_CONTROL_CMDQ_SIZE)
    186     {
    187       m_read = 0;
    188     }
    189   }
    190   else
    191   {
    192     ret = false;
    193   }
    194   return ret;
    195 }
    196 
    197 // Retrieve the first mesg type in the queue
    198 unsigned omx_video::omx_cmd_queue::get_q_msg_type()
    199 {
    200   return m_q[m_read].id;
    201 }
    202 
    203 
    204 
    205 #ifdef _ANDROID_
    206 VideoHeap::VideoHeap(int fd, size_t size, void* base)
    207 {
    208   // dup file descriptor, map once, use pmem
    209   init(dup(fd), base, size, 0 , MEM_DEVICE);
    210 }
    211 #endif // _ANDROID_
    212 
    213 /* ======================================================================
    214 FUNCTION
    215   omx_venc::omx_venc
    216 
    217 DESCRIPTION
    218   Constructor
    219 
    220 PARAMETERS
    221   None
    222 
    223 RETURN VALUE
    224   None.
    225 ========================================================================== */
    226 omx_video::omx_video(): m_state(OMX_StateInvalid),
    227                         m_app_data(NULL),
    228                         m_inp_mem_ptr(NULL),
    229                         m_out_mem_ptr(NULL),
    230                         m_pInput_pmem(NULL),
    231                         m_pOutput_pmem(NULL),
    232 #ifdef USE_ION
    233                         m_pInput_ion(NULL),
    234                         m_pOutput_ion(NULL),
    235 #endif
    236                         pending_input_buffers(0),
    237                         pending_output_buffers(0),
    238                         m_out_bm_count(0),
    239                         m_inp_bm_count(0),
    240                         m_flags(0),
    241                         m_event_port_settings_sent(false),
    242                         output_flush_progress (false),
    243                         input_flush_progress (false),
    244                         input_use_buffer (false),
    245                         output_use_buffer (false),
    246                         m_use_input_pmem(OMX_FALSE),
    247                         m_use_output_pmem(OMX_FALSE),
    248                         m_etb_count(0),
    249                         m_fbd_count(0),
    250                         m_error_propogated(false),
    251                         m_input_msg_id(OMX_COMPONENT_GENERATE_ETB),
    252                         psource_frame(NULL),
    253                         pdest_frame(NULL),
    254                         c2d_opened(false),
    255                         secure_session(false)
    256 {
    257   DEBUG_PRINT_HIGH("\n omx_video(): Inside Constructor()");
    258   memset(&m_cmp,0,sizeof(m_cmp));
    259   memset(&m_pCallbacks,0,sizeof(m_pCallbacks));
    260   secure_color_format = (int) OMX_COLOR_FormatYUV420SemiPlanar;
    261   pthread_mutex_init(&m_lock, NULL);
    262   sem_init(&m_cmd_lock,0,0);
    263 }
    264 
    265 
    266 /* ======================================================================
    267 FUNCTION
    268   omx_venc::~omx_venc
    269 
    270 DESCRIPTION
    271   Destructor
    272 
    273 PARAMETERS
    274   None
    275 
    276 RETURN VALUE
    277   None.
    278 ========================================================================== */
    279 omx_video::~omx_video()
    280 {
    281   DEBUG_PRINT_HIGH("\n ~omx_video(): Inside Destructor()");
    282   if(m_pipe_in) close(m_pipe_in);
    283   if(m_pipe_out) close(m_pipe_out);
    284   DEBUG_PRINT_HIGH("omx_video: Waiting on Msg Thread exit\n");
    285   pthread_join(msg_thread_id,NULL);
    286   DEBUG_PRINT_HIGH("omx_video: Waiting on Async Thread exit\n");
    287   pthread_join(async_thread_id,NULL);
    288   pthread_mutex_destroy(&m_lock);
    289   sem_destroy(&m_cmd_lock);
    290   DEBUG_PRINT_HIGH("\n m_etb_count = %u, m_fbd_count = %u\n", m_etb_count,
    291       m_fbd_count);
    292   DEBUG_PRINT_HIGH("omx_video: Destructor exit\n");
    293   DEBUG_PRINT_HIGH("Exiting 7x30 OMX Video Encoder ...\n");
    294 }
    295 
    296 /* ======================================================================
    297 FUNCTION
    298   omx_venc::OMXCntrlProcessMsgCb
    299 
    300 DESCRIPTION
    301   IL Client callbacks are generated through this routine. The decoder
    302   provides the thread context for this routine.
    303 
    304 PARAMETERS
    305   ctxt -- Context information related to the self.
    306   id   -- Event identifier. This could be any of the following:
    307           1. Command completion event
    308           2. Buffer done callback event
    309           3. Frame done callback event
    310 
    311 RETURN VALUE
    312   None.
    313 
    314 ========================================================================== */
    315 void omx_video::process_event_cb(void *ctxt, unsigned char id)
    316 {
    317   unsigned p1; // Parameter - 1
    318   unsigned p2; // Parameter - 2
    319   unsigned ident;
    320   unsigned qsize=0; // qsize
    321   omx_video *pThis = (omx_video *) ctxt;
    322 
    323   if(!pThis)
    324   {
    325     DEBUG_PRINT_ERROR("ERROR:ProcessMsgCb:Context is incorrect; bailing out\n");
    326     return;
    327   }
    328 
    329   // Protect the shared queue data structure
    330   do
    331   {
    332     /*Read the message id's from the queue*/
    333 
    334     pthread_mutex_lock(&pThis->m_lock);
    335     qsize = pThis->m_cmd_q.m_size;
    336     if(qsize)
    337     {
    338       pThis->m_cmd_q.pop_entry(&p1,&p2,&ident);
    339     }
    340 
    341     if(qsize == 0)
    342     {
    343       qsize = pThis->m_ftb_q.m_size;
    344       if(qsize)
    345       {
    346         pThis->m_ftb_q.pop_entry(&p1,&p2,&ident);
    347       }
    348     }
    349 
    350     if(qsize == 0)
    351     {
    352       qsize = pThis->m_etb_q.m_size;
    353       if(qsize)
    354       {
    355         pThis->m_etb_q.pop_entry(&p1,&p2,&ident);
    356       }
    357     }
    358 
    359     pthread_mutex_unlock(&pThis->m_lock);
    360 
    361     /*process message if we have one*/
    362     if(qsize > 0)
    363     {
    364       id = ident;
    365       switch(id)
    366       {
    367       case OMX_COMPONENT_GENERATE_EVENT:
    368         if(pThis->m_pCallbacks.EventHandler)
    369         {
    370           switch(p1)
    371           {
    372           case OMX_CommandStateSet:
    373             pThis->m_state = (OMX_STATETYPE) p2;
    374             DEBUG_PRINT_LOW("Process -> state set to %d \n", pThis->m_state);
    375             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
    376                                              OMX_EventCmdComplete, p1, p2, NULL);
    377             break;
    378 
    379           case OMX_EventError:
    380             DEBUG_PRINT_ERROR("\nERROR: OMX_EventError: p2 = %d\n", p2);
    381             if(p2 == OMX_ErrorHardware)
    382             {
    383               pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
    384                                                OMX_EventError,OMX_ErrorHardware,0,NULL);
    385             }
    386             else
    387             {
    388               pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
    389                                                OMX_EventError, p2, NULL, NULL );
    390 
    391             }
    392             break;
    393 
    394           case OMX_CommandPortDisable:
    395             DEBUG_PRINT_LOW("Process -> Port %d set to PORT_STATE_DISABLED" \
    396                         "state \n", p2);
    397             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
    398                                              OMX_EventCmdComplete, p1, p2, NULL );
    399             break;
    400           case OMX_CommandPortEnable:
    401             DEBUG_PRINT_LOW("Process ->Port %d set PORT_STATE_ENABLED state\n" \
    402                         , p2);
    403             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,\
    404                                              OMX_EventCmdComplete, p1, p2, NULL );
    405             break;
    406 
    407           default:
    408             DEBUG_PRINT_LOW("\n process_event_cb forwarding EventCmdComplete %d \n", p1);
    409             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
    410                                              OMX_EventCmdComplete, p1, p2, NULL );
    411             break;
    412 
    413           }
    414         }
    415         else
    416         {
    417           DEBUG_PRINT_ERROR("ERROR: ProcessMsgCb NULL callbacks\n");
    418         }
    419         break;
    420       case OMX_COMPONENT_GENERATE_ETB_OPQ:
    421         DEBUG_PRINT_LOW("OMX_COMPONENT_GENERATE_ETB_OPQ\n");
    422         if(pThis->empty_this_buffer_opaque((OMX_HANDLETYPE)p1,\
    423                                           (OMX_BUFFERHEADERTYPE *)p2) != OMX_ErrorNone)
    424         {
    425           DEBUG_PRINT_ERROR("\nERROR: ETBProxy() failed!\n");
    426           pThis->omx_report_error ();
    427         }
    428         break;
    429       case OMX_COMPONENT_GENERATE_ETB:
    430         DEBUG_PRINT_LOW("OMX_COMPONENT_GENERATE_ETB\n");
    431         if(pThis->empty_this_buffer_proxy((OMX_HANDLETYPE)p1,\
    432                                           (OMX_BUFFERHEADERTYPE *)p2) != OMX_ErrorNone)
    433         {
    434           DEBUG_PRINT_ERROR("\nERROR: ETBProxy() failed!\n");
    435           pThis->omx_report_error ();
    436         }
    437         break;
    438 
    439       case OMX_COMPONENT_GENERATE_FTB:
    440         if( pThis->fill_this_buffer_proxy((OMX_HANDLETYPE)p1,\
    441                                           (OMX_BUFFERHEADERTYPE *)p2) != OMX_ErrorNone)
    442         {
    443           DEBUG_PRINT_ERROR("\nERROR: FTBProxy() failed!\n");
    444           pThis->omx_report_error ();
    445         }
    446         break;
    447 
    448       case OMX_COMPONENT_GENERATE_COMMAND:
    449         pThis->send_command_proxy(&pThis->m_cmp,(OMX_COMMANDTYPE)p1,\
    450                                   (OMX_U32)p2,(OMX_PTR)NULL);
    451         break;
    452 
    453       case OMX_COMPONENT_GENERATE_EBD:
    454         if( pThis->empty_buffer_done(&pThis->m_cmp,
    455                                      (OMX_BUFFERHEADERTYPE *)p1) != OMX_ErrorNone)
    456         {
    457           DEBUG_PRINT_ERROR("\nERROR: empty_buffer_done() failed!\n");
    458           pThis->omx_report_error ();
    459         }
    460         break;
    461 
    462       case OMX_COMPONENT_GENERATE_FBD:
    463         if( pThis->fill_buffer_done(&pThis->m_cmp,
    464                                     (OMX_BUFFERHEADERTYPE *)p1) != OMX_ErrorNone )
    465         {
    466           DEBUG_PRINT_ERROR("\nERROR: fill_buffer_done() failed!\n");
    467           pThis->omx_report_error ();
    468         }
    469         break;
    470 
    471       case OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH:
    472 
    473         pThis->input_flush_progress = false;
    474         DEBUG_PRINT_HIGH("\nm_etb_count at i/p flush = %u", m_etb_count);
    475         m_etb_count = 0;
    476         if(pThis->m_pCallbacks.EventHandler)
    477         {
    478           /*Check if we need generate event for Flush done*/
    479           if(BITMASK_PRESENT(&pThis->m_flags,
    480                              OMX_COMPONENT_INPUT_FLUSH_PENDING))
    481           {
    482             BITMASK_CLEAR (&pThis->m_flags,OMX_COMPONENT_INPUT_FLUSH_PENDING);
    483             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
    484                                              OMX_EventCmdComplete,OMX_CommandFlush,
    485                                              PORT_INDEX_IN,NULL );
    486           }
    487           else if(BITMASK_PRESENT(&pThis->m_flags,
    488                                   OMX_COMPONENT_IDLE_PENDING))
    489           {
    490             if(!pThis->output_flush_progress)
    491             {
    492               DEBUG_PRINT_LOW("\n dev_stop called after input flush complete\n");
    493               if(dev_stop() != 0)
    494               {
    495                 DEBUG_PRINT_ERROR("\nERROR: dev_stop() failed in i/p flush!\n");
    496                 pThis->omx_report_error ();
    497               }
    498             }
    499           }
    500         }
    501 
    502         break;
    503 
    504       case OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH:
    505 
    506         pThis->output_flush_progress = false;
    507         DEBUG_PRINT_HIGH("\nm_fbd_count at o/p flush = %u", m_fbd_count);
    508         m_fbd_count = 0;
    509         if(pThis->m_pCallbacks.EventHandler)
    510         {
    511           /*Check if we need generate event for Flush done*/
    512           if(BITMASK_PRESENT(&pThis->m_flags,
    513                              OMX_COMPONENT_OUTPUT_FLUSH_PENDING))
    514           {
    515             BITMASK_CLEAR (&pThis->m_flags,OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
    516 
    517             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
    518                                              OMX_EventCmdComplete,OMX_CommandFlush,
    519                                              PORT_INDEX_OUT,NULL );
    520           }
    521           else if(BITMASK_PRESENT(&pThis->m_flags ,OMX_COMPONENT_IDLE_PENDING))
    522           {
    523             DEBUG_PRINT_LOW("\n dev_stop called after Output flush complete\n");
    524             if(!pThis->input_flush_progress)
    525             {
    526               if(dev_stop() != 0)
    527               {
    528                 DEBUG_PRINT_ERROR("\nERROR: dev_stop() failed in o/p flush!\n");
    529                 pThis->omx_report_error ();
    530               }
    531             }
    532           }
    533         }
    534         break;
    535 
    536       case OMX_COMPONENT_GENERATE_START_DONE:
    537         DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_START_DONE msg");
    538 
    539         if(pThis->m_pCallbacks.EventHandler)
    540         {
    541           DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_START_DONE Success");
    542           if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
    543           {
    544             DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_START_DONE Move to \
    545                              executing");
    546             // Send the callback now
    547             BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_EXECUTE_PENDING);
    548             pThis->m_state = OMX_StateExecuting;
    549             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
    550                                              OMX_EventCmdComplete,OMX_CommandStateSet,
    551                                              OMX_StateExecuting, NULL);
    552           }
    553           else if(BITMASK_PRESENT(&pThis->m_flags,
    554                                   OMX_COMPONENT_PAUSE_PENDING))
    555           {
    556             if(dev_pause())
    557             {
    558               DEBUG_PRINT_ERROR("\nERROR: dev_pause() failed in Start Done!\n");
    559               pThis->omx_report_error ();
    560             }
    561           }
    562           else if (BITMASK_PRESENT(&pThis->m_flags,
    563                                    OMX_COMPONENT_LOADED_START_PENDING))
    564           {
    565             if(dev_loaded_start_done())
    566             {
    567               DEBUG_PRINT_LOW("successful loaded Start Done!");
    568             }
    569             else
    570             {
    571               DEBUG_PRINT_ERROR("ERROR: failed in loaded Start Done!");
    572               pThis->omx_report_error ();
    573             }
    574             BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_LOADED_START_PENDING);
    575           }
    576           else
    577           {
    578             DEBUG_PRINT_ERROR("\nERROR: unknown flags=%x\n",pThis->m_flags);
    579           }
    580         }
    581         else
    582         {
    583           DEBUG_PRINT_LOW("\n Event Handler callback is NULL");
    584         }
    585         break;
    586 
    587       case OMX_COMPONENT_GENERATE_PAUSE_DONE:
    588         DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_PAUSE_DONE msg");
    589         if(pThis->m_pCallbacks.EventHandler)
    590         {
    591           if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_PAUSE_PENDING))
    592           {
    593             //Send the callback now
    594             pThis->complete_pending_buffer_done_cbs();
    595             DEBUG_PRINT_LOW("omx_video::process_event_cb() Sending PAUSE complete after all pending EBD/FBD\n");
    596             BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_PAUSE_PENDING);
    597             pThis->m_state = OMX_StatePause;
    598             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
    599                                              OMX_EventCmdComplete,OMX_CommandStateSet,
    600                                              OMX_StatePause, NULL);
    601           }
    602         }
    603 
    604         break;
    605 
    606       case OMX_COMPONENT_GENERATE_RESUME_DONE:
    607         DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_RESUME_DONE msg");
    608         if(pThis->m_pCallbacks.EventHandler)
    609         {
    610           if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
    611           {
    612             // Send the callback now
    613             BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_EXECUTE_PENDING);
    614             pThis->m_state = OMX_StateExecuting;
    615             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
    616                                              OMX_EventCmdComplete,OMX_CommandStateSet,
    617                                              OMX_StateExecuting,NULL);
    618           }
    619         }
    620 
    621         break;
    622 
    623       case OMX_COMPONENT_GENERATE_STOP_DONE:
    624         DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_STOP_DONE msg");
    625         if(pThis->m_pCallbacks.EventHandler)
    626         {
    627           pThis->complete_pending_buffer_done_cbs();
    628           if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_IDLE_PENDING))
    629           {
    630             // Send the callback now
    631             BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_IDLE_PENDING);
    632             pThis->m_state = OMX_StateIdle;
    633             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp,pThis->m_app_data,
    634                                              OMX_EventCmdComplete,OMX_CommandStateSet,
    635                                              OMX_StateIdle,NULL);
    636           }
    637           else if (BITMASK_PRESENT(&pThis->m_flags,
    638                                    OMX_COMPONENT_LOADED_STOP_PENDING))
    639           {
    640             if(dev_loaded_stop_done())
    641             {
    642               DEBUG_PRINT_LOW("successful loaded Stop Done!");
    643             }
    644             else
    645             {
    646               DEBUG_PRINT_ERROR("ERROR: failed in loaded Stop Done!");
    647               pThis->omx_report_error ();
    648             }
    649             BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_LOADED_STOP_PENDING);
    650           }
    651           else
    652           {
    653             DEBUG_PRINT_ERROR("\nERROR: unknown flags=%x\n",pThis->m_flags);
    654           }
    655         }
    656 
    657         break;
    658 
    659       case OMX_COMPONENT_GENERATE_HARDWARE_ERROR:
    660         DEBUG_PRINT_ERROR("\nERROR: OMX_COMPONENT_GENERATE_HARDWARE_ERROR!\n");
    661         pThis->omx_report_error ();
    662         break;
    663 
    664       default:
    665         DEBUG_PRINT_LOW("\n process_event_cb unknown msg id 0x%02x", id);
    666         break;
    667       }
    668     }
    669 
    670     pthread_mutex_lock(&pThis->m_lock);
    671     qsize = pThis->m_cmd_q.m_size + pThis->m_ftb_q.m_size +\
    672             pThis->m_etb_q.m_size;
    673 
    674     pthread_mutex_unlock(&pThis->m_lock);
    675 
    676   }
    677   while(qsize>0);
    678   DEBUG_PRINT_LOW("\n exited the while loop\n");
    679 
    680 }
    681 
    682 
    683 
    684 
    685 /* ======================================================================
    686 FUNCTION
    687   omx_venc::GetComponentVersion
    688 
    689 DESCRIPTION
    690   Returns the component version.
    691 
    692 PARAMETERS
    693   TBD.
    694 
    695 RETURN VALUE
    696   OMX_ErrorNone.
    697 
    698 ========================================================================== */
    699 OMX_ERRORTYPE  omx_video::get_component_version
    700 (
    701 OMX_IN OMX_HANDLETYPE hComp,
    702 OMX_OUT OMX_STRING componentName,
    703 OMX_OUT OMX_VERSIONTYPE* componentVersion,
    704 OMX_OUT OMX_VERSIONTYPE* specVersion,
    705 OMX_OUT OMX_UUIDTYPE* componentUUID
    706 )
    707 {
    708   if(m_state == OMX_StateInvalid)
    709   {
    710     DEBUG_PRINT_ERROR("ERROR: Get Comp Version in Invalid State\n");
    711     return OMX_ErrorInvalidState;
    712   }
    713   /* TBD -- Return the proper version */
    714   if (specVersion)
    715   {
    716     specVersion->nVersion = OMX_SPEC_VERSION;
    717   }
    718   return OMX_ErrorNone;
    719 }
    720 /* ======================================================================
    721 FUNCTION
    722   omx_venc::SendCommand
    723 
    724 DESCRIPTION
    725   Returns zero if all the buffers released..
    726 
    727 PARAMETERS
    728   None.
    729 
    730 RETURN VALUE
    731   true/false
    732 
    733 ========================================================================== */
    734 OMX_ERRORTYPE  omx_video::send_command(OMX_IN OMX_HANDLETYPE hComp,
    735                                        OMX_IN OMX_COMMANDTYPE cmd,
    736                                        OMX_IN OMX_U32 param1,
    737                                        OMX_IN OMX_PTR cmdData
    738                                       )
    739 {
    740   if(m_state == OMX_StateInvalid)
    741   {
    742     DEBUG_PRINT_ERROR("ERROR: Send Command in Invalid State\n");
    743     return OMX_ErrorInvalidState;
    744   }
    745 
    746   if(cmd == OMX_CommandFlush || cmd == OMX_CommandPortDisable || cmd == OMX_CommandPortEnable)
    747   {
    748     if((param1 != PORT_INDEX_IN) && (param1 != PORT_INDEX_OUT) && (param1 != PORT_INDEX_BOTH))
    749     {
    750       DEBUG_PRINT_ERROR("ERROR: omx_video::send_command-->bad port index\n");
    751       return OMX_ErrorBadPortIndex;
    752     }
    753   }
    754   if(cmd == OMX_CommandMarkBuffer)
    755   {
    756     if(param1 != PORT_INDEX_IN)
    757     {
    758       DEBUG_PRINT_ERROR("ERROR: omx_video::send_command-->bad port index \n");
    759       return OMX_ErrorBadPortIndex;
    760     }
    761     if(!cmdData)
    762     {
    763       DEBUG_PRINT_ERROR("ERROR: omx_video::send_command-->param is null");
    764       return OMX_ErrorBadParameter;
    765     }
    766   }
    767 
    768   post_event((unsigned)cmd,(unsigned)param1,OMX_COMPONENT_GENERATE_COMMAND);
    769   sem_wait(&m_cmd_lock);
    770   return OMX_ErrorNone;
    771 }
    772 
    773 /* ======================================================================
    774 FUNCTION
    775   omx_venc::SendCommand
    776 
    777 DESCRIPTION
    778   Returns zero if all the buffers released..
    779 
    780 PARAMETERS
    781   None.
    782 
    783 RETURN VALUE
    784   true/false
    785 
    786 ========================================================================== */
    787 OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
    788                                              OMX_IN OMX_COMMANDTYPE cmd,
    789                                              OMX_IN OMX_U32 param1,
    790                                              OMX_IN OMX_PTR cmdData
    791                                             )
    792 {
    793   OMX_ERRORTYPE eRet = OMX_ErrorNone;
    794   OMX_STATETYPE eState = (OMX_STATETYPE) param1;
    795   int bFlag = 1;
    796 
    797   if(cmd == OMX_CommandStateSet)
    798   {
    799     /***************************/
    800     /* Current State is Loaded */
    801     /***************************/
    802     if(m_state == OMX_StateLoaded)
    803     {
    804       if(eState == OMX_StateIdle)
    805       {
    806         //if all buffers are allocated or all ports disabled
    807         if(allocate_done() ||
    808            ( m_sInPortDef.bEnabled == OMX_FALSE && m_sOutPortDef.bEnabled == OMX_FALSE))
    809         {
    810           DEBUG_PRINT_LOW("OMXCORE-SM: Loaded-->Idle\n");
    811         }
    812         else
    813         {
    814           DEBUG_PRINT_LOW("OMXCORE-SM: Loaded-->Idle-Pending\n");
    815           BITMASK_SET(&m_flags, OMX_COMPONENT_IDLE_PENDING);
    816           // Skip the event notification
    817           bFlag = 0;
    818         }
    819       }
    820       /* Requesting transition from Loaded to Loaded */
    821       else if(eState == OMX_StateLoaded)
    822       {
    823         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Loaded-->Loaded\n");
    824         post_event(OMX_EventError,OMX_ErrorSameState,\
    825                    OMX_COMPONENT_GENERATE_EVENT);
    826         eRet = OMX_ErrorSameState;
    827       }
    828       /* Requesting transition from Loaded to WaitForResources */
    829       else if(eState == OMX_StateWaitForResources)
    830       {
    831         /* Since error is None , we will post an event
    832            at the end of this function definition */
    833         DEBUG_PRINT_LOW("OMXCORE-SM: Loaded-->WaitForResources\n");
    834       }
    835       /* Requesting transition from Loaded to Executing */
    836       else if(eState == OMX_StateExecuting)
    837       {
    838         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Loaded-->Executing\n");
    839         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
    840                    OMX_COMPONENT_GENERATE_EVENT);
    841         eRet = OMX_ErrorIncorrectStateTransition;
    842       }
    843       /* Requesting transition from Loaded to Pause */
    844       else if(eState == OMX_StatePause)
    845       {
    846         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Loaded-->Pause\n");
    847         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
    848                    OMX_COMPONENT_GENERATE_EVENT);
    849         eRet = OMX_ErrorIncorrectStateTransition;
    850       }
    851       /* Requesting transition from Loaded to Invalid */
    852       else if(eState == OMX_StateInvalid)
    853       {
    854         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Loaded-->Invalid\n");
    855         post_event(OMX_EventError,eState,OMX_COMPONENT_GENERATE_EVENT);
    856         eRet = OMX_ErrorInvalidState;
    857       }
    858       else
    859       {
    860         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Loaded-->%d Not Handled\n",\
    861                           eState);
    862         eRet = OMX_ErrorBadParameter;
    863       }
    864     }
    865 
    866     /***************************/
    867     /* Current State is IDLE */
    868     /***************************/
    869     else if(m_state == OMX_StateIdle)
    870     {
    871       if(eState == OMX_StateLoaded)
    872       {
    873         if(release_done())
    874         {
    875           /*
    876              Since error is None , we will post an event at the end
    877              of this function definition
    878           */
    879           DEBUG_PRINT_LOW("OMXCORE-SM: Idle-->Loaded\n");
    880           if(dev_stop() != 0)
    881           {
    882             DEBUG_PRINT_ERROR("\nERROR: dev_stop() failed at Idle --> Loaded");
    883             eRet = OMX_ErrorHardware;
    884           }
    885         }
    886         else
    887         {
    888           DEBUG_PRINT_LOW("OMXCORE-SM: Idle-->Loaded-Pending\n");
    889           BITMASK_SET(&m_flags, OMX_COMPONENT_LOADING_PENDING);
    890           // Skip the event notification
    891           bFlag = 0;
    892         }
    893       }
    894       /* Requesting transition from Idle to Executing */
    895       else if(eState == OMX_StateExecuting)
    896       {
    897         if( dev_start() )
    898         {
    899           DEBUG_PRINT_ERROR("\nERROR: dev_start() failed in SCP on Idle --> Exe\n");
    900           omx_report_error ();
    901           eRet = OMX_ErrorHardware;
    902         }
    903         else
    904         {
    905           BITMASK_SET(&m_flags,OMX_COMPONENT_EXECUTE_PENDING);
    906           DEBUG_PRINT_LOW("OMXCORE-SM: Idle-->Executing\n");
    907           bFlag = 0;
    908         }
    909 
    910 	dev_start_done();
    911       }
    912       /* Requesting transition from Idle to Idle */
    913       else if(eState == OMX_StateIdle)
    914       {
    915         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Idle-->Idle\n");
    916         post_event(OMX_EventError,OMX_ErrorSameState,\
    917                    OMX_COMPONENT_GENERATE_EVENT);
    918         eRet = OMX_ErrorSameState;
    919       }
    920       /* Requesting transition from Idle to WaitForResources */
    921       else if(eState == OMX_StateWaitForResources)
    922       {
    923         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Idle-->WaitForResources\n");
    924         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
    925                    OMX_COMPONENT_GENERATE_EVENT);
    926         eRet = OMX_ErrorIncorrectStateTransition;
    927       }
    928       /* Requesting transition from Idle to Pause */
    929       else if(eState == OMX_StatePause)
    930       {
    931         /*To pause the Video core we need to start the driver*/
    932         if( dev_start() )
    933         {
    934           DEBUG_PRINT_ERROR("\nERROR: dev_start() failed in SCP on Idle --> Pause\n");
    935           omx_report_error ();
    936           eRet = OMX_ErrorHardware;
    937         }
    938         else
    939         {
    940           BITMASK_SET(&m_flags,OMX_COMPONENT_PAUSE_PENDING);
    941           DEBUG_PRINT_LOW("OMXCORE-SM: Idle-->Pause\n");
    942           bFlag = 0;
    943         }
    944       }
    945       /* Requesting transition from Idle to Invalid */
    946       else if(eState == OMX_StateInvalid)
    947       {
    948         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Idle-->Invalid\n");
    949         post_event(OMX_EventError,eState,OMX_COMPONENT_GENERATE_EVENT);
    950         eRet = OMX_ErrorInvalidState;
    951       }
    952       else
    953       {
    954         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Idle --> %d Not Handled\n",eState);
    955         eRet = OMX_ErrorBadParameter;
    956       }
    957     }
    958 
    959     /******************************/
    960     /* Current State is Executing */
    961     /******************************/
    962     else if(m_state == OMX_StateExecuting)
    963     {
    964       /* Requesting transition from Executing to Idle */
    965       if(eState == OMX_StateIdle)
    966       {
    967         /* Since error is None , we will post an event
    968         at the end of this function definition
    969         */
    970         DEBUG_PRINT_LOW("\n OMXCORE-SM: Executing --> Idle \n");
    971         //here this should be Pause-Idle pending and should be cleared when flush is complete and change the state to Idle
    972         BITMASK_SET(&m_flags,OMX_COMPONENT_IDLE_PENDING);
    973         execute_omx_flush(OMX_ALL);
    974         bFlag = 0;
    975 	dev_stop_done();
    976       }
    977       /* Requesting transition from Executing to Paused */
    978       else if(eState == OMX_StatePause)
    979       {
    980 
    981         if(dev_pause())
    982         {
    983           DEBUG_PRINT_ERROR("\nERROR: dev_pause() failed in SCP on Exe --> Pause\n");
    984           post_event(OMX_EventError,OMX_ErrorHardware,\
    985                      OMX_COMPONENT_GENERATE_EVENT);
    986           eRet = OMX_ErrorHardware;
    987         }
    988         else
    989         {
    990           BITMASK_SET(&m_flags,OMX_COMPONENT_PAUSE_PENDING);
    991           DEBUG_PRINT_LOW("OMXCORE-SM: Executing-->Pause\n");
    992           bFlag = 0;
    993         }
    994       }
    995       /* Requesting transition from Executing to Loaded */
    996       else if(eState == OMX_StateLoaded)
    997       {
    998         DEBUG_PRINT_ERROR("\nERROR: OMXCORE-SM: Executing --> Loaded \n");
    999         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
   1000                    OMX_COMPONENT_GENERATE_EVENT);
   1001         eRet = OMX_ErrorIncorrectStateTransition;
   1002       }
   1003       /* Requesting transition from Executing to WaitForResources */
   1004       else if(eState == OMX_StateWaitForResources)
   1005       {
   1006         DEBUG_PRINT_ERROR("\nERROR: OMXCORE-SM: Executing --> WaitForResources \n");
   1007         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
   1008                    OMX_COMPONENT_GENERATE_EVENT);
   1009         eRet = OMX_ErrorIncorrectStateTransition;
   1010       }
   1011       /* Requesting transition from Executing to Executing */
   1012       else if(eState == OMX_StateExecuting)
   1013       {
   1014         DEBUG_PRINT_ERROR("\nERROR: OMXCORE-SM: Executing --> Executing \n");
   1015         post_event(OMX_EventError,OMX_ErrorSameState,\
   1016                    OMX_COMPONENT_GENERATE_EVENT);
   1017         eRet = OMX_ErrorSameState;
   1018       }
   1019       /* Requesting transition from Executing to Invalid */
   1020       else if(eState == OMX_StateInvalid)
   1021       {
   1022         DEBUG_PRINT_ERROR("\nERROR: OMXCORE-SM: Executing --> Invalid \n");
   1023         post_event(OMX_EventError,eState,OMX_COMPONENT_GENERATE_EVENT);
   1024         eRet = OMX_ErrorInvalidState;
   1025       }
   1026       else
   1027       {
   1028         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Executing --> %d Not Handled\n",eState);
   1029         eRet = OMX_ErrorBadParameter;
   1030       }
   1031     }
   1032     /***************************/
   1033     /* Current State is Pause  */
   1034     /***************************/
   1035     else if(m_state == OMX_StatePause)
   1036     {
   1037       /* Requesting transition from Pause to Executing */
   1038       if(eState == OMX_StateExecuting)
   1039       {
   1040         DEBUG_PRINT_LOW("\n Pause --> Executing \n");
   1041         if( dev_resume() )
   1042         {
   1043           post_event(OMX_EventError,OMX_ErrorHardware,\
   1044                      OMX_COMPONENT_GENERATE_EVENT);
   1045           eRet = OMX_ErrorHardware;
   1046         }
   1047         else
   1048         {
   1049           BITMASK_SET(&m_flags,OMX_COMPONENT_EXECUTE_PENDING);
   1050           DEBUG_PRINT_LOW("OMXCORE-SM: Pause-->Executing\n");
   1051           post_event (NULL, NULL, OMX_COMPONENT_GENERATE_RESUME_DONE);
   1052           bFlag = 0;
   1053         }
   1054       }
   1055       /* Requesting transition from Pause to Idle */
   1056       else if(eState == OMX_StateIdle)
   1057       {
   1058         /* Since error is None , we will post an event
   1059         at the end of this function definition */
   1060         DEBUG_PRINT_LOW("\n Pause --> Idle \n");
   1061         BITMASK_SET(&m_flags,OMX_COMPONENT_IDLE_PENDING);
   1062         execute_omx_flush(OMX_ALL);
   1063         bFlag = 0;
   1064       }
   1065       /* Requesting transition from Pause to loaded */
   1066       else if(eState == OMX_StateLoaded)
   1067       {
   1068         DEBUG_PRINT_ERROR("\nERROR: Pause --> loaded \n");
   1069         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
   1070                    OMX_COMPONENT_GENERATE_EVENT);
   1071         eRet = OMX_ErrorIncorrectStateTransition;
   1072       }
   1073       /* Requesting transition from Pause to WaitForResources */
   1074       else if(eState == OMX_StateWaitForResources)
   1075       {
   1076         DEBUG_PRINT_ERROR("\nERROR: Pause --> WaitForResources \n");
   1077         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
   1078                    OMX_COMPONENT_GENERATE_EVENT);
   1079         eRet = OMX_ErrorIncorrectStateTransition;
   1080       }
   1081       /* Requesting transition from Pause to Pause */
   1082       else if(eState == OMX_StatePause)
   1083       {
   1084         DEBUG_PRINT_ERROR("\nERROR: Pause --> Pause \n");
   1085         post_event(OMX_EventError,OMX_ErrorSameState,\
   1086                    OMX_COMPONENT_GENERATE_EVENT);
   1087         eRet = OMX_ErrorSameState;
   1088       }
   1089       /* Requesting transition from Pause to Invalid */
   1090       else if(eState == OMX_StateInvalid)
   1091       {
   1092         DEBUG_PRINT_ERROR("\nERROR: Pause --> Invalid \n");
   1093         post_event(OMX_EventError,eState,OMX_COMPONENT_GENERATE_EVENT);
   1094         eRet = OMX_ErrorInvalidState;
   1095       }
   1096       else
   1097       {
   1098         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Paused --> %d Not Handled\n",eState);
   1099         eRet = OMX_ErrorBadParameter;
   1100       }
   1101     }
   1102     /***************************/
   1103     /* Current State is WaitForResources  */
   1104     /***************************/
   1105     else if(m_state == OMX_StateWaitForResources)
   1106     {
   1107       /* Requesting transition from WaitForResources to Loaded */
   1108       if(eState == OMX_StateLoaded)
   1109       {
   1110         /* Since error is None , we will post an event
   1111         at the end of this function definition */
   1112         DEBUG_PRINT_LOW("OMXCORE-SM: WaitForResources-->Loaded\n");
   1113       }
   1114       /* Requesting transition from WaitForResources to WaitForResources */
   1115       else if(eState == OMX_StateWaitForResources)
   1116       {
   1117         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: WaitForResources-->WaitForResources\n");
   1118         post_event(OMX_EventError,OMX_ErrorSameState,
   1119                    OMX_COMPONENT_GENERATE_EVENT);
   1120         eRet = OMX_ErrorSameState;
   1121       }
   1122       /* Requesting transition from WaitForResources to Executing */
   1123       else if(eState == OMX_StateExecuting)
   1124       {
   1125         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: WaitForResources-->Executing\n");
   1126         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
   1127                    OMX_COMPONENT_GENERATE_EVENT);
   1128         eRet = OMX_ErrorIncorrectStateTransition;
   1129       }
   1130       /* Requesting transition from WaitForResources to Pause */
   1131       else if(eState == OMX_StatePause)
   1132       {
   1133         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: WaitForResources-->Pause\n");
   1134         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
   1135                    OMX_COMPONENT_GENERATE_EVENT);
   1136         eRet = OMX_ErrorIncorrectStateTransition;
   1137       }
   1138       /* Requesting transition from WaitForResources to Invalid */
   1139       else if(eState == OMX_StateInvalid)
   1140       {
   1141         DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: WaitForResources-->Invalid\n");
   1142         post_event(OMX_EventError,eState,OMX_COMPONENT_GENERATE_EVENT);
   1143         eRet = OMX_ErrorInvalidState;
   1144       }
   1145       /* Requesting transition from WaitForResources to Loaded -
   1146       is NOT tested by Khronos TS */
   1147 
   1148     }
   1149     else
   1150     {
   1151       DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: %d --> %d(Not Handled)\n",m_state,eState);
   1152       eRet = OMX_ErrorBadParameter;
   1153     }
   1154   }
   1155   /********************************/
   1156   /* Current State is Invalid */
   1157   /*******************************/
   1158   else if(m_state == OMX_StateInvalid)
   1159   {
   1160     /* State Transition from Inavlid to any state */
   1161     if(eState == (OMX_StateLoaded || OMX_StateWaitForResources
   1162                   || OMX_StateIdle || OMX_StateExecuting
   1163                   || OMX_StatePause || OMX_StateInvalid))
   1164     {
   1165       DEBUG_PRINT_ERROR("ERROR: OMXCORE-SM: Invalid -->Loaded\n");
   1166       post_event(OMX_EventError,OMX_ErrorInvalidState,\
   1167                  OMX_COMPONENT_GENERATE_EVENT);
   1168       eRet = OMX_ErrorInvalidState;
   1169     }
   1170   }
   1171   else if(cmd == OMX_CommandFlush)
   1172   {
   1173     if(0 == param1 || OMX_ALL == param1)
   1174     {
   1175       BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_FLUSH_PENDING);
   1176     }
   1177     if(1 == param1 || OMX_ALL == param1)
   1178     {
   1179       //generate output flush event only.
   1180       BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
   1181     }
   1182 
   1183     execute_omx_flush(param1);
   1184     bFlag = 0;
   1185   }
   1186   else if( cmd == OMX_CommandPortEnable)
   1187   {
   1188     if(param1 == PORT_INDEX_IN || param1 == OMX_ALL)
   1189     {
   1190       m_sInPortDef.bEnabled = OMX_TRUE;
   1191 
   1192       if( (m_state == OMX_StateLoaded &&
   1193            !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
   1194           || allocate_input_done())
   1195       {
   1196         post_event(OMX_CommandPortEnable,PORT_INDEX_IN,
   1197                    OMX_COMPONENT_GENERATE_EVENT);
   1198       }
   1199       else
   1200       {
   1201         DEBUG_PRINT_LOW("OMXCORE-SM: Disabled-->Enabled Pending\n");
   1202         BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_ENABLE_PENDING);
   1203         // Skip the event notification
   1204         bFlag = 0;
   1205       }
   1206     }
   1207     if(param1 == PORT_INDEX_OUT || param1 == OMX_ALL)
   1208     {
   1209       m_sOutPortDef.bEnabled = OMX_TRUE;
   1210 
   1211       if( (m_state == OMX_StateLoaded &&
   1212            !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
   1213           || (allocate_output_done()))
   1214       {
   1215         post_event(OMX_CommandPortEnable,PORT_INDEX_OUT,
   1216                    OMX_COMPONENT_GENERATE_EVENT);
   1217 
   1218       }
   1219       else
   1220       {
   1221         DEBUG_PRINT_LOW("OMXCORE-SM: Disabled-->Enabled Pending\n");
   1222         BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
   1223         // Skip the event notification
   1224         bFlag = 0;
   1225       }
   1226     }
   1227   }
   1228   else if(cmd == OMX_CommandPortDisable)
   1229   {
   1230     if(param1 == PORT_INDEX_IN || param1 == OMX_ALL)
   1231     {
   1232       m_sInPortDef.bEnabled = OMX_FALSE;
   1233       if((m_state == OMX_StateLoaded || m_state == OMX_StateIdle)
   1234          && release_input_done())
   1235       {
   1236         post_event(OMX_CommandPortDisable,PORT_INDEX_IN,
   1237                    OMX_COMPONENT_GENERATE_EVENT);
   1238       }
   1239       else
   1240       {
   1241         BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_DISABLE_PENDING);
   1242         if(m_state == OMX_StatePause ||m_state == OMX_StateExecuting)
   1243         {
   1244           execute_omx_flush(PORT_INDEX_IN);
   1245         }
   1246 
   1247         // Skip the event notification
   1248         bFlag = 0;
   1249       }
   1250     }
   1251     if(param1 == PORT_INDEX_OUT || param1 == OMX_ALL)
   1252     {
   1253       m_sOutPortDef.bEnabled = OMX_FALSE;
   1254 
   1255       if((m_state == OMX_StateLoaded || m_state == OMX_StateIdle)
   1256          && release_output_done())
   1257       {
   1258         post_event(OMX_CommandPortDisable,PORT_INDEX_OUT,\
   1259                    OMX_COMPONENT_GENERATE_EVENT);
   1260       }
   1261       else
   1262       {
   1263         BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
   1264         if(m_state == OMX_StatePause ||m_state == OMX_StateExecuting)
   1265         {
   1266           execute_omx_flush(PORT_INDEX_OUT);
   1267         }
   1268         // Skip the event notification
   1269         bFlag = 0;
   1270 
   1271       }
   1272     }
   1273   }
   1274   else
   1275   {
   1276     DEBUG_PRINT_ERROR("ERROR: Invalid Command received other than StateSet (%d)\n",cmd);
   1277     eRet = OMX_ErrorNotImplemented;
   1278   }
   1279   if(eRet == OMX_ErrorNone && bFlag)
   1280   {
   1281     post_event(cmd,eState,OMX_COMPONENT_GENERATE_EVENT);
   1282   }
   1283   sem_post(&m_cmd_lock);
   1284   return eRet;
   1285 }
   1286 
   1287 /* ======================================================================
   1288 FUNCTION
   1289   omx_venc::ExecuteOmxFlush
   1290 
   1291 DESCRIPTION
   1292   Executes the OMX flush.
   1293 
   1294 PARAMETERS
   1295   flushtype - input flush(1)/output flush(0)/ both.
   1296 
   1297 RETURN VALUE
   1298   true/false
   1299 
   1300 ========================================================================== */
   1301 bool omx_video::execute_omx_flush(OMX_U32 flushType)
   1302 {
   1303   bool bRet = false;
   1304   DEBUG_PRINT_LOW("\n execute_omx_flush -  %d\n", flushType);
   1305   if(flushType == 0 || flushType == OMX_ALL)
   1306   {
   1307     input_flush_progress = true;
   1308     //flush input only
   1309     bRet = execute_input_flush();
   1310   }
   1311   if(flushType == 1 || flushType == OMX_ALL)
   1312   {
   1313     //flush output only
   1314     output_flush_progress = true;
   1315     bRet = execute_output_flush();
   1316   }
   1317   return bRet;
   1318 }
   1319 /*=========================================================================
   1320 FUNCTION : execute_output_flush
   1321 
   1322 DESCRIPTION
   1323   Executes the OMX flush at OUTPUT PORT.
   1324 
   1325 PARAMETERS
   1326   None.
   1327 
   1328 RETURN VALUE
   1329   true/false
   1330 ==========================================================================*/
   1331 bool omx_video::execute_output_flush(void)
   1332 {
   1333   unsigned      p1 = 0; // Parameter - 1
   1334   unsigned      p2 = 0; // Parameter - 2
   1335   unsigned      ident = 0;
   1336   bool bRet = true;
   1337 
   1338   /*Generate FBD for all Buffers in the FTBq*/
   1339   DEBUG_PRINT_LOW("\n execute_output_flush\n");
   1340   pthread_mutex_lock(&m_lock);
   1341   while(m_ftb_q.m_size)
   1342   {
   1343     m_ftb_q.pop_entry(&p1,&p2,&ident);
   1344 
   1345     if(ident == OMX_COMPONENT_GENERATE_FTB )
   1346     {
   1347       pending_output_buffers++;
   1348       fill_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p2);
   1349     }
   1350     else if(ident == OMX_COMPONENT_GENERATE_FBD)
   1351     {
   1352       fill_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p1);
   1353     }
   1354   }
   1355 
   1356   pthread_mutex_unlock(&m_lock);
   1357   /*Check if there are buffers with the Driver*/
   1358   if(dev_flush(PORT_INDEX_OUT))
   1359   {
   1360     DEBUG_PRINT_ERROR("\nERROR: o/p dev_flush() Failed");
   1361     return false;
   1362   }
   1363 
   1364   return bRet;
   1365 }
   1366 /*=========================================================================
   1367 FUNCTION : execute_input_flush
   1368 
   1369 DESCRIPTION
   1370   Executes the OMX flush at INPUT PORT.
   1371 
   1372 PARAMETERS
   1373   None.
   1374 
   1375 RETURN VALUE
   1376   true/false
   1377 ==========================================================================*/
   1378 bool omx_video::execute_input_flush(void)
   1379 {
   1380   unsigned      p1 = 0; // Parameter - 1
   1381   unsigned      p2 = 0; // Parameter - 2
   1382   unsigned      ident = 0;
   1383   bool bRet = true;
   1384 
   1385   /*Generate EBD for all Buffers in the ETBq*/
   1386   DEBUG_PRINT_LOW("\n execute_input_flush\n");
   1387 
   1388   pthread_mutex_lock(&m_lock);
   1389   while(m_etb_q.m_size)
   1390   {
   1391     m_etb_q.pop_entry(&p1,&p2,&ident);
   1392     if(ident == OMX_COMPONENT_GENERATE_ETB)
   1393     {
   1394       pending_input_buffers++;
   1395       empty_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p2);
   1396     }
   1397     else if(ident == OMX_COMPONENT_GENERATE_EBD)
   1398     {
   1399       empty_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p1);
   1400     }
   1401     else if(ident == OMX_COMPONENT_GENERATE_ETB_OPQ)
   1402     {
   1403       m_pCallbacks.EmptyBufferDone(&m_cmp,m_app_data,(OMX_BUFFERHEADERTYPE *)p2);
   1404     }
   1405   }
   1406   if(mUseProxyColorFormat) {
   1407     if(psource_frame) {
   1408       m_pCallbacks.EmptyBufferDone(&m_cmp,m_app_data,psource_frame);
   1409       psource_frame = NULL;
   1410     }
   1411     while(m_opq_meta_q.m_size) {
   1412       unsigned p1,p2,id;
   1413       m_opq_meta_q.pop_entry(&p1,&p2,&id);
   1414       m_pCallbacks.EmptyBufferDone(&m_cmp,m_app_data,
   1415          (OMX_BUFFERHEADERTYPE  *)p1);
   1416     }
   1417     if(pdest_frame){
   1418       m_opq_pmem_q.insert_entry((unsigned int)pdest_frame,0,0);
   1419       pdest_frame = NULL;
   1420     }
   1421   }
   1422   pthread_mutex_unlock(&m_lock);
   1423   /*Check if there are buffers with the Driver*/
   1424   if(dev_flush(PORT_INDEX_IN))
   1425   {
   1426     DEBUG_PRINT_ERROR("\nERROR: i/p dev_flush() Failed");
   1427     return false;
   1428   }
   1429 
   1430   return bRet;
   1431 }
   1432 
   1433 
   1434 /* ======================================================================
   1435 FUNCTION
   1436   omx_venc::SendCommandEvent
   1437 
   1438 DESCRIPTION
   1439   Send the event to decoder pipe.  This is needed to generate the callbacks
   1440   in decoder thread context.
   1441 
   1442 PARAMETERS
   1443   None.
   1444 
   1445 RETURN VALUE
   1446   true/false
   1447 
   1448 ========================================================================== */
   1449 bool omx_video::post_event(unsigned int p1,
   1450                            unsigned int p2,
   1451                            unsigned int id)
   1452 {
   1453   bool bRet      =                      false;
   1454 
   1455 
   1456   pthread_mutex_lock(&m_lock);
   1457 
   1458   if( id == OMX_COMPONENT_GENERATE_FTB || \
   1459       (id == OMX_COMPONENT_GENERATE_FRAME_DONE))
   1460   {
   1461     m_ftb_q.insert_entry(p1,p2,id);
   1462   }
   1463   else if((id == m_input_msg_id) \
   1464           || (id == OMX_COMPONENT_GENERATE_EBD))
   1465   {
   1466     m_etb_q.insert_entry(p1,p2,id);
   1467   }
   1468   else
   1469   {
   1470     m_cmd_q.insert_entry(p1,p2,id);
   1471   }
   1472 
   1473   bRet = true;
   1474   DEBUG_PRINT_LOW("\n Value of this pointer in post_event %p",this);
   1475   post_message(this, id);
   1476   pthread_mutex_unlock(&m_lock);
   1477 
   1478   return bRet;
   1479 }
   1480 
   1481 /* ======================================================================
   1482 FUNCTION
   1483   omx_venc::GetParameter
   1484 
   1485 DESCRIPTION
   1486   OMX Get Parameter method implementation
   1487 
   1488 PARAMETERS
   1489   <TBD>.
   1490 
   1491 RETURN VALUE
   1492   Error None if successful.
   1493 
   1494 ========================================================================== */
   1495 OMX_ERRORTYPE  omx_video::get_parameter(OMX_IN OMX_HANDLETYPE     hComp,
   1496                                         OMX_IN OMX_INDEXTYPE paramIndex,
   1497                                         OMX_INOUT OMX_PTR     paramData)
   1498 {
   1499   OMX_ERRORTYPE eRet = OMX_ErrorNone;
   1500   unsigned int height=0,width = 0;
   1501 
   1502   DEBUG_PRINT_LOW("get_parameter: \n");
   1503   if(m_state == OMX_StateInvalid)
   1504   {
   1505     DEBUG_PRINT_ERROR("ERROR: Get Param in Invalid State\n");
   1506     return OMX_ErrorInvalidState;
   1507   }
   1508   if(paramData == NULL)
   1509   {
   1510     DEBUG_PRINT_ERROR("ERROR: Get Param in Invalid paramData \n");
   1511     return OMX_ErrorBadParameter;
   1512   }
   1513   switch(paramIndex)
   1514   {
   1515   case OMX_IndexParamPortDefinition:
   1516     {
   1517       OMX_PARAM_PORTDEFINITIONTYPE *portDefn;
   1518       portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData;
   1519 
   1520       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamPortDefinition\n");
   1521       if(portDefn->nPortIndex == (OMX_U32) PORT_INDEX_IN)
   1522       {
   1523         DEBUG_PRINT_LOW("m_sInPortDef: size = %d, min cnt = %d, actual cnt = %d",
   1524             m_sInPortDef.nBufferSize, m_sInPortDef.nBufferCountMin,
   1525             m_sInPortDef.nBufferCountActual);
   1526         memcpy(portDefn, &m_sInPortDef, sizeof(m_sInPortDef));
   1527 #ifdef _ANDROID_ICS_
   1528         if(meta_mode_enable)
   1529         {
   1530           portDefn->nBufferSize = sizeof(encoder_media_buffer_type);
   1531         }
   1532         if(secure_session) {
   1533           portDefn->format.video.eColorFormat =
   1534             (OMX_COLOR_FORMATTYPE)secure_color_format;
   1535         }
   1536         else if (mUseProxyColorFormat) {
   1537             portDefn->format.video.eColorFormat =
   1538               (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque;
   1539         }
   1540 #endif
   1541       }
   1542       else if(portDefn->nPortIndex == (OMX_U32) PORT_INDEX_OUT)
   1543       {
   1544         dev_get_buf_req (&m_sOutPortDef.nBufferCountMin,
   1545                          &m_sOutPortDef.nBufferCountActual,
   1546                          &m_sOutPortDef.nBufferSize,
   1547                          m_sOutPortDef.nPortIndex);
   1548         DEBUG_PRINT_LOW("m_sOutPortDef: size = %d, min cnt = %d, actual cnt = %d",
   1549             m_sOutPortDef.nBufferSize, m_sOutPortDef.nBufferCountMin,
   1550             m_sOutPortDef.nBufferCountActual);
   1551         memcpy(portDefn, &m_sOutPortDef, sizeof(m_sOutPortDef));
   1552       }
   1553       else
   1554       {
   1555         DEBUG_PRINT_ERROR("ERROR: GetParameter called on Bad Port Index");
   1556         eRet = OMX_ErrorBadPortIndex;
   1557       }
   1558       break;
   1559     }
   1560   case OMX_IndexParamVideoInit:
   1561     {
   1562       OMX_PORT_PARAM_TYPE *portParamType =
   1563       (OMX_PORT_PARAM_TYPE *) paramData;
   1564       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoInit\n");
   1565 
   1566       memcpy(portParamType, &m_sPortParam, sizeof(m_sPortParam));
   1567       break;
   1568     }
   1569   case OMX_IndexParamVideoPortFormat:
   1570     {
   1571       OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt =
   1572       (OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData;
   1573       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoPortFormat\n");
   1574 
   1575       if(portFmt->nPortIndex == (OMX_U32) PORT_INDEX_IN)
   1576       {
   1577           int index = portFmt->nIndex;
   1578 
   1579           if (index > 1) {
   1580               eRet = OMX_ErrorNoMore;
   1581           } else {
   1582               memcpy(portFmt, &m_sInPortFormat, sizeof(m_sInPortFormat));
   1583 #ifdef _ANDROID_ICS_
   1584               if (index == 1) {
   1585                   //we support two formats
   1586                   //index 0 - YUV420SP
   1587                   //index 1 - opaque which internally maps to YUV420SP.
   1588                   //this can be extended in the future
   1589                   portFmt->nIndex = index; //restore index set from client
   1590                   portFmt->eColorFormat =
   1591                     (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque;
   1592               }
   1593           }
   1594 #endif
   1595       }
   1596       else if(portFmt->nPortIndex == (OMX_U32) PORT_INDEX_OUT)
   1597       {
   1598         memcpy(portFmt, &m_sOutPortFormat, sizeof(m_sOutPortFormat));
   1599       }
   1600       else
   1601       {
   1602         DEBUG_PRINT_ERROR("ERROR: GetParameter called on Bad Port Index");
   1603         eRet = OMX_ErrorBadPortIndex;
   1604       }
   1605       break;
   1606     }
   1607   case OMX_IndexParamVideoBitrate:
   1608     {
   1609       OMX_VIDEO_PARAM_BITRATETYPE* pParam = (OMX_VIDEO_PARAM_BITRATETYPE*)paramData;
   1610       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoBitrate\n");
   1611 
   1612       if(pParam->nPortIndex == (OMX_U32) PORT_INDEX_OUT)
   1613       {
   1614         memcpy(pParam, &m_sParamBitrate, sizeof(m_sParamBitrate));
   1615       }
   1616       else
   1617       {
   1618         DEBUG_PRINT_ERROR("ERROR: GetParameter called on Bad Port Index");
   1619         eRet = OMX_ErrorBadPortIndex;
   1620       }
   1621 
   1622       break;
   1623     }
   1624   case OMX_IndexParamVideoMpeg4:
   1625     {
   1626       OMX_VIDEO_PARAM_MPEG4TYPE* pParam = (OMX_VIDEO_PARAM_MPEG4TYPE*)paramData;
   1627       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoMpeg4\n");
   1628       memcpy(pParam, &m_sParamMPEG4, sizeof(m_sParamMPEG4));
   1629       break;
   1630     }
   1631   case OMX_IndexParamVideoH263:
   1632     {
   1633       OMX_VIDEO_PARAM_H263TYPE* pParam = (OMX_VIDEO_PARAM_H263TYPE*)paramData;
   1634       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoH263\n");
   1635       memcpy(pParam, &m_sParamH263, sizeof(m_sParamH263));
   1636       break;
   1637     }
   1638   case OMX_IndexParamVideoAvc:
   1639     {
   1640       OMX_VIDEO_PARAM_AVCTYPE* pParam = (OMX_VIDEO_PARAM_AVCTYPE*)paramData;
   1641       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoAvc\n");
   1642       memcpy(pParam, &m_sParamAVC, sizeof(m_sParamAVC));
   1643       break;
   1644     }
   1645   case OMX_IndexParamVideoProfileLevelQuerySupported:
   1646     {
   1647       OMX_VIDEO_PARAM_PROFILELEVELTYPE* pParam = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)paramData;
   1648       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported\n");
   1649       eRet = get_supported_profile_level(pParam);
   1650       if(eRet)
   1651         DEBUG_PRINT_ERROR("Invalid entry returned from get_supported_profile_level %d, %d",
   1652                           pParam->eProfile, pParam->eLevel);
   1653       break;
   1654      }
   1655   case OMX_IndexParamVideoProfileLevelCurrent:
   1656     {
   1657       OMX_VIDEO_PARAM_PROFILELEVELTYPE* pParam = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)paramData;
   1658       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoProfileLevelCurrent\n");
   1659       memcpy(pParam, &m_sParamProfileLevel, sizeof(m_sParamProfileLevel));
   1660       break;
   1661     }
   1662     /*Component should support this port definition*/
   1663   case OMX_IndexParamAudioInit:
   1664     {
   1665       OMX_PORT_PARAM_TYPE *audioPortParamType = (OMX_PORT_PARAM_TYPE *) paramData;
   1666       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamAudioInit\n");
   1667       memcpy(audioPortParamType, &m_sPortParam_audio, sizeof(m_sPortParam_audio));
   1668       break;
   1669     }
   1670     /*Component should support this port definition*/
   1671   case OMX_IndexParamImageInit:
   1672     {
   1673       OMX_PORT_PARAM_TYPE *imagePortParamType = (OMX_PORT_PARAM_TYPE *) paramData;
   1674       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamImageInit\n");
   1675       memcpy(imagePortParamType, &m_sPortParam_img, sizeof(m_sPortParam_img));
   1676       break;
   1677 
   1678     }
   1679     /*Component should support this port definition*/
   1680   case OMX_IndexParamOtherInit:
   1681     {
   1682       DEBUG_PRINT_ERROR("ERROR: get_parameter: OMX_IndexParamOtherInit %08x\n", paramIndex);
   1683       eRet =OMX_ErrorUnsupportedIndex;
   1684       break;
   1685     }
   1686   case OMX_IndexParamStandardComponentRole:
   1687     {
   1688       OMX_PARAM_COMPONENTROLETYPE *comp_role;
   1689       comp_role = (OMX_PARAM_COMPONENTROLETYPE *) paramData;
   1690       comp_role->nVersion.nVersion = OMX_SPEC_VERSION;
   1691       comp_role->nSize = sizeof(*comp_role);
   1692 
   1693       DEBUG_PRINT_LOW("Getparameter: OMX_IndexParamStandardComponentRole %d\n",paramIndex);
   1694       if(NULL != comp_role->cRole)
   1695       {
   1696         strlcpy((char*)comp_role->cRole,(const char*)m_cRole,OMX_MAX_STRINGNAME_SIZE);
   1697       }
   1698       else
   1699       {
   1700         DEBUG_PRINT_ERROR("ERROR: Getparameter: OMX_IndexParamStandardComponentRole %d is passed with NULL parameter for role\n",paramIndex);
   1701         eRet =OMX_ErrorBadParameter;
   1702       }
   1703       break;
   1704     }
   1705     /* Added for parameter test */
   1706   case OMX_IndexParamPriorityMgmt:
   1707     {
   1708 
   1709       OMX_PRIORITYMGMTTYPE *priorityMgmType = (OMX_PRIORITYMGMTTYPE *) paramData;
   1710       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamPriorityMgmt\n");
   1711       memcpy(priorityMgmType, &m_sPriorityMgmt, sizeof(m_sPriorityMgmt));
   1712       break;
   1713     }
   1714     /* Added for parameter test */
   1715   case OMX_IndexParamCompBufferSupplier:
   1716     {
   1717       OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData;
   1718       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamCompBufferSupplier\n");
   1719       if(bufferSupplierType->nPortIndex ==(OMX_U32) PORT_INDEX_IN)
   1720       {
   1721         memcpy(bufferSupplierType, &m_sInBufSupplier, sizeof(m_sInBufSupplier));
   1722       }
   1723       else if(bufferSupplierType->nPortIndex ==(OMX_U32) PORT_INDEX_OUT)
   1724       {
   1725         memcpy(bufferSupplierType, &m_sOutBufSupplier, sizeof(m_sOutBufSupplier));
   1726       }
   1727       else
   1728       {
   1729         DEBUG_PRINT_ERROR("ERROR: GetParameter called on Bad Port Index");
   1730         eRet = OMX_ErrorBadPortIndex;
   1731       }
   1732       break;
   1733     }
   1734 
   1735   case OMX_IndexParamVideoQuantization:
   1736     {
   1737       OMX_VIDEO_PARAM_QUANTIZATIONTYPE *session_qp = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE*) paramData;
   1738       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoQuantization\n");
   1739       memcpy(session_qp, &m_sSessionQuantization, sizeof(m_sSessionQuantization));
   1740       break;
   1741     }
   1742 
   1743     case OMX_IndexParamVideoErrorCorrection:
   1744     {
   1745       OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE* errorresilience = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE*)paramData;
   1746       DEBUG_PRINT_LOW("OMX_IndexParamVideoErrorCorrection\n");
   1747       errorresilience->bEnableHEC = m_sErrorCorrection.bEnableHEC;
   1748       errorresilience->bEnableResync = m_sErrorCorrection.bEnableResync;
   1749       errorresilience->nResynchMarkerSpacing = m_sErrorCorrection.nResynchMarkerSpacing;
   1750       break;
   1751     }
   1752   case OMX_IndexParamVideoIntraRefresh:
   1753     {
   1754       OMX_VIDEO_PARAM_INTRAREFRESHTYPE* intrarefresh = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE*)paramData;
   1755       DEBUG_PRINT_LOW("OMX_IndexParamVideoIntraRefresh\n");
   1756       DEBUG_PRINT_ERROR("OMX_IndexParamVideoIntraRefresh GET\n");
   1757       intrarefresh->eRefreshMode = m_sIntraRefresh.eRefreshMode;
   1758       intrarefresh->nCirMBs = m_sIntraRefresh.nCirMBs;
   1759       break;
   1760     }
   1761   case OMX_QcomIndexPortDefn:
   1762     //TODO
   1763     break;
   1764   case OMX_COMPONENT_CAPABILITY_TYPE_INDEX:
   1765    {
   1766         OMXComponentCapabilityFlagsType *pParam = reinterpret_cast<OMXComponentCapabilityFlagsType*>(paramData);
   1767         DEBUG_PRINT_LOW("get_parameter: OMX_COMPONENT_CAPABILITY_TYPE_INDEX\n");
   1768         pParam->iIsOMXComponentMultiThreaded = OMX_TRUE;
   1769         pParam->iOMXComponentSupportsExternalOutputBufferAlloc = OMX_FALSE;
   1770         pParam->iOMXComponentSupportsExternalInputBufferAlloc = OMX_TRUE;
   1771         pParam->iOMXComponentSupportsMovableInputBuffers = OMX_TRUE;
   1772         pParam->iOMXComponentUsesNALStartCodes = OMX_TRUE;
   1773         pParam->iOMXComponentSupportsPartialFrames = OMX_FALSE;
   1774         pParam->iOMXComponentCanHandleIncompleteFrames = OMX_FALSE;
   1775         pParam->iOMXComponentUsesFullAVCFrames = OMX_FALSE;
   1776         m_use_input_pmem = OMX_TRUE;
   1777         DEBUG_PRINT_LOW("Supporting capability index in encoder node");
   1778         break;
   1779    }
   1780 #ifndef MAX_RES_720P
   1781   case OMX_QcomIndexParamIndexExtraDataType:
   1782     {
   1783       DEBUG_PRINT_LOW("get_parameter: OMX_QcomIndexParamIndexExtraDataType");
   1784       QOMX_INDEXEXTRADATATYPE *pParam = (QOMX_INDEXEXTRADATATYPE *)paramData;
   1785       if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderSliceInfo)
   1786       {
   1787         if (pParam->nPortIndex == PORT_INDEX_OUT)
   1788         {
   1789           pParam->bEnabled =
   1790              (OMX_BOOL)((m_sExtraData & VEN_EXTRADATA_SLICEINFO) ? 1 : 0);
   1791           DEBUG_PRINT_HIGH("Slice Info extradata %d", pParam->bEnabled);
   1792         }
   1793         else
   1794         {
   1795           DEBUG_PRINT_ERROR("get_parameter: slice information is "
   1796               "valid for output port only");
   1797           eRet =OMX_ErrorUnsupportedIndex;
   1798         }
   1799       }
   1800       else
   1801       {
   1802         DEBUG_PRINT_ERROR("get_parameter: unsupported index (%x), "
   1803             "only slice information extradata is supported", pParam->nIndex);
   1804         eRet =OMX_ErrorUnsupportedIndex;
   1805       }
   1806       break;
   1807     }
   1808 #endif
   1809   case QOMX_IndexParamVideoSyntaxHdr:
   1810     {
   1811        DEBUG_PRINT_HIGH("QOMX_IndexParamVideoSyntaxHdr");
   1812        QOMX_EXTNINDEX_PARAMTYPE* pParam =
   1813           reinterpret_cast<QOMX_EXTNINDEX_PARAMTYPE*>(paramData);
   1814        BITMASK_SET(&m_flags, OMX_COMPONENT_LOADED_START_PENDING);
   1815        if(dev_loaded_start())
   1816        {
   1817          DEBUG_PRINT_LOW("device start successful");
   1818        }
   1819        else
   1820        {
   1821          DEBUG_PRINT_ERROR("device start failed");
   1822          BITMASK_CLEAR(&m_flags, OMX_COMPONENT_LOADED_START_PENDING);
   1823          return OMX_ErrorHardware;
   1824        }
   1825        if(dev_get_seq_hdr(pParam->pData,
   1826             (unsigned)(pParam->nSize - sizeof(QOMX_EXTNINDEX_PARAMTYPE)),
   1827             (unsigned *)&pParam->nDataSize))
   1828        {
   1829          DEBUG_PRINT_HIGH("get syntax header successful (hdrlen = %d)",
   1830             pParam->nDataSize);
   1831          for (unsigned i = 0; i < pParam->nDataSize; i++) {
   1832            DEBUG_PRINT_LOW("Header[%d] = %x", i, *((char *)pParam->pData + i));
   1833          }
   1834        }
   1835        else
   1836        {
   1837          DEBUG_PRINT_ERROR("Error returned from GetSyntaxHeader()");
   1838          eRet = OMX_ErrorHardware;
   1839        }
   1840        BITMASK_SET(&m_flags, OMX_COMPONENT_LOADED_STOP_PENDING);
   1841        if(dev_loaded_stop())
   1842        {
   1843          DEBUG_PRINT_LOW("device stop successful");
   1844        }
   1845        else
   1846        {
   1847          DEBUG_PRINT_ERROR("device stop failed");
   1848          BITMASK_CLEAR(&m_flags, OMX_COMPONENT_LOADED_STOP_PENDING);
   1849          eRet = OMX_ErrorHardware;
   1850        }
   1851        break;
   1852     }
   1853   case OMX_IndexParamVideoSliceFMO:
   1854   default:
   1855     {
   1856       DEBUG_PRINT_ERROR("ERROR: get_parameter: unknown param %08x\n", paramIndex);
   1857       eRet =OMX_ErrorUnsupportedIndex;
   1858       break;
   1859     }
   1860 
   1861   }
   1862 
   1863   return eRet;
   1864 
   1865 }
   1866 /* ======================================================================
   1867 FUNCTION
   1868   omx_video::GetConfig
   1869 
   1870 DESCRIPTION
   1871   OMX Get Config Method implementation.
   1872 
   1873 PARAMETERS
   1874   <TBD>.
   1875 
   1876 RETURN VALUE
   1877   OMX Error None if successful.
   1878 
   1879 ========================================================================== */
   1880 OMX_ERRORTYPE  omx_video::get_config(OMX_IN OMX_HANDLETYPE      hComp,
   1881                                      OMX_IN OMX_INDEXTYPE configIndex,
   1882                                      OMX_INOUT OMX_PTR     configData)
   1883 {
   1884   ////////////////////////////////////////////////////////////////
   1885   // Supported Config Index           Type
   1886   // =============================================================
   1887   // OMX_IndexConfigVideoBitrate      OMX_VIDEO_CONFIG_BITRATETYPE
   1888   // OMX_IndexConfigVideoFramerate    OMX_CONFIG_FRAMERATETYPE
   1889   // OMX_IndexConfigCommonRotate      OMX_CONFIG_ROTATIONTYPE
   1890   ////////////////////////////////////////////////////////////////
   1891 
   1892   if(configData == NULL)
   1893   {
   1894     DEBUG_PRINT_ERROR("ERROR: param is null");
   1895     return OMX_ErrorBadParameter;
   1896   }
   1897 
   1898   if(m_state == OMX_StateInvalid)
   1899   {
   1900     DEBUG_PRINT_ERROR("ERROR: can't be in invalid state");
   1901     return OMX_ErrorIncorrectStateOperation;
   1902   }
   1903 
   1904   //@todo need to validate params
   1905   switch(configIndex)
   1906   {
   1907   case OMX_IndexConfigVideoBitrate:
   1908     {
   1909       OMX_VIDEO_CONFIG_BITRATETYPE* pParam = reinterpret_cast<OMX_VIDEO_CONFIG_BITRATETYPE*>(configData);
   1910       memcpy(pParam, &m_sConfigBitrate, sizeof(m_sConfigBitrate));
   1911       break;
   1912     }
   1913   case OMX_IndexConfigVideoFramerate:
   1914     {
   1915       OMX_CONFIG_FRAMERATETYPE* pParam = reinterpret_cast<OMX_CONFIG_FRAMERATETYPE*>(configData);
   1916       memcpy(pParam, &m_sConfigFramerate, sizeof(m_sConfigFramerate));
   1917       break;
   1918     }
   1919   case OMX_IndexConfigCommonRotate:
   1920     {
   1921       OMX_CONFIG_ROTATIONTYPE* pParam = reinterpret_cast<OMX_CONFIG_ROTATIONTYPE*>(configData);
   1922       memcpy(pParam, &m_sConfigFrameRotation, sizeof(m_sConfigFrameRotation));
   1923       break;
   1924     }
   1925   case QOMX_IndexConfigVideoIntraperiod:
   1926     {
   1927       DEBUG_PRINT_LOW("get_config:QOMX_IndexConfigVideoIntraperiod\n");
   1928       QOMX_VIDEO_INTRAPERIODTYPE* pParam = reinterpret_cast<QOMX_VIDEO_INTRAPERIODTYPE*>(configData);
   1929       memcpy(pParam, &m_sIntraperiod, sizeof(m_sIntraperiod));
   1930       break;
   1931     }
   1932   default:
   1933     DEBUG_PRINT_ERROR("ERROR: unsupported index %d", (int) configIndex);
   1934     return OMX_ErrorUnsupportedIndex;
   1935   }
   1936   return OMX_ErrorNone;
   1937 
   1938 }
   1939 
   1940 /* ======================================================================
   1941 FUNCTION
   1942   omx_video::GetExtensionIndex
   1943 
   1944 DESCRIPTION
   1945   OMX GetExtensionIndex method implementaion.  <TBD>
   1946 
   1947 PARAMETERS
   1948   <TBD>.
   1949 
   1950 RETURN VALUE
   1951   OMX Error None if everything successful.
   1952 
   1953 ========================================================================== */
   1954 OMX_ERRORTYPE  omx_video::get_extension_index(OMX_IN OMX_HANDLETYPE      hComp,
   1955                                               OMX_IN OMX_STRING      paramName,
   1956                                               OMX_OUT OMX_INDEXTYPE* indexType)
   1957 {
   1958   char *extns[] = {
   1959     "OMX.QCOM.index.param.SliceDeliveryMode",
   1960     "OMX.google.android.index.storeMetaDataInBuffers",
   1961     "OMX.google.android.index.prependSPSPPSToIDRFrames",
   1962     "OMX.google.android.index.setVUIStreamRestrictFlag"
   1963   };
   1964 
   1965   if(m_state == OMX_StateInvalid)
   1966   {
   1967     DEBUG_PRINT_ERROR("ERROR: Get Extension Index in Invalid State\n");
   1968     return OMX_ErrorInvalidState;
   1969   }
   1970 #ifdef MAX_RES_1080P
   1971   if (!strncmp(paramName, extns[0], strlen(extns[0]))) {
   1972     *indexType = (OMX_INDEXTYPE)OMX_QcomIndexEnableSliceDeliveryMode;
   1973     return OMX_ErrorNone;
   1974   }
   1975 #endif
   1976 #ifdef _ANDROID_ICS_
   1977   if (!strncmp(paramName, extns[1], strlen(extns[1]))) {
   1978         *indexType = (OMX_INDEXTYPE)OMX_QcomIndexParamVideoMetaBufferMode;
   1979         return OMX_ErrorNone;
   1980   } else if (!strncmp(paramName, extns[2], strlen(extns[2]))) {
   1981         *indexType = (OMX_INDEXTYPE)OMX_QcomIndexParamSequenceHeaderWithIDR;
   1982         return OMX_ErrorNone;
   1983   } else if (!strncmp(paramName, extns[3], strlen(extns[3]))) {
   1984         *indexType = (OMX_INDEXTYPE)OMX_QcomIndexParamEnableVUIStreamRestrictFlag;
   1985         return OMX_ErrorNone;
   1986   }
   1987 #endif
   1988   return OMX_ErrorNotImplemented;
   1989 }
   1990 
   1991 /* ======================================================================
   1992 FUNCTION
   1993   omx_video::GetState
   1994 
   1995 DESCRIPTION
   1996   Returns the state information back to the caller.<TBD>
   1997 
   1998 PARAMETERS
   1999   <TBD>.
   2000 
   2001 RETURN VALUE
   2002   Error None if everything is successful.
   2003 ========================================================================== */
   2004 OMX_ERRORTYPE  omx_video::get_state(OMX_IN OMX_HANDLETYPE  hComp,
   2005                                     OMX_OUT OMX_STATETYPE* state)
   2006 {
   2007   *state = m_state;
   2008   DEBUG_PRINT_LOW("get_state: Returning the state %d\n",*state);
   2009   return OMX_ErrorNone;
   2010 }
   2011 
   2012 /* ======================================================================
   2013 FUNCTION
   2014   omx_video::ComponentTunnelRequest
   2015 
   2016 DESCRIPTION
   2017   OMX Component Tunnel Request method implementation. <TBD>
   2018 
   2019 PARAMETERS
   2020   None.
   2021 
   2022 RETURN VALUE
   2023   OMX Error None if everything successful.
   2024 
   2025 ========================================================================== */
   2026 OMX_ERRORTYPE  omx_video::component_tunnel_request(OMX_IN OMX_HANDLETYPE                hComp,
   2027                                                    OMX_IN OMX_U32                        port,
   2028                                                    OMX_IN OMX_HANDLETYPE        peerComponent,
   2029                                                    OMX_IN OMX_U32                    peerPort,
   2030                                                    OMX_INOUT OMX_TUNNELSETUPTYPE* tunnelSetup)
   2031 {
   2032   DEBUG_PRINT_ERROR("ERROR: component_tunnel_request Not Implemented\n");
   2033   return OMX_ErrorNotImplemented;
   2034 }
   2035 
   2036 /* ======================================================================
   2037 FUNCTION
   2038   omx_video::UseInputBuffer
   2039 
   2040 DESCRIPTION
   2041   Helper function for Use buffer in the input pin
   2042 
   2043 PARAMETERS
   2044   None.
   2045 
   2046 RETURN VALUE
   2047   true/false
   2048 
   2049 ========================================================================== */
   2050 OMX_ERRORTYPE  omx_video::use_input_buffer(
   2051                                           OMX_IN OMX_HANDLETYPE            hComp,
   2052                                           OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
   2053                                           OMX_IN OMX_U32                   port,
   2054                                           OMX_IN OMX_PTR                   appData,
   2055                                           OMX_IN OMX_U32                   bytes,
   2056                                           OMX_IN OMX_U8*                   buffer)
   2057 {
   2058   OMX_ERRORTYPE eRet = OMX_ErrorNone;
   2059 
   2060   unsigned   i = 0;
   2061   unsigned char *buf_addr = NULL;
   2062 
   2063   DEBUG_PRINT_HIGH("use_input_buffer: port = %d appData = %p bytes = %d buffer = %p",port,appData,bytes,buffer);
   2064   if(bytes != m_sInPortDef.nBufferSize || secure_session)
   2065   {
   2066     DEBUG_PRINT_ERROR("\nERROR: use_input_buffer: Size Mismatch!! "
   2067                       "bytes[%d] != Port.nBufferSize[%d]", bytes, m_sInPortDef.nBufferSize);
   2068     return OMX_ErrorBadParameter;
   2069   }
   2070 
   2071   if(!m_inp_mem_ptr)
   2072   {
   2073     input_use_buffer = true;
   2074     m_inp_mem_ptr = (OMX_BUFFERHEADERTYPE*) \
   2075                     calloc( (sizeof(OMX_BUFFERHEADERTYPE)), m_sInPortDef.nBufferCountActual);
   2076     if(m_inp_mem_ptr == NULL)
   2077     {
   2078       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_inp_mem_ptr");
   2079       return OMX_ErrorInsufficientResources;
   2080     }
   2081 
   2082 
   2083     m_pInput_pmem = (struct pmem *) calloc(sizeof (struct pmem), m_sInPortDef.nBufferCountActual);
   2084     if(m_pInput_pmem == NULL)
   2085     {
   2086       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_pInput_pmem");
   2087       return OMX_ErrorInsufficientResources;
   2088     }
   2089 #ifdef USE_ION
   2090     m_pInput_ion = (struct venc_ion *) calloc(sizeof (struct venc_ion), m_sInPortDef.nBufferCountActual);
   2091     if(m_pInput_ion == NULL)
   2092     {
   2093       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_pInput_ion");
   2094       return OMX_ErrorInsufficientResources;
   2095     }
   2096 #endif
   2097 
   2098     for(i=0; i< m_sInPortDef.nBufferCountActual; i++)
   2099     {
   2100       m_pInput_pmem[i].fd = -1;
   2101 #ifdef USE_ION
   2102       m_pInput_ion[i].ion_device_fd =-1;
   2103       m_pInput_ion[i].fd_ion_data.fd =-1;
   2104       m_pInput_ion[i].ion_alloc_data.handle=NULL;
   2105 #endif
   2106     }
   2107 
   2108   }
   2109 
   2110   for(i=0; i< m_sInPortDef.nBufferCountActual; i++)
   2111   {
   2112     if(BITMASK_ABSENT(&m_inp_bm_count,i))
   2113     {
   2114       break;
   2115     }
   2116   }
   2117 
   2118   if(i < m_sInPortDef.nBufferCountActual)
   2119   {
   2120 
   2121     *bufferHdr = (m_inp_mem_ptr + i);
   2122     BITMASK_SET(&m_inp_bm_count,i);
   2123 
   2124     (*bufferHdr)->pBuffer           = (OMX_U8 *)buffer;
   2125     (*bufferHdr)->nSize             = sizeof(OMX_BUFFERHEADERTYPE);
   2126     (*bufferHdr)->nVersion.nVersion = OMX_SPEC_VERSION;
   2127     (*bufferHdr)->nAllocLen         = m_sInPortDef.nBufferSize;
   2128     (*bufferHdr)->pAppPrivate       = appData;
   2129     (*bufferHdr)->nInputPortIndex   = PORT_INDEX_IN;
   2130 
   2131     if(!m_use_input_pmem)
   2132     {
   2133 #ifdef USE_ION
   2134       m_pInput_ion[i].ion_device_fd = alloc_map_ion_memory(m_sInPortDef.nBufferSize,
   2135                                       &m_pInput_ion[i].ion_alloc_data,
   2136                                       &m_pInput_ion[i].fd_ion_data,ION_FLAG_CACHED);
   2137       if(m_pInput_ion[i].ion_device_fd < 0) {
   2138         DEBUG_PRINT_ERROR("\nERROR:ION device open() Failed");
   2139         return OMX_ErrorInsufficientResources;
   2140       }
   2141       m_pInput_pmem[i].fd = m_pInput_ion[i].fd_ion_data.fd;
   2142 #else
   2143       m_pInput_pmem[i].fd = open (MEM_DEVICE,O_RDWR);
   2144       if(m_pInput_pmem[i].fd == 0)
   2145       {
   2146         m_pInput_pmem[i].fd = open (MEM_DEVICE,O_RDWR);
   2147       }
   2148 
   2149       if(m_pInput_pmem[i] .fd < 0)
   2150       {
   2151         DEBUG_PRINT_ERROR("\nERROR: /dev/pmem_adsp open() Failed");
   2152         return OMX_ErrorInsufficientResources;
   2153       }
   2154 #endif
   2155       m_pInput_pmem[i].size = m_sInPortDef.nBufferSize;
   2156       m_pInput_pmem[i].offset = 0;
   2157       m_pInput_pmem[i].buffer = (unsigned char *)mmap(NULL,m_pInput_pmem[i].size,PROT_READ|PROT_WRITE,
   2158                                                       MAP_SHARED,m_pInput_pmem[i].fd,0);
   2159 
   2160       if(m_pInput_pmem[i].buffer == MAP_FAILED)
   2161       {
   2162         DEBUG_PRINT_ERROR("\nERROR: mmap() Failed");
   2163         close(m_pInput_pmem[i].fd);
   2164 #ifdef USE_ION
   2165         free_ion_memory(&m_pInput_ion[i]);
   2166 #endif
   2167         return OMX_ErrorInsufficientResources;
   2168       }
   2169     }
   2170     else
   2171     {
   2172       OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO *pParam = reinterpret_cast<OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO *>((*bufferHdr)->pAppPrivate);
   2173       DEBUG_PRINT_LOW("Inside qcom_ext with luma:(fd:%d,offset:0x%x)", pParam->pmem_fd, pParam->offset);
   2174 
   2175       if(pParam)
   2176       {
   2177         m_pInput_pmem[i].fd = pParam->pmem_fd;
   2178         m_pInput_pmem[i].offset = pParam->offset;
   2179         m_pInput_pmem[i].size = m_sInPortDef.nBufferSize;
   2180         m_pInput_pmem[i].buffer = (unsigned char *)buffer;
   2181         DEBUG_PRINT_LOW("\n DBG:: pParam->pmem_fd = %u, pParam->offset = %u",
   2182             pParam->pmem_fd, pParam->offset);
   2183       }
   2184       else
   2185       {
   2186         DEBUG_PRINT_ERROR("ERROR: Invalid AppData given for PMEM i/p UseBuffer case");
   2187         return OMX_ErrorBadParameter;
   2188       }
   2189     }
   2190 
   2191     DEBUG_PRINT_LOW("\nuse_inp:: bufhdr = %p, pBuffer = %p, m_pInput_pmem[i].buffer = %p",
   2192                 (*bufferHdr), (*bufferHdr)->pBuffer, m_pInput_pmem[i].buffer);
   2193     if( dev_use_buf(&m_pInput_pmem[i],PORT_INDEX_IN,i) != true)
   2194     {
   2195       DEBUG_PRINT_ERROR("\nERROR: dev_use_buf() Failed for i/p buf");
   2196       return OMX_ErrorInsufficientResources;
   2197     }
   2198   }
   2199   else
   2200   {
   2201     DEBUG_PRINT_ERROR("\nERROR: All buffers are already used, invalid use_buf call for "
   2202                       "index = %u", i);
   2203     eRet = OMX_ErrorInsufficientResources;
   2204   }
   2205 
   2206   return eRet;
   2207 }
   2208 
   2209 
   2210 
   2211 /* ======================================================================
   2212 FUNCTION
   2213   omx_video::UseOutputBuffer
   2214 
   2215 DESCRIPTION
   2216   Helper function for Use buffer in the input pin
   2217 
   2218 PARAMETERS
   2219   None.
   2220 
   2221 RETURN VALUE
   2222   true/false
   2223 
   2224 ========================================================================== */
   2225 OMX_ERRORTYPE  omx_video::use_output_buffer(
   2226                                            OMX_IN OMX_HANDLETYPE            hComp,
   2227                                            OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
   2228                                            OMX_IN OMX_U32                   port,
   2229                                            OMX_IN OMX_PTR                   appData,
   2230                                            OMX_IN OMX_U32                   bytes,
   2231                                            OMX_IN OMX_U8*                   buffer)
   2232 {
   2233   OMX_ERRORTYPE eRet = OMX_ErrorNone;
   2234   OMX_BUFFERHEADERTYPE       *bufHdr= NULL; // buffer header
   2235   unsigned                         i= 0; // Temporary counter
   2236   unsigned char *buf_addr = NULL;
   2237 
   2238   DEBUG_PRINT_HIGH("\n Inside use_output_buffer()");
   2239   if(bytes != m_sOutPortDef.nBufferSize || secure_session)
   2240   {
   2241     DEBUG_PRINT_ERROR("\nERROR: use_output_buffer: Size Mismatch!! "
   2242                       "bytes[%d] != Port.nBufferSize[%d]", bytes, m_sOutPortDef.nBufferSize);
   2243     return OMX_ErrorBadParameter;
   2244   }
   2245 
   2246   if(!m_out_mem_ptr)
   2247   {
   2248     output_use_buffer = true;
   2249     int nBufHdrSize        = 0;
   2250 
   2251     DEBUG_PRINT_LOW("Allocating First Output Buffer(%d)\n",m_sOutPortDef.nBufferCountActual);
   2252     nBufHdrSize        = m_sOutPortDef.nBufferCountActual * sizeof(OMX_BUFFERHEADERTYPE);
   2253     /*
   2254      * Memory for output side involves the following:
   2255      * 1. Array of Buffer Headers
   2256      * 2. Bitmask array to hold the buffer allocation details
   2257      * In order to minimize the memory management entire allocation
   2258      * is done in one step.
   2259      */
   2260     //OMX Buffer header
   2261     m_out_mem_ptr = (OMX_BUFFERHEADERTYPE  *)calloc(nBufHdrSize,1);
   2262     if(m_out_mem_ptr == NULL)
   2263     {
   2264       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_out_mem_ptr");
   2265       return OMX_ErrorInsufficientResources;
   2266     }
   2267 
   2268     m_pOutput_pmem = (struct pmem *) calloc(sizeof (struct pmem), m_sOutPortDef.nBufferCountActual);
   2269     if(m_pOutput_pmem == NULL)
   2270     {
   2271       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_pOutput_pmem");
   2272       return OMX_ErrorInsufficientResources;
   2273     }
   2274 #ifdef USE_ION
   2275     m_pOutput_ion = (struct venc_ion *) calloc(sizeof (struct venc_ion), m_sOutPortDef.nBufferCountActual);
   2276     if(m_pOutput_ion == NULL)
   2277     {
   2278       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_pOutput_ion");
   2279       return OMX_ErrorInsufficientResources;
   2280     }
   2281 #endif
   2282     if(m_out_mem_ptr)
   2283     {
   2284       bufHdr          =  m_out_mem_ptr;
   2285       DEBUG_PRINT_LOW("Memory Allocation Succeeded for OUT port%p\n",m_out_mem_ptr);
   2286       // Settting the entire storage nicely
   2287       for(i=0; i < m_sOutPortDef.nBufferCountActual ; i++)
   2288       {
   2289         bufHdr->nSize              = sizeof(OMX_BUFFERHEADERTYPE);
   2290         bufHdr->nVersion.nVersion  = OMX_SPEC_VERSION;
   2291         bufHdr->nAllocLen          = bytes;
   2292         bufHdr->nFilledLen         = 0;
   2293         bufHdr->pAppPrivate        = appData;
   2294         bufHdr->nOutputPortIndex   = PORT_INDEX_OUT;
   2295         bufHdr->pBuffer            = NULL;
   2296         bufHdr++;
   2297         m_pOutput_pmem[i].fd = -1;
   2298 #ifdef USE_ION
   2299         m_pOutput_ion[i].ion_device_fd =-1;
   2300         m_pOutput_ion[i].fd_ion_data.fd=-1;
   2301         m_pOutput_ion[i].ion_alloc_data.handle =NULL;
   2302 #endif
   2303       }
   2304     }
   2305     else
   2306     {
   2307       DEBUG_PRINT_ERROR("ERROR: Output buf mem alloc failed[0x%x]\n",m_out_mem_ptr);
   2308       eRet =  OMX_ErrorInsufficientResources;
   2309     }
   2310   }
   2311 
   2312   for(i=0; i< m_sOutPortDef.nBufferCountActual; i++)
   2313   {
   2314     if(BITMASK_ABSENT(&m_out_bm_count,i))
   2315     {
   2316       break;
   2317     }
   2318   }
   2319 
   2320   if(eRet == OMX_ErrorNone)
   2321   {
   2322     if(i < m_sOutPortDef.nBufferCountActual)
   2323     {
   2324       *bufferHdr = (m_out_mem_ptr + i );
   2325       (*bufferHdr)->pBuffer = (OMX_U8 *)buffer;
   2326 	  (*bufferHdr)->pAppPrivate = appData;
   2327       BITMASK_SET(&m_out_bm_count,i);
   2328 
   2329       if(!m_use_output_pmem)
   2330       {
   2331 #ifdef USE_ION
   2332         m_pOutput_ion[i].ion_device_fd = alloc_map_ion_memory(
   2333                                          m_sOutPortDef.nBufferSize,
   2334                                          &m_pOutput_ion[i].ion_alloc_data,
   2335                                          &m_pOutput_ion[i].fd_ion_data,ION_FLAG_CACHED);
   2336       if(m_pOutput_ion[i].ion_device_fd < 0) {
   2337         DEBUG_PRINT_ERROR("\nERROR:ION device open() Failed");
   2338         return OMX_ErrorInsufficientResources;
   2339       }
   2340       m_pOutput_pmem[i].fd = m_pOutput_ion[i].fd_ion_data.fd;
   2341 #else
   2342         m_pOutput_pmem[i].fd = open (MEM_DEVICE,O_RDWR);
   2343 
   2344         if(m_pOutput_pmem[i].fd == 0)
   2345         {
   2346           m_pOutput_pmem[i].fd = open (MEM_DEVICE,O_RDWR);
   2347         }
   2348 
   2349         if(m_pOutput_pmem[i].fd < 0)
   2350         {
   2351           DEBUG_PRINT_ERROR("\nERROR: /dev/pmem_adsp open() Failed");
   2352           return OMX_ErrorInsufficientResources;
   2353         }
   2354 #endif
   2355         m_pOutput_pmem[i].size = m_sOutPortDef.nBufferSize;
   2356         m_pOutput_pmem[i].offset = 0;
   2357         m_pOutput_pmem[i].buffer = (unsigned char *)mmap(NULL,m_pOutput_pmem[i].size,PROT_READ|PROT_WRITE,
   2358                                                          MAP_SHARED,m_pOutput_pmem[i].fd,0);
   2359         if(m_pOutput_pmem[i].buffer == MAP_FAILED)
   2360         {
   2361           DEBUG_PRINT_ERROR("\nERROR: mmap() Failed");
   2362           close(m_pOutput_pmem[i].fd);
   2363 #ifdef USE_ION
   2364           free_ion_memory(&m_pOutput_ion[i]);
   2365 #endif
   2366           return OMX_ErrorInsufficientResources;
   2367         }
   2368       }
   2369       else
   2370       {
   2371         OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO *pParam = reinterpret_cast<OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO*>((*bufferHdr)->pAppPrivate);
   2372         DEBUG_PRINT_LOW("Inside qcom_ext pParam:0x%x )", pParam);
   2373 
   2374         if(pParam)
   2375         {
   2376           DEBUG_PRINT_LOW("Inside qcom_ext with luma:(fd:%d,offset:0x%x)", pParam->pmem_fd, pParam->offset);
   2377           m_pOutput_pmem[i].fd = pParam->pmem_fd;
   2378           m_pOutput_pmem[i].offset = pParam->offset;
   2379           m_pOutput_pmem[i].size = m_sOutPortDef.nBufferSize;
   2380           m_pOutput_pmem[i].buffer = (unsigned char *)buffer;
   2381         }
   2382         else
   2383         {
   2384           DEBUG_PRINT_ERROR("ERROR: Invalid AppData given for PMEM o/p UseBuffer case");
   2385           return OMX_ErrorBadParameter;
   2386         }
   2387         buf_addr = (unsigned char *)buffer;
   2388       }
   2389 
   2390       DEBUG_PRINT_LOW("\n use_out:: bufhdr = %p, pBuffer = %p, m_pOutput_pmem[i].buffer = %p",
   2391                 (*bufferHdr), (*bufferHdr)->pBuffer, m_pOutput_pmem[i].buffer);
   2392       if(dev_use_buf(&m_pOutput_pmem[i],PORT_INDEX_OUT,i) != true)
   2393       {
   2394         DEBUG_PRINT_ERROR("ERROR: dev_use_buf Failed for o/p buf");
   2395         return OMX_ErrorInsufficientResources;
   2396       }
   2397     }
   2398     else
   2399     {
   2400       DEBUG_PRINT_ERROR("ERROR: All o/p Buffers have been Used, invalid use_buf call for "
   2401                       "index = %u", i);
   2402       eRet = OMX_ErrorInsufficientResources;
   2403     }
   2404   }
   2405   return eRet;
   2406 }
   2407 
   2408 
   2409 /* ======================================================================
   2410 FUNCTION
   2411   omx_video::UseBuffer
   2412 
   2413 DESCRIPTION
   2414   OMX Use Buffer method implementation.
   2415 
   2416 PARAMETERS
   2417   <TBD>.
   2418 
   2419 RETURN VALUE
   2420   OMX Error None , if everything successful.
   2421 
   2422 ========================================================================== */
   2423 OMX_ERRORTYPE  omx_video::use_buffer(
   2424                                     OMX_IN OMX_HANDLETYPE            hComp,
   2425                                     OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
   2426                                     OMX_IN OMX_U32                   port,
   2427                                     OMX_IN OMX_PTR                   appData,
   2428                                     OMX_IN OMX_U32                   bytes,
   2429                                     OMX_IN OMX_U8*                   buffer)
   2430 {
   2431   OMX_ERRORTYPE eRet = OMX_ErrorNone;
   2432   if(m_state == OMX_StateInvalid)
   2433   {
   2434     DEBUG_PRINT_ERROR("ERROR: Use Buffer in Invalid State\n");
   2435     return OMX_ErrorInvalidState;
   2436   }
   2437   if(port == PORT_INDEX_IN)
   2438   {
   2439     eRet = use_input_buffer(hComp,bufferHdr,port,appData,bytes,buffer);
   2440   }
   2441   else if(port == PORT_INDEX_OUT)
   2442   {
   2443     eRet = use_output_buffer(hComp,bufferHdr,port,appData,bytes,buffer);
   2444   }
   2445   else
   2446   {
   2447     DEBUG_PRINT_ERROR("ERROR: Invalid Port Index received %d\n",(int)port);
   2448     eRet = OMX_ErrorBadPortIndex;
   2449   }
   2450 
   2451   if(eRet == OMX_ErrorNone)
   2452   {
   2453     if(allocate_done())
   2454     {
   2455       if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
   2456       {
   2457         // Send the callback now
   2458         BITMASK_CLEAR((&m_flags),OMX_COMPONENT_IDLE_PENDING);
   2459         post_event(OMX_CommandStateSet,OMX_StateIdle,
   2460                    OMX_COMPONENT_GENERATE_EVENT);
   2461       }
   2462     }
   2463     if(port == PORT_INDEX_IN && m_sInPortDef.bPopulated)
   2464     {
   2465       if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
   2466       {
   2467         BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_ENABLE_PENDING);
   2468         post_event(OMX_CommandPortEnable,
   2469                    PORT_INDEX_IN,
   2470                    OMX_COMPONENT_GENERATE_EVENT);
   2471       }
   2472 
   2473     }
   2474     else if(port == PORT_INDEX_OUT && m_sOutPortDef.bPopulated)
   2475     {
   2476       if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
   2477       {
   2478         BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
   2479         post_event(OMX_CommandPortEnable,
   2480                    PORT_INDEX_OUT,
   2481                    OMX_COMPONENT_GENERATE_EVENT);
   2482         m_event_port_settings_sent = false;
   2483       }
   2484     }
   2485   }
   2486   return eRet;
   2487 }
   2488 
   2489 OMX_ERRORTYPE omx_video::free_input_buffer(OMX_BUFFERHEADERTYPE *bufferHdr)
   2490 {
   2491   unsigned int index = 0;
   2492   OMX_U8 *temp_buff ;
   2493 
   2494   if(bufferHdr == NULL || m_inp_mem_ptr == NULL)
   2495   {
   2496     DEBUG_PRINT_ERROR("ERROR: free_input: Invalid bufferHdr[%p] or m_inp_mem_ptr[%p]",
   2497       bufferHdr, m_inp_mem_ptr);
   2498     return OMX_ErrorBadParameter;
   2499   }
   2500 
   2501   index = bufferHdr - ((!mUseProxyColorFormat)?m_inp_mem_ptr:meta_buffer_hdr);
   2502 #ifdef _ANDROID_ICS_
   2503   if(meta_mode_enable)
   2504   {
   2505     if(index < m_sInPortDef.nBufferCountActual)
   2506     {
   2507       memset(&meta_buffer_hdr[index], 0, sizeof(meta_buffer_hdr[index]));
   2508       memset(&meta_buffers[index], 0, sizeof(meta_buffers[index]));
   2509     }
   2510     if(!mUseProxyColorFormat)
   2511       return OMX_ErrorNone;
   2512     else {
   2513       c2d_conv.close();
   2514       opaque_buffer_hdr[index] = NULL;
   2515     }
   2516   }
   2517 #endif
   2518   if(index < m_sInPortDef.nBufferCountActual && !mUseProxyColorFormat &&
   2519      dev_free_buf(&m_pInput_pmem[index],PORT_INDEX_IN) != true)
   2520   {
   2521     DEBUG_PRINT_LOW("\nERROR: dev_free_buf() Failed for i/p buf");
   2522   }
   2523 
   2524   if(index < m_sInPortDef.nBufferCountActual && m_pInput_pmem)
   2525   {
   2526     if(m_pInput_pmem[index].fd > 0 && input_use_buffer == false)
   2527     {
   2528       DEBUG_PRINT_LOW("\n FreeBuffer:: i/p AllocateBuffer case");
   2529       munmap (m_pInput_pmem[index].buffer,m_pInput_pmem[index].size);
   2530       close (m_pInput_pmem[index].fd);
   2531 #ifdef USE_ION
   2532       free_ion_memory(&m_pInput_ion[index]);
   2533 #endif
   2534       m_pInput_pmem[index].fd = -1;
   2535     }
   2536     else if(m_pInput_pmem[index].fd > 0 && (input_use_buffer == true &&
   2537       m_use_input_pmem == OMX_FALSE))
   2538     {
   2539       DEBUG_PRINT_LOW("\n FreeBuffer:: i/p Heap UseBuffer case");
   2540       if(dev_free_buf(&m_pInput_pmem[index],PORT_INDEX_IN) != true)
   2541       {
   2542         DEBUG_PRINT_ERROR("\nERROR: dev_free_buf() Failed for i/p buf");
   2543       }
   2544       munmap (m_pInput_pmem[index].buffer,m_pInput_pmem[index].size);
   2545       close (m_pInput_pmem[index].fd);
   2546 #ifdef USE_ION
   2547       free_ion_memory(&m_pInput_ion[index]);
   2548 #endif
   2549       m_pInput_pmem[index].fd = -1;
   2550     }
   2551     else
   2552     {
   2553       DEBUG_PRINT_ERROR("\n FreeBuffer:: fd is invalid or i/p PMEM UseBuffer case");
   2554     }
   2555   }
   2556   return OMX_ErrorNone;
   2557 }
   2558 
   2559 OMX_ERRORTYPE omx_video::free_output_buffer(OMX_BUFFERHEADERTYPE *bufferHdr)
   2560 {
   2561   unsigned int index = 0;
   2562   OMX_U8 *temp_buff ;
   2563 
   2564   if(bufferHdr == NULL || m_out_mem_ptr == NULL)
   2565   {
   2566     DEBUG_PRINT_ERROR("ERROR: free_output: Invalid bufferHdr[%p] or m_out_mem_ptr[%p]",
   2567       bufferHdr, m_out_mem_ptr);
   2568     return OMX_ErrorBadParameter;
   2569   }
   2570   index = bufferHdr - m_out_mem_ptr;
   2571 
   2572   if(index < m_sOutPortDef.nBufferCountActual &&
   2573      dev_free_buf(&m_pOutput_pmem[index],PORT_INDEX_OUT) != true)
   2574   {
   2575     DEBUG_PRINT_ERROR("ERROR: dev_free_buf Failed for o/p buf");
   2576   }
   2577 
   2578   if(index < m_sOutPortDef.nBufferCountActual && m_pOutput_pmem)
   2579   {
   2580     if(m_pOutput_pmem[index].fd > 0 && output_use_buffer == false )
   2581     {
   2582       DEBUG_PRINT_LOW("\n FreeBuffer:: o/p AllocateBuffer case");
   2583       if(!secure_session)
   2584         munmap (m_pOutput_pmem[index].buffer,m_pOutput_pmem[index].size);
   2585       close (m_pOutput_pmem[index].fd);
   2586 #ifdef USE_ION
   2587       free_ion_memory(&m_pOutput_ion[index]);
   2588 #endif
   2589       m_pOutput_pmem[index].fd = -1;
   2590     }
   2591     else if( m_pOutput_pmem[index].fd > 0 && (output_use_buffer == true
   2592       && m_use_output_pmem == OMX_FALSE))
   2593     {
   2594       DEBUG_PRINT_LOW("\n FreeBuffer:: o/p Heap UseBuffer case");
   2595       if(dev_free_buf(&m_pOutput_pmem[index],PORT_INDEX_OUT) != true)
   2596       {
   2597         DEBUG_PRINT_ERROR("ERROR: dev_free_buf Failed for o/p buf");
   2598       }
   2599       munmap (m_pOutput_pmem[index].buffer,m_pOutput_pmem[index].size);
   2600       close (m_pOutput_pmem[index].fd);
   2601 #ifdef USE_ION
   2602       free_ion_memory(&m_pOutput_ion[index]);
   2603 #endif
   2604       m_pOutput_pmem[index].fd = -1;
   2605     }
   2606     else
   2607     {
   2608       DEBUG_PRINT_LOW("\n FreeBuffer:: fd is invalid or o/p PMEM UseBuffer case");
   2609     }
   2610   }
   2611   return OMX_ErrorNone;
   2612 }
   2613 #ifdef _ANDROID_ICS_
   2614 OMX_ERRORTYPE omx_video::allocate_input_meta_buffer(
   2615                     OMX_HANDLETYPE       hComp,
   2616                     OMX_BUFFERHEADERTYPE **bufferHdr,
   2617                     OMX_PTR              appData,
   2618                     OMX_U32              bytes)
   2619 {
   2620   unsigned index = 0;
   2621   if(!bufferHdr || bytes != sizeof(encoder_media_buffer_type))
   2622   {
   2623     DEBUG_PRINT_ERROR("wrong params allocate_input_meta_buffer Hdr %p len %d",
   2624                      bufferHdr,bytes);
   2625     return OMX_ErrorBadParameter;
   2626   }
   2627   if(!m_inp_mem_ptr && !mUseProxyColorFormat)
   2628     m_inp_mem_ptr = meta_buffer_hdr;
   2629   for(index = 0;((index < m_sInPortDef.nBufferCountActual) &&
   2630       meta_buffer_hdr[index].pBuffer); index++);
   2631   if(index == m_sInPortDef.nBufferCountActual)
   2632   {
   2633     DEBUG_PRINT_ERROR("All buffers are allocated input_meta_buffer");
   2634     return OMX_ErrorBadParameter;
   2635   }
   2636   if(mUseProxyColorFormat){
   2637     if(opaque_buffer_hdr[index]){
   2638       DEBUG_PRINT_ERROR("All buffers are allocated opaque_buffer_hdr");
   2639       return OMX_ErrorBadParameter;
   2640     }
   2641     if(allocate_input_buffer(hComp,&opaque_buffer_hdr[index],
   2642        PORT_INDEX_IN,appData,m_sInPortDef.nBufferSize) != OMX_ErrorNone) {
   2643       DEBUG_PRINT_ERROR("All buffers are allocated opaque_buffer_hdr");
   2644       return OMX_ErrorBadParameter;
   2645     }
   2646   }
   2647   BITMASK_SET(&m_inp_bm_count,index);
   2648   *bufferHdr = &meta_buffer_hdr[index];
   2649   memset(&meta_buffer_hdr[index], 0, sizeof(meta_buffer_hdr[index]));
   2650   meta_buffer_hdr[index].nSize = sizeof(meta_buffer_hdr[index]);
   2651   meta_buffer_hdr[index].nAllocLen = bytes;
   2652   meta_buffer_hdr[index].nVersion.nVersion = OMX_SPEC_VERSION;
   2653   meta_buffer_hdr[index].nInputPortIndex = PORT_INDEX_IN;
   2654   meta_buffer_hdr[index].pBuffer = (OMX_U8*)&meta_buffers[index];
   2655   meta_buffer_hdr[index].pAppPrivate = appData;
   2656   if(mUseProxyColorFormat) {
   2657     m_opq_pmem_q.insert_entry((unsigned int)opaque_buffer_hdr[index],0,0);
   2658     DEBUG_PRINT_HIGH("\n opaque_buffer_hdr insert %p", opaque_buffer_hdr[index]);
   2659   }
   2660   return OMX_ErrorNone;
   2661 }
   2662 #endif
   2663 /* ======================================================================
   2664 FUNCTION
   2665   omx_venc::AllocateInputBuffer
   2666 
   2667 DESCRIPTION
   2668   Helper function for allocate buffer in the input pin
   2669 
   2670 PARAMETERS
   2671   None.
   2672 
   2673 RETURN VALUE
   2674   true/false
   2675 
   2676 ========================================================================== */
   2677 OMX_ERRORTYPE  omx_video::allocate_input_buffer(
   2678                                                OMX_IN OMX_HANDLETYPE            hComp,
   2679                                                OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
   2680                                                OMX_IN OMX_U32                   port,
   2681                                                OMX_IN OMX_PTR                   appData,
   2682                                                OMX_IN OMX_U32                   bytes)
   2683 {
   2684 
   2685   OMX_ERRORTYPE eRet = OMX_ErrorNone;
   2686   unsigned   i = 0;
   2687 
   2688   DEBUG_PRINT_HIGH("\n allocate_input_buffer()::");
   2689   if(bytes != m_sInPortDef.nBufferSize || secure_session)
   2690   {
   2691     DEBUG_PRINT_ERROR("\nERROR: Buffer size mismatch error: bytes[%u] != nBufferSize[%u]\n",
   2692       bytes, m_sInPortDef.nBufferSize);
   2693     return OMX_ErrorBadParameter;
   2694   }
   2695 
   2696   if(!m_inp_mem_ptr)
   2697   {
   2698     DEBUG_PRINT_HIGH("%s: size = %d, actual cnt %d", __FUNCTION__,
   2699         m_sInPortDef.nBufferSize, m_sInPortDef.nBufferCountActual);
   2700     m_inp_mem_ptr = (OMX_BUFFERHEADERTYPE*) \
   2701                     calloc( (sizeof(OMX_BUFFERHEADERTYPE)), m_sInPortDef.nBufferCountActual);
   2702     if(m_inp_mem_ptr == NULL)
   2703     {
   2704       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_inp_mem_ptr");
   2705       return OMX_ErrorInsufficientResources;
   2706     }
   2707 
   2708     m_pInput_pmem = (struct pmem *) calloc(sizeof (struct pmem), m_sInPortDef.nBufferCountActual);
   2709 
   2710     if(m_pInput_pmem == NULL)
   2711     {
   2712       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_pInput_pmem");
   2713       return OMX_ErrorInsufficientResources;
   2714     }
   2715 #ifdef USE_ION
   2716     m_pInput_ion = (struct venc_ion *) calloc(sizeof (struct venc_ion), m_sInPortDef.nBufferCountActual);
   2717     if(m_pInput_ion == NULL)
   2718     {
   2719       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_pInput_ion");
   2720       return OMX_ErrorInsufficientResources;
   2721     }
   2722 #endif
   2723     for(i=0; i< m_sInPortDef.nBufferCountActual; i++)
   2724     {
   2725       m_pInput_pmem[i].fd = -1;
   2726 #ifdef USE_ION
   2727       m_pInput_ion[i].ion_device_fd =-1;
   2728       m_pInput_ion[i].fd_ion_data.fd =-1;
   2729       m_pInput_ion[i].ion_alloc_data.handle=NULL;
   2730 #endif
   2731     }
   2732   }
   2733 
   2734   for(i=0; i< m_sInPortDef.nBufferCountActual; i++)
   2735   {
   2736     if(BITMASK_ABSENT(&m_inp_bm_count,i))
   2737     {
   2738       break;
   2739     }
   2740   }
   2741   if(i < m_sInPortDef.nBufferCountActual)
   2742   {
   2743 
   2744     *bufferHdr = (m_inp_mem_ptr + i);
   2745     (*bufferHdr)->nSize             = sizeof(OMX_BUFFERHEADERTYPE);
   2746     (*bufferHdr)->nVersion.nVersion = OMX_SPEC_VERSION;
   2747     (*bufferHdr)->nAllocLen         = m_sInPortDef.nBufferSize;
   2748     (*bufferHdr)->pAppPrivate       = appData;
   2749     (*bufferHdr)->nInputPortIndex   = PORT_INDEX_IN;
   2750 
   2751 #ifdef USE_ION
   2752     m_pInput_ion[i].ion_device_fd = alloc_map_ion_memory(m_sInPortDef.nBufferSize,
   2753                                     &m_pInput_ion[i].ion_alloc_data,
   2754                                     &m_pInput_ion[i].fd_ion_data,0);
   2755     if(m_pInput_ion[i].ion_device_fd < 0) {
   2756       DEBUG_PRINT_ERROR("\nERROR:ION device open() Failed");
   2757       return OMX_ErrorInsufficientResources;
   2758     }
   2759 
   2760     m_pInput_pmem[i].fd = m_pInput_ion[i].fd_ion_data.fd;
   2761 #else
   2762     m_pInput_pmem[i].fd = open (MEM_DEVICE,O_RDWR);
   2763 
   2764     if(m_pInput_pmem[i].fd == 0)
   2765     {
   2766       m_pInput_pmem[i].fd = open (MEM_DEVICE,O_RDWR);
   2767     }
   2768 
   2769     if(m_pInput_pmem[i].fd < 0)
   2770     {
   2771       DEBUG_PRINT_ERROR("\nERROR: /dev/pmem_adsp open() Failed\n");
   2772       return OMX_ErrorInsufficientResources;
   2773     }
   2774 #endif
   2775     m_pInput_pmem[i].size = m_sInPortDef.nBufferSize;
   2776     m_pInput_pmem[i].offset = 0;
   2777 
   2778     m_pInput_pmem[i].buffer = (unsigned char *)mmap(NULL,m_pInput_pmem[i].size,PROT_READ|PROT_WRITE,
   2779                                                     MAP_SHARED,m_pInput_pmem[i].fd,0);
   2780     if(m_pInput_pmem[i].buffer == MAP_FAILED)
   2781     {
   2782       DEBUG_PRINT_ERROR("\nERROR: mmap FAILED= %d\n", errno);
   2783       close(m_pInput_pmem[i].fd);
   2784 #ifdef USE_ION
   2785       free_ion_memory(&m_pInput_ion[i]);
   2786 #endif
   2787       return OMX_ErrorInsufficientResources;
   2788     }
   2789 
   2790     (*bufferHdr)->pBuffer           = (OMX_U8 *)m_pInput_pmem[i].buffer;
   2791     DEBUG_PRINT_LOW("\n Virtual address in allocate buffer is %p", m_pInput_pmem[i].buffer);
   2792     BITMASK_SET(&m_inp_bm_count,i);
   2793     //here change the I/P param here from buf_adr to pmem
   2794     if(!mUseProxyColorFormat && (dev_use_buf(&m_pInput_pmem[i],PORT_INDEX_IN,i) != true))
   2795     {
   2796       DEBUG_PRINT_ERROR("\nERROR: dev_use_buf FAILED for i/p buf\n");
   2797       return OMX_ErrorInsufficientResources;
   2798     }
   2799   }
   2800   else
   2801   {
   2802     DEBUG_PRINT_ERROR("\nERROR: All i/p buffers are allocated, invalid allocate buf call"
   2803                       "for index [%d]\n", i);
   2804     eRet = OMX_ErrorInsufficientResources;
   2805   }
   2806 
   2807   return eRet;
   2808 }
   2809 
   2810 
   2811 /* ======================================================================
   2812 FUNCTION
   2813   omx_venc::AllocateOutputBuffer
   2814 
   2815 DESCRIPTION
   2816   Helper fn for AllocateBuffer in the output pin
   2817 
   2818 PARAMETERS
   2819   <TBD>.
   2820 
   2821 RETURN VALUE
   2822   OMX Error None if everything went well.
   2823 
   2824 ========================================================================== */
   2825 OMX_ERRORTYPE  omx_video::allocate_output_buffer(
   2826                                                 OMX_IN OMX_HANDLETYPE            hComp,
   2827                                                 OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
   2828                                                 OMX_IN OMX_U32                   port,
   2829                                                 OMX_IN OMX_PTR                   appData,
   2830                                                 OMX_IN OMX_U32                   bytes)
   2831 {
   2832   OMX_ERRORTYPE eRet = OMX_ErrorNone;
   2833   OMX_BUFFERHEADERTYPE       *bufHdr= NULL; // buffer header
   2834   unsigned                         i= 0; // Temporary counter
   2835 
   2836   DEBUG_PRINT_HIGH("\n allocate_output_buffer()::");
   2837   if(!m_out_mem_ptr)
   2838   {
   2839     int nBufHdrSize        = 0;
   2840     DEBUG_PRINT_HIGH("%s: size = %d, actual cnt %d", __FUNCTION__,
   2841         m_sOutPortDef.nBufferSize, m_sOutPortDef.nBufferCountActual);
   2842     nBufHdrSize        = m_sOutPortDef.nBufferCountActual * sizeof(OMX_BUFFERHEADERTYPE);
   2843 
   2844     /*
   2845      * Memory for output side involves the following:
   2846      * 1. Array of Buffer Headers
   2847      * 2. Bitmask array to hold the buffer allocation details
   2848      * In order to minimize the memory management entire allocation
   2849      * is done in one step.
   2850      */
   2851     m_out_mem_ptr = (OMX_BUFFERHEADERTYPE  *)calloc(nBufHdrSize,1);
   2852 
   2853 #ifdef USE_ION
   2854     m_pOutput_ion = (struct venc_ion *) calloc(sizeof (struct venc_ion), m_sOutPortDef.nBufferCountActual);
   2855     if(m_pOutput_ion == NULL)
   2856     {
   2857       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_pOutput_ion");
   2858       return OMX_ErrorInsufficientResources;
   2859     }
   2860 #endif
   2861     m_pOutput_pmem = (struct pmem *) calloc(sizeof(struct pmem), m_sOutPortDef.nBufferCountActual);
   2862     if(m_pOutput_pmem == NULL)
   2863     {
   2864       DEBUG_PRINT_ERROR("\nERROR: calloc() Failed for m_pOutput_pmem");
   2865       return OMX_ErrorInsufficientResources;
   2866     }
   2867     if(m_out_mem_ptr && m_pOutput_pmem)
   2868     {
   2869       bufHdr          =  m_out_mem_ptr;
   2870 
   2871       for(i=0; i < m_sOutPortDef.nBufferCountActual ; i++)
   2872       {
   2873         bufHdr->nSize              = sizeof(OMX_BUFFERHEADERTYPE);
   2874         bufHdr->nVersion.nVersion  = OMX_SPEC_VERSION;
   2875         // Set the values when we determine the right HxW param
   2876         bufHdr->nAllocLen          = bytes;
   2877         bufHdr->nFilledLen         = 0;
   2878         bufHdr->pAppPrivate        = appData;
   2879         bufHdr->nOutputPortIndex   = PORT_INDEX_OUT;
   2880         bufHdr->pBuffer            = NULL;
   2881         bufHdr++;
   2882         m_pOutput_pmem[i].fd = -1;
   2883 #ifdef USE_ION
   2884         m_pOutput_ion[i].ion_device_fd =-1;
   2885         m_pOutput_ion[i].fd_ion_data.fd=-1;
   2886         m_pOutput_ion[i].ion_alloc_data.handle =NULL;
   2887 #endif
   2888       }
   2889     }
   2890     else
   2891     {
   2892       DEBUG_PRINT_ERROR("ERROR: calloc() failed for m_out_mem_ptr/m_pOutput_pmem");
   2893       eRet = OMX_ErrorInsufficientResources;
   2894     }
   2895   }
   2896 
   2897   DEBUG_PRINT_HIGH("\n actual cnt = %u", m_sOutPortDef.nBufferCountActual);
   2898   for(i=0; i< m_sOutPortDef.nBufferCountActual; i++)
   2899   {
   2900     if(BITMASK_ABSENT(&m_out_bm_count,i))
   2901     {
   2902       DEBUG_PRINT_LOW("\n Found a Free Output Buffer %d",i);
   2903       break;
   2904     }
   2905   }
   2906   if(eRet == OMX_ErrorNone)
   2907   {
   2908     if(i < m_sOutPortDef.nBufferCountActual)
   2909     {
   2910 #ifdef USE_ION
   2911       m_pOutput_ion[i].ion_device_fd = alloc_map_ion_memory(m_sOutPortDef.nBufferSize,
   2912                                        &m_pOutput_ion[i].ion_alloc_data,
   2913                                        &m_pOutput_ion[i].fd_ion_data,ION_FLAG_CACHED);
   2914       if(m_pOutput_ion[i].ion_device_fd < 0) {
   2915         DEBUG_PRINT_ERROR("\nERROR:ION device open() Failed");
   2916         return OMX_ErrorInsufficientResources;
   2917       }
   2918       m_pOutput_pmem[i].fd = m_pOutput_ion[i].fd_ion_data.fd;
   2919 #else
   2920       m_pOutput_pmem[i].fd = open (MEM_DEVICE,O_RDWR);
   2921       if(m_pOutput_pmem[i].fd == 0)
   2922       {
   2923         m_pOutput_pmem[i].fd = open (MEM_DEVICE,O_RDWR);
   2924       }
   2925 
   2926       if(m_pOutput_pmem[i].fd < 0)
   2927       {
   2928         DEBUG_PRINT_ERROR("\nERROR: /dev/pmem_adsp open() failed");
   2929         return OMX_ErrorInsufficientResources;
   2930       }
   2931 #endif
   2932       m_pOutput_pmem[i].size = m_sOutPortDef.nBufferSize;
   2933       m_pOutput_pmem[i].offset = 0;
   2934       if(!secure_session) {
   2935           m_pOutput_pmem[i].buffer = (unsigned char *)mmap(NULL,m_pOutput_pmem[i].size,PROT_READ|PROT_WRITE,
   2936                   MAP_SHARED,m_pOutput_pmem[i].fd,0);
   2937           if(m_pOutput_pmem[i].buffer == MAP_FAILED)
   2938           {
   2939               DEBUG_PRINT_ERROR("\nERROR: MMAP_FAILED in o/p alloc buffer");
   2940               close (m_pOutput_pmem[i].fd);
   2941 #ifdef USE_ION
   2942               free_ion_memory(&m_pOutput_ion[i]);
   2943 #endif
   2944               return OMX_ErrorInsufficientResources;
   2945           }
   2946       }
   2947 
   2948       *bufferHdr = (m_out_mem_ptr + i );
   2949       if(!secure_session)
   2950         (*bufferHdr)->pBuffer = (OMX_U8 *)m_pOutput_pmem[i].buffer;
   2951       else {
   2952         m_pOutput_pmem[i].buffer = (OMX_U8 *)(i + 12345);
   2953         (*bufferHdr)->pBuffer = (OMX_U8 *)(i + 12345);
   2954       }
   2955       (*bufferHdr)->pAppPrivate = appData;
   2956 
   2957       BITMASK_SET(&m_out_bm_count,i);
   2958 
   2959       if(dev_use_buf(&m_pOutput_pmem[i],PORT_INDEX_OUT,i) != true)
   2960       {
   2961         DEBUG_PRINT_ERROR("\nERROR: dev_use_buf FAILED for o/p buf");
   2962         return OMX_ErrorInsufficientResources;
   2963       }
   2964     }
   2965     else
   2966     {
   2967       DEBUG_PRINT_ERROR("\nERROR: All o/p buffers are allocated, invalid allocate buf call"
   2968                         "for index [%d]\n", i);
   2969     }
   2970   }
   2971 
   2972   return eRet;
   2973 }
   2974 
   2975 
   2976 // AllocateBuffer  -- API Call
   2977 /* ======================================================================
   2978 FUNCTION
   2979   omx_video::AllocateBuffer
   2980 
   2981 DESCRIPTION
   2982   Returns zero if all the buffers released..
   2983 
   2984 PARAMETERS
   2985   None.
   2986 
   2987 RETURN VALUE
   2988   true/false
   2989 
   2990 ========================================================================== */
   2991 OMX_ERRORTYPE  omx_video::allocate_buffer(OMX_IN OMX_HANDLETYPE                hComp,
   2992                                           OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
   2993                                           OMX_IN OMX_U32                        port,
   2994                                           OMX_IN OMX_PTR                     appData,
   2995                                           OMX_IN OMX_U32                       bytes)
   2996 {
   2997 
   2998   OMX_ERRORTYPE eRet = OMX_ErrorNone; // OMX return type
   2999 
   3000   DEBUG_PRINT_LOW("\n Allocate buffer of size = %d on port %d \n", bytes, (int)port);
   3001   if(m_state == OMX_StateInvalid)
   3002   {
   3003     DEBUG_PRINT_ERROR("ERROR: Allocate Buf in Invalid State\n");
   3004     return OMX_ErrorInvalidState;
   3005   }
   3006 
   3007   // What if the client calls again.
   3008   if(port == PORT_INDEX_IN)
   3009   {
   3010 #ifdef _ANDROID_ICS_
   3011     if(meta_mode_enable)
   3012       eRet = allocate_input_meta_buffer(hComp,bufferHdr,appData,bytes);
   3013     else
   3014 #endif
   3015     eRet = allocate_input_buffer(hComp,bufferHdr,port,appData,bytes);
   3016   }
   3017   else if(port == PORT_INDEX_OUT)
   3018   {
   3019     eRet = allocate_output_buffer(hComp,bufferHdr,port,appData,bytes);
   3020   }
   3021   else
   3022   {
   3023     DEBUG_PRINT_ERROR("ERROR: Invalid Port Index received %d\n",(int)port);
   3024     eRet = OMX_ErrorBadPortIndex;
   3025   }
   3026   DEBUG_PRINT_LOW("Checking for Output Allocate buffer Done");
   3027   if(eRet == OMX_ErrorNone)
   3028   {
   3029     if(allocate_done())
   3030     {
   3031       if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
   3032       {
   3033         // Send the callback now
   3034         BITMASK_CLEAR((&m_flags),OMX_COMPONENT_IDLE_PENDING);
   3035         post_event(OMX_CommandStateSet,OMX_StateIdle,
   3036                    OMX_COMPONENT_GENERATE_EVENT);
   3037       }
   3038     }
   3039     if(port == PORT_INDEX_IN && m_sInPortDef.bPopulated)
   3040     {
   3041       if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
   3042       {
   3043         BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_ENABLE_PENDING);
   3044         post_event(OMX_CommandPortEnable,
   3045                    PORT_INDEX_IN,
   3046                    OMX_COMPONENT_GENERATE_EVENT);
   3047       }
   3048     }
   3049     if(port == PORT_INDEX_OUT && m_sOutPortDef.bPopulated)
   3050     {
   3051       if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
   3052       {
   3053         BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
   3054         post_event(OMX_CommandPortEnable,
   3055                    PORT_INDEX_OUT,
   3056                    OMX_COMPONENT_GENERATE_EVENT);
   3057         m_event_port_settings_sent = false;
   3058       }
   3059     }
   3060   }
   3061   DEBUG_PRINT_LOW("Allocate Buffer exit with ret Code %d\n",eRet);
   3062   return eRet;
   3063 }
   3064 
   3065 
   3066 // Free Buffer - API call
   3067 /* ======================================================================
   3068 FUNCTION
   3069   omx_video::FreeBuffer
   3070 
   3071 DESCRIPTION
   3072 
   3073 PARAMETERS
   3074   None.
   3075 
   3076 RETURN VALUE
   3077   true/false
   3078 
   3079 ========================================================================== */
   3080 OMX_ERRORTYPE  omx_video::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
   3081                                       OMX_IN OMX_U32                 port,
   3082                                       OMX_IN OMX_BUFFERHEADERTYPE* buffer)
   3083 {
   3084   OMX_ERRORTYPE eRet = OMX_ErrorNone;
   3085   unsigned int nPortIndex;
   3086 
   3087   DEBUG_PRINT_LOW("In for decoder free_buffer \n");
   3088 
   3089   if(m_state == OMX_StateIdle &&
   3090      (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING)))
   3091   {
   3092     DEBUG_PRINT_LOW(" free buffer while Component in Loading pending\n");
   3093   }
   3094   else if((m_sInPortDef.bEnabled == OMX_FALSE && port == PORT_INDEX_IN)||
   3095           (m_sOutPortDef.bEnabled == OMX_FALSE && port == PORT_INDEX_OUT))
   3096   {
   3097     DEBUG_PRINT_LOW("Free Buffer while port %d disabled\n", port);
   3098   }
   3099   else if(m_state == OMX_StateExecuting || m_state == OMX_StatePause)
   3100   {
   3101     DEBUG_PRINT_ERROR("ERROR: Invalid state to free buffer,ports need to be disabled\n");
   3102     post_event(OMX_EventError,
   3103                OMX_ErrorPortUnpopulated,
   3104                OMX_COMPONENT_GENERATE_EVENT);
   3105 
   3106     return eRet;
   3107   }
   3108   else
   3109   {
   3110     DEBUG_PRINT_ERROR("ERROR: Invalid state to free buffer,port lost Buffers\n");
   3111     post_event(OMX_EventError,
   3112                OMX_ErrorPortUnpopulated,
   3113                OMX_COMPONENT_GENERATE_EVENT);
   3114   }
   3115 
   3116   if(port == PORT_INDEX_IN)
   3117   {
   3118     // check if the buffer is valid
   3119     nPortIndex = buffer - ((!mUseProxyColorFormat)?m_inp_mem_ptr:meta_buffer_hdr);
   3120 
   3121     DEBUG_PRINT_LOW("free_buffer on i/p port - Port idx %d, actual cnt %d \n",
   3122                     nPortIndex, m_sInPortDef.nBufferCountActual);
   3123     if(nPortIndex < m_sInPortDef.nBufferCountActual)
   3124     {
   3125       // Clear the bit associated with it.
   3126       BITMASK_CLEAR(&m_inp_bm_count,nPortIndex);
   3127       free_input_buffer (buffer);
   3128       m_sInPortDef.bPopulated = OMX_FALSE;
   3129 
   3130       /*Free the Buffer Header*/
   3131       if(release_input_done()
   3132 #ifdef _ANDROID_ICS_
   3133          && !meta_mode_enable
   3134 #endif
   3135          )
   3136       {
   3137         input_use_buffer = false;
   3138         if(m_inp_mem_ptr)
   3139         {
   3140           DEBUG_PRINT_LOW("Freeing m_inp_mem_ptr\n");
   3141           free (m_inp_mem_ptr);
   3142           m_inp_mem_ptr = NULL;
   3143         }
   3144         if(m_pInput_pmem)
   3145         {
   3146           DEBUG_PRINT_LOW("Freeing m_pInput_pmem\n");
   3147           free(m_pInput_pmem);
   3148           m_pInput_pmem = NULL;
   3149         }
   3150 #ifdef USE_ION
   3151         if(m_pInput_ion)
   3152         {
   3153           DEBUG_PRINT_LOW("Freeing m_pInput_ion\n");
   3154           free(m_pInput_ion);
   3155           m_pInput_ion = NULL;
   3156         }
   3157 #endif
   3158       }
   3159     }
   3160     else
   3161     {
   3162       DEBUG_PRINT_ERROR("ERROR: free_buffer ,Port Index Invalid\n");
   3163       eRet = OMX_ErrorBadPortIndex;
   3164     }
   3165 
   3166     if(BITMASK_PRESENT((&m_flags),OMX_COMPONENT_INPUT_DISABLE_PENDING)
   3167        && release_input_done())
   3168     {
   3169       DEBUG_PRINT_LOW("MOVING TO DISABLED STATE \n");
   3170       BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_DISABLE_PENDING);
   3171       post_event(OMX_CommandPortDisable,
   3172                  PORT_INDEX_IN,
   3173                  OMX_COMPONENT_GENERATE_EVENT);
   3174     }
   3175   }
   3176   else if(port == PORT_INDEX_OUT)
   3177   {
   3178     // check if the buffer is valid
   3179     nPortIndex = buffer - (OMX_BUFFERHEADERTYPE*)m_out_mem_ptr;
   3180 
   3181     DEBUG_PRINT_LOW("free_buffer on o/p port - Port idx %d, actual cnt %d \n",
   3182                     nPortIndex, m_sOutPortDef.nBufferCountActual);
   3183     if(nPortIndex < m_sOutPortDef.nBufferCountActual)
   3184     {
   3185       // Clear the bit associated with it.
   3186       BITMASK_CLEAR(&m_out_bm_count,nPortIndex);
   3187       m_sOutPortDef.bPopulated = OMX_FALSE;
   3188       free_output_buffer (buffer);
   3189 
   3190       if(release_output_done())
   3191       {
   3192         output_use_buffer = false;
   3193         if(m_out_mem_ptr)
   3194         {
   3195           DEBUG_PRINT_LOW("Freeing m_out_mem_ptr\n");
   3196           free (m_out_mem_ptr);
   3197           m_out_mem_ptr = NULL;
   3198         }
   3199         if(m_pOutput_pmem)
   3200         {
   3201           DEBUG_PRINT_LOW("Freeing m_pOutput_pmem\n");
   3202           free(m_pOutput_pmem);
   3203           m_pOutput_pmem = NULL;
   3204         }
   3205 #ifdef USE_ION
   3206         if(m_pOutput_ion)
   3207         {
   3208           DEBUG_PRINT_LOW("Freeing m_pOutput_ion\n");
   3209           free(m_pOutput_ion);
   3210           m_pOutput_ion = NULL;
   3211         }
   3212 #endif
   3213       }
   3214     }
   3215     else
   3216     {
   3217       DEBUG_PRINT_ERROR("ERROR: free_buffer , Port Index Invalid\n");
   3218       eRet = OMX_ErrorBadPortIndex;
   3219     }
   3220     if(BITMASK_PRESENT((&m_flags),OMX_COMPONENT_OUTPUT_DISABLE_PENDING)
   3221        && release_output_done() )
   3222     {
   3223       DEBUG_PRINT_LOW("FreeBuffer : If any Disable event pending,post it\n");
   3224 
   3225       DEBUG_PRINT_LOW("MOVING TO DISABLED STATE \n");
   3226       BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
   3227       post_event(OMX_CommandPortDisable,
   3228                  PORT_INDEX_OUT,
   3229                  OMX_COMPONENT_GENERATE_EVENT);
   3230 
   3231     }
   3232   }
   3233   else
   3234   {
   3235     eRet = OMX_ErrorBadPortIndex;
   3236   }
   3237   if((eRet == OMX_ErrorNone) &&
   3238      (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING)))
   3239   {
   3240     if(release_done())
   3241     {
   3242       if(dev_stop() != 0)
   3243       {
   3244         DEBUG_PRINT_ERROR("ERROR: dev_stop() FAILED\n");
   3245         eRet = OMX_ErrorHardware;
   3246       }
   3247       // Send the callback now
   3248       BITMASK_CLEAR((&m_flags),OMX_COMPONENT_LOADING_PENDING);
   3249       post_event(OMX_CommandStateSet, OMX_StateLoaded,
   3250                  OMX_COMPONENT_GENERATE_EVENT);
   3251     }
   3252   }
   3253 
   3254   return eRet;
   3255 }
   3256 
   3257 
   3258 /* ======================================================================
   3259 FUNCTION
   3260   omx_video::EmptyThisBuffer
   3261 
   3262 DESCRIPTION
   3263   This routine is used to push the encoded video frames to
   3264   the video decoder.
   3265 
   3266 PARAMETERS
   3267   None.
   3268 
   3269 RETURN VALUE
   3270   OMX Error None if everything went successful.
   3271 
   3272 ========================================================================== */
   3273 OMX_ERRORTYPE  omx_video::empty_this_buffer(OMX_IN OMX_HANDLETYPE         hComp,
   3274                                             OMX_IN OMX_BUFFERHEADERTYPE* buffer)
   3275 {
   3276   OMX_ERRORTYPE ret1 = OMX_ErrorNone;
   3277   unsigned int nBufferIndex ;
   3278 
   3279   DEBUG_PRINT_LOW("\n ETB: buffer = %p, buffer->pBuffer[%p]\n", buffer, buffer->pBuffer);
   3280   if(m_state == OMX_StateInvalid)
   3281   {
   3282     DEBUG_PRINT_ERROR("ERROR: Empty this buffer in Invalid State\n");
   3283     return OMX_ErrorInvalidState;
   3284   }
   3285 
   3286   if (buffer == NULL || (buffer->nSize != sizeof(OMX_BUFFERHEADERTYPE)))
   3287   {
   3288     DEBUG_PRINT_ERROR("\nERROR: omx_video::etb--> buffer is null or buffer size is invalid");
   3289     return OMX_ErrorBadParameter;
   3290   }
   3291 
   3292   if(buffer->nVersion.nVersion != OMX_SPEC_VERSION)
   3293   {
   3294     DEBUG_PRINT_ERROR("\nERROR: omx_video::etb--> OMX Version Invalid");
   3295     return OMX_ErrorVersionMismatch;
   3296   }
   3297 
   3298   if (buffer->nInputPortIndex != (OMX_U32)PORT_INDEX_IN)
   3299   {
   3300     DEBUG_PRINT_ERROR("\nERROR: Bad port index to call empty_this_buffer");
   3301     return OMX_ErrorBadPortIndex;
   3302   }
   3303   if(!m_sInPortDef.bEnabled)
   3304   {
   3305     DEBUG_PRINT_ERROR("\nERROR: Cannot call empty_this_buffer while I/P port is disabled");
   3306     return OMX_ErrorIncorrectStateOperation;
   3307   }
   3308 
   3309   nBufferIndex = buffer - ((!mUseProxyColorFormat)?m_inp_mem_ptr:meta_buffer_hdr);
   3310 
   3311   if(nBufferIndex > m_sInPortDef.nBufferCountActual )
   3312   {
   3313     DEBUG_PRINT_ERROR("ERROR: ETB: Invalid buffer index[%d]\n", nBufferIndex);
   3314     return OMX_ErrorBadParameter;
   3315   }
   3316 
   3317   m_etb_count++;
   3318   DEBUG_PRINT_LOW("\n DBG: i/p nTimestamp = %u", (unsigned)buffer->nTimeStamp);
   3319   post_event ((unsigned)hComp,(unsigned)buffer,m_input_msg_id);
   3320   return OMX_ErrorNone;
   3321 }
   3322 /* ======================================================================
   3323 FUNCTION
   3324   omx_video::empty_this_buffer_proxy
   3325 
   3326 DESCRIPTION
   3327   This routine is used to push the encoded video frames to
   3328   the video decoder.
   3329 
   3330 PARAMETERS
   3331   None.
   3332 
   3333 RETURN VALUE
   3334   OMX Error None if everything went successful.
   3335 
   3336 ========================================================================== */
   3337 OMX_ERRORTYPE  omx_video::empty_this_buffer_proxy(OMX_IN OMX_HANDLETYPE         hComp,
   3338                                                   OMX_IN OMX_BUFFERHEADERTYPE* buffer)
   3339 {
   3340   OMX_U8 *pmem_data_buf = NULL;
   3341   int push_cnt = 0;
   3342   unsigned nBufIndex = 0,nBufIndex_meta = 0;
   3343   OMX_ERRORTYPE ret = OMX_ErrorNone;
   3344 
   3345   DEBUG_PRINT_LOW("\n ETBProxy: buffer[%p]\n", buffer);
   3346 
   3347   if(buffer == NULL)
   3348   {
   3349     DEBUG_PRINT_ERROR("\nERROR: ETBProxy: Invalid buffer[%p]\n", buffer);
   3350     return OMX_ErrorBadParameter;
   3351   }
   3352 
   3353   nBufIndex = buffer - ((OMX_BUFFERHEADERTYPE *)m_inp_mem_ptr);
   3354   nBufIndex_meta = buffer - meta_buffer_hdr;
   3355   if(nBufIndex >= m_sInPortDef.nBufferCountActual &&
   3356      nBufIndex_meta >= m_sInPortDef.nBufferCountActual)
   3357   {
   3358     DEBUG_PRINT_ERROR("\nERROR: ETBProxy: Invalid bufindex = %u\n", nBufIndex);
   3359     return OMX_ErrorBadParameter;
   3360   }
   3361 
   3362   pending_input_buffers++;
   3363   if(input_flush_progress == true)
   3364   {
   3365     post_event ((unsigned int)buffer,0,
   3366                 OMX_COMPONENT_GENERATE_EBD);
   3367     DEBUG_PRINT_ERROR("\nERROR: ETBProxy: Input flush in progress");
   3368     return OMX_ErrorNone;
   3369   }
   3370 #ifdef _ANDROID_ICS_
   3371   if(meta_mode_enable && !mUseProxyColorFormat)
   3372   {
   3373     encoder_media_buffer_type *media_buffer;
   3374     bool met_error = false;
   3375     media_buffer = (encoder_media_buffer_type *)meta_buffer_hdr[nBufIndex].pBuffer;
   3376     if(media_buffer)
   3377     {
   3378       if (media_buffer->buffer_type != kMetadataBufferTypeCameraSource &&
   3379           media_buffer->buffer_type != kMetadataBufferTypeGrallocSource) {
   3380           met_error = true;
   3381       } else {
   3382         if(media_buffer->buffer_type == kMetadataBufferTypeCameraSource)
   3383         {
   3384           if(media_buffer->meta_handle == NULL) {
   3385             met_error = true;
   3386           }
   3387           else if((media_buffer->meta_handle->numFds != 1 &&
   3388                    media_buffer->meta_handle->numInts != 2))
   3389           {
   3390             met_error = true;
   3391           }
   3392         }
   3393       }
   3394     } else {
   3395       met_error = true;
   3396     }
   3397     if(met_error)
   3398     {
   3399       DEBUG_PRINT_ERROR("\nERROR: Unkown source/metahandle in ETB call");
   3400       post_event ((unsigned int)buffer,0,OMX_COMPONENT_GENERATE_EBD);
   3401       return OMX_ErrorBadParameter;
   3402     }
   3403 
   3404     struct pmem Input_pmem_info;
   3405     if(media_buffer->buffer_type == kMetadataBufferTypeCameraSource)
   3406     {
   3407       Input_pmem_info.buffer = media_buffer;
   3408       Input_pmem_info.fd = media_buffer->meta_handle->data[0];
   3409       Input_pmem_info.offset = media_buffer->meta_handle->data[1];
   3410       Input_pmem_info.size = media_buffer->meta_handle->data[2];
   3411       DEBUG_PRINT_LOW("ETB fd = %d, offset = %d, size = %d",Input_pmem_info.fd,
   3412                         Input_pmem_info.offset,
   3413                         Input_pmem_info.size);
   3414 
   3415     } else {
   3416       private_handle_t *handle = (private_handle_t *)media_buffer->meta_handle;
   3417       if(handle->format != HAL_PIXEL_FORMAT_NV12_ENCODEABLE) {
   3418         DEBUG_PRINT_ERROR("\n Incorrect pixel format");
   3419         post_event ((unsigned int)buffer,0,OMX_COMPONENT_GENERATE_EBD);
   3420         return OMX_ErrorBadParameter;
   3421       }
   3422       Input_pmem_info.buffer = media_buffer;
   3423       Input_pmem_info.fd = handle->fd;
   3424       Input_pmem_info.offset = 0;
   3425       Input_pmem_info.size = handle->size;
   3426     }
   3427     if(dev_use_buf(&Input_pmem_info,PORT_INDEX_IN,0) != true) {
   3428       DEBUG_PRINT_ERROR("\nERROR: in dev_use_buf");
   3429       post_event ((unsigned int)buffer,0,OMX_COMPONENT_GENERATE_EBD);
   3430       return OMX_ErrorBadParameter;
   3431     }
   3432   }
   3433   else if(input_use_buffer && !m_use_input_pmem)
   3434 #else
   3435   if(input_use_buffer && !m_use_input_pmem)
   3436 #endif
   3437   {
   3438     DEBUG_PRINT_LOW("\n Heap UseBuffer case, so memcpy the data");
   3439     pmem_data_buf = (OMX_U8 *)m_pInput_pmem[nBufIndex].buffer;
   3440 
   3441     memcpy (pmem_data_buf, (buffer->pBuffer + buffer->nOffset),
   3442             buffer->nFilledLen);
   3443     DEBUG_PRINT_LOW("memcpy() done in ETBProxy for i/p Heap UseBuf");
   3444   } else if (m_sInPortDef.format.video.eColorFormat ==
   3445       OMX_COLOR_FormatYUV420SemiPlanar && !mUseProxyColorFormat) {
   3446       //For the case where YUV420SP buffers are qeueued to component
   3447       //by sources other than camera (Apps via MediaCodec), alignment
   3448       //of chroma-plane to 2K is necessary.
   3449       //For RGB buffers, color-conversion takes care of such alignment
   3450       OMX_U32 width = m_sInPortDef.format.video.nFrameWidth;
   3451       OMX_U32 height = m_sInPortDef.format.video.nFrameHeight;
   3452       OMX_U32 chromaOffset = width * height;
   3453       if (IS_NOT_ALIGNED(chromaOffset, SZ_2K)) {
   3454           OMX_U32 chromaSize = (width * height)/2;
   3455           chromaOffset = ALIGN(chromaOffset,SZ_2K);
   3456           if (buffer->nAllocLen >= chromaOffset + chromaSize) {
   3457               OMX_U8* buf = buffer->pBuffer;
   3458               memmove(buf + chromaOffset, buf + (width*height), chromaSize);
   3459           } else {
   3460              DEBUG_PRINT_ERROR("Failed to align Chroma. from %u to %u : \
   3461                  Insufficient bufferLen=%u v/s Required=%u",
   3462                  (width*height), chromaOffset, buffer->nAllocLen,
   3463                  chromaOffset+chromaSize);
   3464           }
   3465       }
   3466   }
   3467 #ifdef _COPPER_
   3468   if(dev_empty_buf(buffer, pmem_data_buf,nBufIndex,m_pInput_pmem[nBufIndex].fd) != true)
   3469 #else
   3470   if(dev_empty_buf(buffer, pmem_data_buf,0,0) != true)
   3471 #endif
   3472   {
   3473     DEBUG_PRINT_ERROR("\nERROR: ETBProxy: dev_empty_buf failed");
   3474 #ifdef _ANDROID_ICS_
   3475     omx_release_meta_buffer(buffer);
   3476 #endif
   3477     post_event ((unsigned int)buffer,0,OMX_COMPONENT_GENERATE_EBD);
   3478     /*Generate an async error and move to invalid state*/
   3479     pending_input_buffers--;
   3480     return OMX_ErrorBadParameter;
   3481   }
   3482 
   3483   return ret;
   3484 }
   3485 
   3486 /* ======================================================================
   3487 FUNCTION
   3488   omx_video::FillThisBuffer
   3489 
   3490 DESCRIPTION
   3491   IL client uses this method to release the frame buffer
   3492   after displaying them.
   3493 
   3494 PARAMETERS
   3495   None.
   3496 
   3497 RETURN VALUE
   3498   true/false
   3499 
   3500 ========================================================================== */
   3501 OMX_ERRORTYPE  omx_video::fill_this_buffer(OMX_IN OMX_HANDLETYPE  hComp,
   3502                                            OMX_IN OMX_BUFFERHEADERTYPE* buffer)
   3503 {
   3504   DEBUG_PRINT_LOW("\n FTB: buffer->pBuffer[%p]\n", buffer->pBuffer);
   3505   if(m_state == OMX_StateInvalid)
   3506   {
   3507     DEBUG_PRINT_ERROR("ERROR: FTB in Invalid State\n");
   3508     return OMX_ErrorInvalidState;
   3509   }
   3510 
   3511   if (buffer == NULL ||(buffer->nSize != sizeof(OMX_BUFFERHEADERTYPE)))
   3512   {
   3513     DEBUG_PRINT_ERROR("ERROR: omx_video::ftb-->Invalid buffer or size\n");
   3514     return OMX_ErrorBadParameter;
   3515   }
   3516 
   3517   if(buffer->nVersion.nVersion != OMX_SPEC_VERSION)
   3518   {
   3519     DEBUG_PRINT_ERROR("ERROR: omx_video::ftb-->OMX Version Invalid\n");
   3520     return OMX_ErrorVersionMismatch;
   3521   }
   3522 
   3523   if (buffer->nOutputPortIndex != (OMX_U32)PORT_INDEX_OUT)
   3524   {
   3525     DEBUG_PRINT_ERROR("ERROR: omx_video::ftb-->Bad port index\n");
   3526     return OMX_ErrorBadPortIndex;
   3527   }
   3528 
   3529   if(!m_sOutPortDef.bEnabled)
   3530   {
   3531     DEBUG_PRINT_ERROR("ERROR: omx_video::ftb-->port is disabled\n");
   3532     return OMX_ErrorIncorrectStateOperation;
   3533   }
   3534 
   3535   post_event((unsigned) hComp, (unsigned)buffer,OMX_COMPONENT_GENERATE_FTB);
   3536   return OMX_ErrorNone;
   3537 }
   3538 
   3539 /* ======================================================================
   3540 FUNCTION
   3541   omx_video::fill_this_buffer_proxy
   3542 
   3543 DESCRIPTION
   3544   IL client uses this method to release the frame buffer
   3545   after displaying them.
   3546 
   3547 PARAMETERS
   3548   None.
   3549 
   3550 RETURN VALUE
   3551   true/false
   3552 
   3553 ========================================================================== */
   3554 OMX_ERRORTYPE  omx_video::fill_this_buffer_proxy(
   3555                                                 OMX_IN OMX_HANDLETYPE        hComp,
   3556                                                 OMX_IN OMX_BUFFERHEADERTYPE* bufferAdd)
   3557 {
   3558   OMX_U8 *pmem_data_buf = NULL;
   3559   OMX_ERRORTYPE nRet = OMX_ErrorNone;
   3560 
   3561   DEBUG_PRINT_LOW("\n FTBProxy: bufferAdd->pBuffer[%p]\n", bufferAdd->pBuffer);
   3562 
   3563   if(bufferAdd == NULL || ((bufferAdd - m_out_mem_ptr) >= m_sOutPortDef.nBufferCountActual) )
   3564   {
   3565     DEBUG_PRINT_ERROR("\nERROR: FTBProxy: Invalid i/p params\n");
   3566     return OMX_ErrorBadParameter;
   3567   }
   3568 
   3569   pending_output_buffers++;
   3570   /*Return back the output buffer to client*/
   3571   if( m_sOutPortDef.bEnabled != OMX_TRUE || output_flush_progress == true)
   3572   {
   3573     DEBUG_PRINT_LOW("\n o/p port is Disabled or Flush in Progress");
   3574     post_event ((unsigned int)bufferAdd,0,
   3575                 OMX_COMPONENT_GENERATE_FBD);
   3576     return OMX_ErrorNone;
   3577   }
   3578 
   3579   if(output_use_buffer && !m_use_output_pmem)
   3580   {
   3581     DEBUG_PRINT_LOW("\n Heap UseBuffer case");
   3582     pmem_data_buf = (OMX_U8 *)m_pOutput_pmem[bufferAdd - m_out_mem_ptr].buffer;
   3583   }
   3584 
   3585   if(dev_fill_buf(bufferAdd, pmem_data_buf,(bufferAdd - m_out_mem_ptr),m_pOutput_pmem[bufferAdd - m_out_mem_ptr].fd) != true)
   3586   {
   3587     DEBUG_PRINT_ERROR("\nERROR: dev_fill_buf() Failed");
   3588     post_event ((unsigned int)bufferAdd,0,OMX_COMPONENT_GENERATE_FBD);
   3589     pending_output_buffers--;
   3590     return OMX_ErrorBadParameter;
   3591   }
   3592 
   3593   return OMX_ErrorNone;
   3594 }
   3595 
   3596 /* ======================================================================
   3597 FUNCTION
   3598   omx_video::SetCallbacks
   3599 
   3600 DESCRIPTION
   3601   Set the callbacks.
   3602 
   3603 PARAMETERS
   3604   None.
   3605 
   3606 RETURN VALUE
   3607   OMX Error None if everything successful.
   3608 
   3609 ========================================================================== */
   3610 OMX_ERRORTYPE  omx_video::set_callbacks(OMX_IN OMX_HANDLETYPE        hComp,
   3611                                         OMX_IN OMX_CALLBACKTYPE* callbacks,
   3612                                         OMX_IN OMX_PTR             appData)
   3613 {
   3614 
   3615   m_pCallbacks       = *callbacks;
   3616   DEBUG_PRINT_LOW("\n Callbacks Set %p %p %p",m_pCallbacks.EmptyBufferDone,\
   3617                m_pCallbacks.EventHandler,m_pCallbacks.FillBufferDone);
   3618   m_app_data =    appData;
   3619   return OMX_ErrorNotImplemented;
   3620 }
   3621 
   3622 
   3623 /* ======================================================================
   3624 FUNCTION
   3625   omx_venc::UseEGLImage
   3626 
   3627 DESCRIPTION
   3628   OMX Use EGL Image method implementation <TBD>.
   3629 
   3630 PARAMETERS
   3631   <TBD>.
   3632 
   3633 RETURN VALUE
   3634   Not Implemented error.
   3635 
   3636 ========================================================================== */
   3637 OMX_ERRORTYPE  omx_video::use_EGL_image(OMX_IN OMX_HANDLETYPE                hComp,
   3638                                         OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
   3639                                         OMX_IN OMX_U32                        port,
   3640                                         OMX_IN OMX_PTR                     appData,
   3641                                         OMX_IN void*                      eglImage)
   3642 {
   3643   DEBUG_PRINT_ERROR("ERROR: use_EGL_image:  Not Implemented \n");
   3644   return OMX_ErrorNotImplemented;
   3645 }
   3646 
   3647 /* ======================================================================
   3648 FUNCTION
   3649   omx_venc::ComponentRoleEnum
   3650 
   3651 DESCRIPTION
   3652   OMX Component Role Enum method implementation.
   3653 
   3654 PARAMETERS
   3655   <TBD>.
   3656 
   3657 RETURN VALUE
   3658   OMX Error None if everything is successful.
   3659 ========================================================================== */
   3660 OMX_ERRORTYPE  omx_video::component_role_enum(OMX_IN OMX_HANDLETYPE hComp,
   3661                                               OMX_OUT OMX_U8*        role,
   3662                                               OMX_IN OMX_U32        index)
   3663 {
   3664   OMX_ERRORTYPE eRet = OMX_ErrorNone;
   3665   if(!strncmp((char*)m_nkind, "OMX.qcom.video.decoder.mpeg4",OMX_MAX_STRINGNAME_SIZE))
   3666   {
   3667     if((0 == index) && role)
   3668     {
   3669       strlcpy((char *)role, "video_decoder.mpeg4",OMX_MAX_STRINGNAME_SIZE);
   3670       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
   3671     }
   3672     else
   3673     {
   3674       eRet = OMX_ErrorNoMore;
   3675     }
   3676   }
   3677   else if(!strncmp((char*)m_nkind, "OMX.qcom.video.decoder.h263",OMX_MAX_STRINGNAME_SIZE))
   3678   {
   3679     if((0 == index) && role)
   3680     {
   3681       strlcpy((char *)role, "video_decoder.h263",OMX_MAX_STRINGNAME_SIZE);
   3682       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
   3683     }
   3684     else
   3685     {
   3686       DEBUG_PRINT_ERROR("\nERROR: No more roles \n");
   3687       eRet = OMX_ErrorNoMore;
   3688     }
   3689   }
   3690   else if(!strncmp((char*)m_nkind, "OMX.qcom.video.decoder.avc",OMX_MAX_STRINGNAME_SIZE))
   3691   {
   3692     if((0 == index) && role)
   3693     {
   3694       strlcpy((char *)role, "video_decoder.avc",OMX_MAX_STRINGNAME_SIZE);
   3695       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
   3696     }
   3697     else
   3698     {
   3699       DEBUG_PRINT_ERROR("\nERROR: No more roles \n");
   3700       eRet = OMX_ErrorNoMore;
   3701     }
   3702   }
   3703   else if(!strncmp((char*)m_nkind, "OMX.qcom.video.decoder.vc1",OMX_MAX_STRINGNAME_SIZE))
   3704   {
   3705     if((0 == index) && role)
   3706     {
   3707       strlcpy((char *)role, "video_decoder.vc1",OMX_MAX_STRINGNAME_SIZE);
   3708       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
   3709     }
   3710     else
   3711     {
   3712       DEBUG_PRINT_ERROR("\nERROR: No more roles \n");
   3713       eRet = OMX_ErrorNoMore;
   3714     }
   3715   }
   3716   if(!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE))
   3717   {
   3718     if((0 == index) && role)
   3719     {
   3720       strlcpy((char *)role, "video_encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE);
   3721       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
   3722     }
   3723     else
   3724     {
   3725       eRet = OMX_ErrorNoMore;
   3726     }
   3727   }
   3728   else if(!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.h263",OMX_MAX_STRINGNAME_SIZE))
   3729   {
   3730     if((0 == index) && role)
   3731     {
   3732       strlcpy((char *)role, "video_encoder.h263",OMX_MAX_STRINGNAME_SIZE);
   3733       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
   3734     }
   3735     else
   3736     {
   3737       DEBUG_PRINT_ERROR("\nERROR: No more roles \n");
   3738       eRet = OMX_ErrorNoMore;
   3739     }
   3740   }
   3741   else if(!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.avc",OMX_MAX_STRINGNAME_SIZE))
   3742   {
   3743     if((0 == index) && role)
   3744     {
   3745       strlcpy((char *)role, "video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
   3746       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
   3747     }
   3748     else
   3749     {
   3750       DEBUG_PRINT_ERROR("\nERROR: No more roles \n");
   3751       eRet = OMX_ErrorNoMore;
   3752     }
   3753   }
   3754   else
   3755   {
   3756     DEBUG_PRINT_ERROR("\nERROR: Querying Role on Unknown Component\n");
   3757     eRet = OMX_ErrorInvalidComponentName;
   3758   }
   3759   return eRet;
   3760 }
   3761 
   3762 
   3763 
   3764 
   3765 /* ======================================================================
   3766 FUNCTION
   3767   omx_venc::AllocateDone
   3768 
   3769 DESCRIPTION
   3770   Checks if entire buffer pool is allocated by IL Client or not.
   3771   Need this to move to IDLE state.
   3772 
   3773 PARAMETERS
   3774   None.
   3775 
   3776 RETURN VALUE
   3777   true/false.
   3778 
   3779 ========================================================================== */
   3780 bool omx_video::allocate_done(void)
   3781 {
   3782   bool bRet = false;
   3783   bool bRet_In = false;
   3784   bool bRet_Out = false;
   3785 
   3786   bRet_In = allocate_input_done();
   3787   bRet_Out = allocate_output_done();
   3788 
   3789   if(bRet_In && bRet_Out)
   3790   {
   3791     bRet = true;
   3792   }
   3793 
   3794   return bRet;
   3795 }
   3796 /* ======================================================================
   3797 FUNCTION
   3798   omx_venc::AllocateInputDone
   3799 
   3800 DESCRIPTION
   3801   Checks if I/P buffer pool is allocated by IL Client or not.
   3802 
   3803 PARAMETERS
   3804   None.
   3805 
   3806 RETURN VALUE
   3807   true/false.
   3808 
   3809 ========================================================================== */
   3810 bool omx_video::allocate_input_done(void)
   3811 {
   3812   bool bRet = false;
   3813   unsigned i=0;
   3814 
   3815   if(m_inp_mem_ptr == NULL)
   3816   {
   3817     return bRet;
   3818   }
   3819   if(m_inp_mem_ptr )
   3820   {
   3821     for(;i<m_sInPortDef.nBufferCountActual;i++)
   3822     {
   3823       if(BITMASK_ABSENT(&m_inp_bm_count,i))
   3824       {
   3825         break;
   3826       }
   3827     }
   3828   }
   3829   if(i==m_sInPortDef.nBufferCountActual)
   3830   {
   3831     bRet = true;
   3832   }
   3833   if(i==m_sInPortDef.nBufferCountActual && m_sInPortDef.bEnabled)
   3834   {
   3835     m_sInPortDef.bPopulated = OMX_TRUE;
   3836   }
   3837   return bRet;
   3838 }
   3839 /* ======================================================================
   3840 FUNCTION
   3841   omx_venc::AllocateOutputDone
   3842 
   3843 DESCRIPTION
   3844   Checks if entire O/P buffer pool is allocated by IL Client or not.
   3845 
   3846 PARAMETERS
   3847   None.
   3848 
   3849 RETURN VALUE
   3850   true/false.
   3851 
   3852 ========================================================================== */
   3853 bool omx_video::allocate_output_done(void)
   3854 {
   3855   bool bRet = false;
   3856   unsigned j=0;
   3857 
   3858   if(m_out_mem_ptr == NULL)
   3859   {
   3860     return bRet;
   3861   }
   3862 
   3863   if(m_out_mem_ptr )
   3864   {
   3865     for(;j<m_sOutPortDef.nBufferCountActual;j++)
   3866     {
   3867       if(BITMASK_ABSENT(&m_out_bm_count,j))
   3868       {
   3869         break;
   3870       }
   3871     }
   3872   }
   3873 
   3874   if(j==m_sOutPortDef.nBufferCountActual)
   3875   {
   3876     bRet = true;
   3877   }
   3878 
   3879   if(j==m_sOutPortDef.nBufferCountActual && m_sOutPortDef.bEnabled)
   3880   {
   3881     m_sOutPortDef.bPopulated = OMX_TRUE;
   3882   }
   3883   return bRet;
   3884 }
   3885 
   3886 /* ======================================================================
   3887 FUNCTION
   3888   omx_venc::ReleaseDone
   3889 
   3890 DESCRIPTION
   3891   Checks if IL client has released all the buffers.
   3892 
   3893 PARAMETERS
   3894   None.
   3895 
   3896 RETURN VALUE
   3897   true/false
   3898 
   3899 ========================================================================== */
   3900 bool omx_video::release_done(void)
   3901 {
   3902   bool bRet = false;
   3903   DEBUG_PRINT_LOW("Inside release_done()\n");
   3904   if(release_input_done())
   3905   {
   3906     if(release_output_done())
   3907     {
   3908       bRet = true;
   3909     }
   3910   }
   3911   return bRet;
   3912 }
   3913 
   3914 
   3915 /* ======================================================================
   3916 FUNCTION
   3917   omx_venc::ReleaseOutputDone
   3918 
   3919 DESCRIPTION
   3920   Checks if IL client has released all the buffers.
   3921 
   3922 PARAMETERS
   3923   None.
   3924 
   3925 RETURN VALUE
   3926   true/false
   3927 
   3928 ========================================================================== */
   3929 bool omx_video::release_output_done(void)
   3930 {
   3931   bool bRet = false;
   3932   unsigned i=0,j=0;
   3933 
   3934   DEBUG_PRINT_LOW("Inside release_output_done()\n");
   3935   if(m_out_mem_ptr)
   3936   {
   3937     for(;j<m_sOutPortDef.nBufferCountActual;j++)
   3938     {
   3939       if(BITMASK_PRESENT(&m_out_bm_count,j))
   3940       {
   3941         break;
   3942       }
   3943     }
   3944     if(j==m_sOutPortDef.nBufferCountActual)
   3945     {
   3946       bRet = true;
   3947     }
   3948   }
   3949   else
   3950   {
   3951     bRet = true;
   3952   }
   3953   return bRet;
   3954 }
   3955 /* ======================================================================
   3956 FUNCTION
   3957   omx_venc::ReleaseInputDone
   3958 
   3959 DESCRIPTION
   3960   Checks if IL client has released all the buffers.
   3961 
   3962 PARAMETERS
   3963   None.
   3964 
   3965 RETURN VALUE
   3966   true/false
   3967 
   3968 ========================================================================== */
   3969 bool omx_video::release_input_done(void)
   3970 {
   3971   bool bRet = false;
   3972   unsigned i=0,j=0;
   3973 
   3974   DEBUG_PRINT_LOW("Inside release_input_done()\n");
   3975   if(m_inp_mem_ptr)
   3976   {
   3977     for(;j<m_sInPortDef.nBufferCountActual;j++)
   3978     {
   3979       if( BITMASK_PRESENT(&m_inp_bm_count,j))
   3980       {
   3981         break;
   3982       }
   3983     }
   3984     if(j==m_sInPortDef.nBufferCountActual)
   3985     {
   3986       bRet = true;
   3987     }
   3988   }
   3989   else
   3990   {
   3991     bRet = true;
   3992   }
   3993   return bRet;
   3994 }
   3995 
   3996 OMX_ERRORTYPE omx_video::fill_buffer_done(OMX_HANDLETYPE hComp,
   3997                                           OMX_BUFFERHEADERTYPE * buffer)
   3998 {
   3999   DEBUG_PRINT_LOW("fill_buffer_done: buffer->pBuffer[%p], flags=0x%x size = %d",
   4000      buffer->pBuffer, buffer->nFlags,buffer->nFilledLen);
   4001   if(buffer == NULL || ((buffer - m_out_mem_ptr) > m_sOutPortDef.nBufferCountActual))
   4002   {
   4003     return OMX_ErrorBadParameter;
   4004   }
   4005 
   4006   pending_output_buffers--;
   4007   if(!secure_session)
   4008   {
   4009     extra_data_handle.create_extra_data(buffer);
   4010   }
   4011 
   4012   if (!secure_session && m_sDebugSliceinfo) {
   4013     if(buffer->nFlags & OMX_BUFFERFLAG_EXTRADATA) {
   4014        DEBUG_PRINT_HIGH("parsing extradata");
   4015        extra_data_handle.parse_extra_data(buffer);
   4016     }
   4017   }
   4018   /* For use buffer we need to copy the data */
   4019   if(m_pCallbacks.FillBufferDone)
   4020   {
   4021     if(buffer->nFilledLen > 0)
   4022     {
   4023       m_fbd_count++;
   4024 
   4025 #ifdef OUTPUT_BUFFER_LOG
   4026       if(outputBufferFile1)
   4027       {
   4028         fwrite((const char *)buffer->pBuffer, buffer->nFilledLen, 1, outputBufferFile1);
   4029       }
   4030 #endif
   4031     }
   4032     m_pCallbacks.FillBufferDone (hComp,m_app_data,buffer);
   4033   }
   4034   else
   4035   {
   4036     return OMX_ErrorBadParameter;
   4037   }
   4038   return OMX_ErrorNone;
   4039 }
   4040 
   4041 OMX_ERRORTYPE omx_video::empty_buffer_done(OMX_HANDLETYPE         hComp,
   4042                                            OMX_BUFFERHEADERTYPE* buffer)
   4043 {
   4044   int buffer_index  = -1;
   4045   int buffer_index_meta = -1;
   4046 
   4047   buffer_index = (buffer - m_inp_mem_ptr);
   4048   buffer_index_meta = (buffer - meta_buffer_hdr);
   4049   DEBUG_PRINT_LOW("\n empty_buffer_done: buffer[%p]", buffer);
   4050   if(buffer == NULL ||
   4051      ((buffer_index > m_sInPortDef.nBufferCountActual) &&
   4052       (buffer_index_meta > m_sInPortDef.nBufferCountActual)))
   4053   {
   4054     DEBUG_PRINT_ERROR("\n ERROR in empty_buffer_done due to index buffer");
   4055     return OMX_ErrorBadParameter;
   4056   }
   4057 
   4058   pending_input_buffers--;
   4059 
   4060   if(mUseProxyColorFormat && (buffer_index < m_sInPortDef.nBufferCountActual)) {
   4061     if(!pdest_frame) {
   4062       pdest_frame = buffer;
   4063       DEBUG_PRINT_LOW("\n empty_buffer_done pdest_frame address is %p",pdest_frame);
   4064       return push_input_buffer(hComp);
   4065 
   4066     } else {
   4067       DEBUG_PRINT_LOW("\n empty_buffer_done insert address is %p",buffer);
   4068       if (!m_opq_pmem_q.insert_entry((unsigned int)buffer, 0, 0)) {
   4069         DEBUG_PRINT_ERROR("\n empty_buffer_done: pmem queue is full");
   4070         return OMX_ErrorBadParameter;
   4071       }
   4072     }
   4073   } else if(m_pCallbacks.EmptyBufferDone) {
   4074     m_pCallbacks.EmptyBufferDone(hComp ,m_app_data, buffer);
   4075   }
   4076   return OMX_ErrorNone;
   4077 }
   4078 
   4079 void omx_video::complete_pending_buffer_done_cbs()
   4080 {
   4081   unsigned p1;
   4082   unsigned p2;
   4083   unsigned ident;
   4084   omx_cmd_queue tmp_q, pending_bd_q;
   4085   pthread_mutex_lock(&m_lock);
   4086   // pop all pending GENERATE FDB from ftb queue
   4087   while (m_ftb_q.m_size)
   4088   {
   4089     m_ftb_q.pop_entry(&p1,&p2,&ident);
   4090     if(ident == OMX_COMPONENT_GENERATE_FBD)
   4091     {
   4092       pending_bd_q.insert_entry(p1,p2,ident);
   4093     }
   4094     else
   4095     {
   4096       tmp_q.insert_entry(p1,p2,ident);
   4097     }
   4098   }
   4099   //return all non GENERATE FDB to ftb queue
   4100   while(tmp_q.m_size)
   4101   {
   4102     tmp_q.pop_entry(&p1,&p2,&ident);
   4103     m_ftb_q.insert_entry(p1,p2,ident);
   4104   }
   4105   // pop all pending GENERATE EDB from etb queue
   4106   while (m_etb_q.m_size)
   4107   {
   4108     m_etb_q.pop_entry(&p1,&p2,&ident);
   4109     if(ident == OMX_COMPONENT_GENERATE_EBD)
   4110     {
   4111       pending_bd_q.insert_entry(p1,p2,ident);
   4112     }
   4113     else
   4114     {
   4115       tmp_q.insert_entry(p1,p2,ident);
   4116     }
   4117   }
   4118   //return all non GENERATE FDB to etb queue
   4119   while(tmp_q.m_size)
   4120   {
   4121     tmp_q.pop_entry(&p1,&p2,&ident);
   4122     m_etb_q.insert_entry(p1,p2,ident);
   4123   }
   4124   pthread_mutex_unlock(&m_lock);
   4125   // process all pending buffer dones
   4126   while(pending_bd_q.m_size)
   4127   {
   4128     pending_bd_q.pop_entry(&p1,&p2,&ident);
   4129     switch(ident)
   4130     {
   4131     case OMX_COMPONENT_GENERATE_EBD:
   4132         if(empty_buffer_done(&m_cmp, (OMX_BUFFERHEADERTYPE *)p1) != OMX_ErrorNone)
   4133         {
   4134           DEBUG_PRINT_ERROR("\nERROR: empty_buffer_done() failed!\n");
   4135           omx_report_error ();
   4136         }
   4137         break;
   4138 
   4139       case OMX_COMPONENT_GENERATE_FBD:
   4140         if(fill_buffer_done(&m_cmp, (OMX_BUFFERHEADERTYPE *)p1) != OMX_ErrorNone )
   4141         {
   4142           DEBUG_PRINT_ERROR("\nERROR: fill_buffer_done() failed!\n");
   4143           omx_report_error ();
   4144         }
   4145         break;
   4146     }
   4147   }
   4148 }
   4149 
   4150 #ifdef MAX_RES_720P
   4151 OMX_ERRORTYPE omx_video::get_supported_profile_level(OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevelType)
   4152 {
   4153   OMX_ERRORTYPE eRet = OMX_ErrorNone;
   4154   if(!profileLevelType)
   4155     return OMX_ErrorBadParameter;
   4156 
   4157   if(profileLevelType->nPortIndex == 1) {
   4158     if (m_sOutPortDef.format.video.eCompressionFormat == OMX_VIDEO_CodingAVC)
   4159     {
   4160       if (profileLevelType->nProfileIndex == 0)
   4161       {
   4162         profileLevelType->eProfile = OMX_VIDEO_AVCProfileBaseline;
   4163         profileLevelType->eLevel   = OMX_VIDEO_AVCLevel31;
   4164       }
   4165       else if (profileLevelType->nProfileIndex == 1)
   4166       {
   4167         profileLevelType->eProfile = OMX_VIDEO_AVCProfileMain;
   4168         profileLevelType->eLevel   = OMX_VIDEO_AVCLevel31;
   4169       }
   4170       else if(profileLevelType->nProfileIndex == 2)
   4171       {
   4172         profileLevelType->eProfile = OMX_VIDEO_AVCProfileHigh;
   4173         profileLevelType->eLevel   = OMX_VIDEO_AVCLevel31;
   4174       }
   4175       else
   4176       {
   4177         DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported nProfileIndex ret NoMore %d\n",
   4178             profileLevelType->nProfileIndex);
   4179         eRet = OMX_ErrorNoMore;
   4180       }
   4181     }
   4182     else if (m_sOutPortDef.format.video.eCompressionFormat == OMX_VIDEO_CodingH263)
   4183     {
   4184       if (profileLevelType->nProfileIndex == 0)
   4185       {
   4186         profileLevelType->eProfile = OMX_VIDEO_H263ProfileBaseline;
   4187         profileLevelType->eLevel   = OMX_VIDEO_H263Level70;
   4188       }
   4189       else
   4190       {
   4191         DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported nProfileIndex ret NoMore %d\n", profileLevelType->nProfileIndex);
   4192         eRet = OMX_ErrorNoMore;
   4193       }
   4194     }
   4195     else if(m_sOutPortDef.format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4)
   4196     {
   4197       if (profileLevelType->nProfileIndex == 0)
   4198       {
   4199         profileLevelType->eProfile = OMX_VIDEO_MPEG4ProfileSimple;
   4200         profileLevelType->eLevel   = OMX_VIDEO_MPEG4Level5;
   4201       }
   4202       else if(profileLevelType->nProfileIndex == 1)
   4203       {
   4204         profileLevelType->eProfile = OMX_VIDEO_MPEG4ProfileAdvancedSimple;
   4205         profileLevelType->eLevel   = OMX_VIDEO_MPEG4Level5;
   4206       }
   4207       else
   4208       {
   4209         DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported nProfileIndex ret NoMore %d\n", profileLevelType->nProfileIndex);
   4210         eRet = OMX_ErrorNoMore;
   4211       }
   4212     }
   4213   }
   4214   else
   4215   {
   4216     DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported should be queries on Input port only %d\n", profileLevelType->nPortIndex);
   4217     eRet = OMX_ErrorBadPortIndex;
   4218   }
   4219   DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported for Input port returned Profile:%d, Level:%d\n",
   4220                     profileLevelType->eProfile,profileLevelType->eLevel);
   4221   return eRet;
   4222 }
   4223 #endif
   4224 
   4225 #ifdef MAX_RES_1080P
   4226 OMX_ERRORTYPE omx_video::get_supported_profile_level(OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevelType)
   4227 {
   4228   OMX_ERRORTYPE eRet = OMX_ErrorNone;
   4229   if(!profileLevelType)
   4230     return OMX_ErrorBadParameter;
   4231 
   4232   if(profileLevelType->nPortIndex == 1) {
   4233     if (m_sOutPortDef.format.video.eCompressionFormat == OMX_VIDEO_CodingAVC)
   4234     {
   4235       if (profileLevelType->nProfileIndex == 0)
   4236       {
   4237         profileLevelType->eProfile = OMX_VIDEO_AVCProfileBaseline;
   4238         profileLevelType->eLevel   = OMX_VIDEO_AVCLevel4;
   4239 
   4240       }
   4241       else if (profileLevelType->nProfileIndex == 1)
   4242       {
   4243         profileLevelType->eProfile = OMX_VIDEO_AVCProfileMain;
   4244         profileLevelType->eLevel   = OMX_VIDEO_AVCLevel4;
   4245       }
   4246       else if(profileLevelType->nProfileIndex == 2)
   4247       {
   4248         profileLevelType->eProfile = OMX_VIDEO_AVCProfileHigh;
   4249         profileLevelType->eLevel   = OMX_VIDEO_AVCLevel4;
   4250       }
   4251       else
   4252       {
   4253         DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported nProfileIndex ret NoMore %d\n",
   4254             profileLevelType->nProfileIndex);
   4255         eRet = OMX_ErrorNoMore;
   4256       }
   4257     }
   4258     else if (m_sOutPortDef.format.video.eCompressionFormat == OMX_VIDEO_CodingH263)
   4259     {
   4260       if (profileLevelType->nProfileIndex == 0)
   4261       {
   4262         profileLevelType->eProfile = OMX_VIDEO_H263ProfileBaseline;
   4263         profileLevelType->eLevel   = OMX_VIDEO_H263Level70;
   4264       }
   4265       else
   4266       {
   4267         DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported nProfileIndex ret NoMore %d\n", profileLevelType->nProfileIndex);
   4268         eRet = OMX_ErrorNoMore;
   4269       }
   4270     }
   4271     else if(m_sOutPortDef.format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4)
   4272     {
   4273       if (profileLevelType->nProfileIndex == 0)
   4274       {
   4275         profileLevelType->eProfile = OMX_VIDEO_MPEG4ProfileSimple;
   4276         profileLevelType->eLevel   = OMX_VIDEO_MPEG4Level5;
   4277       }
   4278       else if(profileLevelType->nProfileIndex == 1)
   4279       {
   4280         profileLevelType->eProfile = OMX_VIDEO_MPEG4ProfileAdvancedSimple;
   4281         profileLevelType->eLevel   = OMX_VIDEO_MPEG4Level5;
   4282       }
   4283       else
   4284       {
   4285         DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported nProfileIndex ret NoMore %d\n", profileLevelType->nProfileIndex);
   4286         eRet = OMX_ErrorNoMore;
   4287       }
   4288     }
   4289   }
   4290   else
   4291   {
   4292     DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported should be queries on Input port only %d\n", profileLevelType->nPortIndex);
   4293     eRet = OMX_ErrorBadPortIndex;
   4294   }
   4295   DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamVideoProfileLevelQuerySupported for Input port returned Profile:%d, Level:%d\n",
   4296                     profileLevelType->eProfile,profileLevelType->eLevel);
   4297   return eRet;
   4298 }
   4299 
   4300 #ifdef USE_ION
   4301 int omx_video::alloc_map_ion_memory(int size,struct ion_allocation_data *alloc_data,
   4302                                     struct ion_fd_data *fd_data,int flag)
   4303 {
   4304   struct venc_ion buf_ion_info;
   4305   int ion_device_fd =-1,rc=0,ion_dev_flags = 0;
   4306   if (size <=0 || !alloc_data || !fd_data) {
   4307     DEBUG_PRINT_ERROR("\nInvalid input to alloc_map_ion_memory");
   4308     return -EINVAL;
   4309 	}
   4310     ion_dev_flags = O_RDONLY;
   4311         ion_device_fd = open (MEM_DEVICE,ion_dev_flags);
   4312         if(ion_device_fd < 0)
   4313         {
   4314            DEBUG_PRINT_ERROR("\nERROR: ION Device open() Failed");
   4315            return ion_device_fd;
   4316         }
   4317         alloc_data->len = size;
   4318         alloc_data->align = 4096;
   4319         alloc_data->flags = 0;
   4320         if(!secure_session && (flag & ION_FLAG_CACHED))
   4321         {
   4322           alloc_data->flags = ION_FLAG_CACHED;
   4323         }
   4324 
   4325         if (secure_session)
   4326            alloc_data->heap_mask = (ION_HEAP(MEM_HEAP_ID) | ION_SECURE);
   4327         else
   4328            alloc_data->heap_mask = (ION_HEAP(MEM_HEAP_ID) |
   4329                 ION_HEAP(ION_IOMMU_HEAP_ID));
   4330 
   4331         rc = ioctl(ion_device_fd,ION_IOC_ALLOC,alloc_data);
   4332         if(rc || !alloc_data->handle) {
   4333            DEBUG_PRINT_ERROR("\n ION ALLOC memory failed ");
   4334            alloc_data->handle =NULL;
   4335            close(ion_device_fd);
   4336            ion_device_fd = -1;
   4337            return ion_device_fd;
   4338         }
   4339         fd_data->handle = alloc_data->handle;
   4340         rc = ioctl(ion_device_fd,ION_IOC_MAP,fd_data);
   4341         if(rc) {
   4342             DEBUG_PRINT_ERROR("\n ION MAP failed ");
   4343             buf_ion_info.ion_alloc_data = *alloc_data;
   4344             buf_ion_info.ion_device_fd = ion_device_fd;
   4345             buf_ion_info.fd_ion_data = *fd_data;
   4346             free_ion_memory(&buf_ion_info);
   4347             fd_data->fd =-1;
   4348             ion_device_fd =-1;
   4349         }
   4350         return ion_device_fd;
   4351 }
   4352 
   4353 void omx_video::free_ion_memory(struct venc_ion *buf_ion_info)
   4354 {
   4355      if (!buf_ion_info) {
   4356         DEBUG_PRINT_ERROR("\n Invalid input to free_ion_memory");
   4357         return;
   4358      }
   4359      if (ioctl(buf_ion_info->ion_device_fd,ION_IOC_FREE,
   4360               &buf_ion_info->ion_alloc_data.handle)) {
   4361          DEBUG_PRINT_ERROR("\n ION free failed ");
   4362          return;
   4363      }
   4364      close(buf_ion_info->ion_device_fd);
   4365      buf_ion_info->ion_alloc_data.handle = NULL;
   4366      buf_ion_info->ion_device_fd = -1;
   4367      buf_ion_info->fd_ion_data.fd = -1;
   4368 }
   4369 #endif
   4370 #endif
   4371 #ifdef _ANDROID_ICS_
   4372 void omx_video::omx_release_meta_buffer(OMX_BUFFERHEADERTYPE *buffer)
   4373 {
   4374   if(buffer && meta_mode_enable)
   4375   {
   4376     encoder_media_buffer_type *media_ptr;
   4377     struct pmem Input_pmem;
   4378     unsigned int index_pmem = 0;
   4379     bool meta_error = false;
   4380 
   4381     index_pmem = (buffer - m_inp_mem_ptr);
   4382     if(mUseProxyColorFormat &&
   4383        (index_pmem < m_sInPortDef.nBufferCountActual)) {
   4384         if(!dev_free_buf((&m_pInput_pmem[index_pmem]),PORT_INDEX_IN)){
   4385           DEBUG_PRINT_ERROR("\n omx_release_meta_buffer dev free failed");
   4386         }
   4387     } else {
   4388       media_ptr = (encoder_media_buffer_type *) buffer->pBuffer;
   4389       if(media_ptr && media_ptr->meta_handle)
   4390       {
   4391         if(media_ptr->buffer_type == kMetadataBufferTypeCameraSource &&
   4392            media_ptr->meta_handle->numFds == 1 &&
   4393            media_ptr->meta_handle->numInts == 2) {
   4394           Input_pmem.fd = media_ptr->meta_handle->data[0];
   4395           Input_pmem.buffer = media_ptr;
   4396           Input_pmem.size = media_ptr->meta_handle->data[2];
   4397           Input_pmem.offset = media_ptr->meta_handle->data[1];
   4398           DEBUG_PRINT_LOW("EBD fd = %d, offset = %d, size = %d",Input_pmem.fd,
   4399                             Input_pmem.offset,
   4400                             Input_pmem.size);
   4401         } else if(media_ptr->buffer_type == kMetadataBufferTypeGrallocSource) {
   4402           private_handle_t *handle = (private_handle_t *)media_ptr->meta_handle;
   4403           Input_pmem.buffer = media_ptr;
   4404           Input_pmem.fd = handle->fd;
   4405           Input_pmem.offset = 0;
   4406           Input_pmem.size = handle->size;
   4407         } else {
   4408           meta_error = true;
   4409           DEBUG_PRINT_ERROR(" Meta Error set in EBD");
   4410         }
   4411         if(!meta_error)
   4412            meta_error = !dev_free_buf(&Input_pmem,PORT_INDEX_IN);
   4413           if(meta_error)
   4414           {
   4415            DEBUG_PRINT_ERROR(" Warning dev_free_buf failed flush value is %d",
   4416                input_flush_progress);
   4417           }
   4418         }
   4419      }
   4420   }
   4421 }
   4422 #endif
   4423 omx_video::omx_c2d_conv::omx_c2d_conv()
   4424 {
   4425   c2dcc = NULL;
   4426   mLibHandle = NULL;
   4427   mConvertOpen = NULL;
   4428   mConvertClose = NULL;
   4429   src_format = NV12_2K;
   4430 }
   4431 
   4432 bool omx_video::omx_c2d_conv::init() {
   4433   bool status = true;
   4434   if(mLibHandle || mConvertOpen || mConvertClose) {
   4435     DEBUG_PRINT_ERROR("\n omx_c2d_conv::init called twice");
   4436     status = false;
   4437   }
   4438   if(status) {
   4439     mLibHandle = dlopen("libc2dcolorconvert.so", RTLD_LAZY);
   4440     if(mLibHandle){
   4441        mConvertOpen = (createC2DColorConverter_t *)
   4442        dlsym(mLibHandle,"createC2DColorConverter");
   4443        mConvertClose = (destroyC2DColorConverter_t *)
   4444        dlsym(mLibHandle,"destroyC2DColorConverter");
   4445        if(!mConvertOpen || !mConvertClose)
   4446          status = false;
   4447     } else
   4448       status = false;
   4449   }
   4450   if(!status && mLibHandle){
   4451     dlclose(mLibHandle);
   4452     mLibHandle = NULL;
   4453     mConvertOpen = NULL;
   4454     mConvertClose = NULL;
   4455   }
   4456   return status;
   4457 }
   4458 
   4459 bool omx_video::omx_c2d_conv::convert(int src_fd, void *src_base, void *src_viraddr,
   4460      int dest_fd, void *dest_base, void *dest_viraddr)
   4461 {
   4462   int result;
   4463   if(!src_viraddr || !dest_viraddr || !c2dcc){
   4464     DEBUG_PRINT_ERROR("\n Invalid arguments omx_c2d_conv::convert");
   4465     return false;
   4466   }
   4467   result =  c2dcc->convertC2D(src_fd, src_base, src_viraddr,
   4468                               dest_fd, dest_base, dest_viraddr);
   4469   DEBUG_PRINT_LOW("\n Color convert status %d",result);
   4470   return ((result < 0)?false:true);
   4471 }
   4472 
   4473 bool omx_video::omx_c2d_conv::open(unsigned int height,unsigned int width,
   4474      ColorConvertFormat src, ColorConvertFormat dest)
   4475 {
   4476   bool status = false;
   4477   size_t srcStride = 0;
   4478   if(!c2dcc) {
   4479      c2dcc = mConvertOpen(width, height, width, height,
   4480              src, dest, 0, srcStride);
   4481      if(c2dcc) {
   4482        src_format = src;
   4483        status = true;
   4484      } else
   4485        DEBUG_PRINT_ERROR("\n mConvertOpen failed");
   4486   }
   4487    return status;
   4488 }
   4489 void omx_video::omx_c2d_conv::close()
   4490 {
   4491   if(mLibHandle) {
   4492     if(mConvertClose && c2dcc)
   4493      mConvertClose(c2dcc);
   4494     c2dcc = NULL;
   4495   }
   4496 }
   4497 omx_video::omx_c2d_conv::~omx_c2d_conv()
   4498 {
   4499   DEBUG_PRINT_ERROR("\n Destroy C2D instance");
   4500   if(mLibHandle) {
   4501     if(mConvertClose && c2dcc)
   4502       mConvertClose(c2dcc);
   4503     dlclose(mLibHandle);
   4504   }
   4505   c2dcc = NULL;
   4506   mLibHandle = NULL;
   4507   mConvertOpen = NULL;
   4508   mConvertClose = NULL;
   4509 }
   4510 int omx_video::omx_c2d_conv::get_src_format()
   4511 {
   4512   int format = -1;
   4513   if(src_format == NV12_2K) {
   4514     format = HAL_PIXEL_FORMAT_NV12_ENCODEABLE;
   4515   } else if(src_format == RGBA8888) {
   4516     format = HAL_PIXEL_FORMAT_RGBA_8888;
   4517   }
   4518   return format;
   4519 }
   4520 bool omx_video::omx_c2d_conv::get_buffer_size(int port,unsigned int &buf_size)
   4521 {
   4522   int cret = 0;
   4523   bool ret = false;
   4524   C2DBuffReq bufferreq;
   4525   if(c2dcc){
   4526     bufferreq.size = 0;
   4527     cret = c2dcc->getBuffReq(port,&bufferreq);
   4528     DEBUG_PRINT_LOW("\n Status of getbuffer is %d", cret);
   4529     ret = (cret)?false:true;
   4530     buf_size = bufferreq.size;
   4531   }
   4532   return ret;
   4533 }
   4534 OMX_ERRORTYPE  omx_video::empty_this_buffer_opaque(OMX_IN OMX_HANDLETYPE hComp,
   4535                                                   OMX_IN OMX_BUFFERHEADERTYPE* buffer)
   4536 {
   4537   unsigned nBufIndex = 0;
   4538   OMX_ERRORTYPE ret = OMX_ErrorNone;
   4539   encoder_media_buffer_type *media_buffer;
   4540   DEBUG_PRINT_LOW("\n ETBProxyOpaque: buffer[%p]\n", buffer);
   4541 
   4542   if(buffer == NULL) {
   4543     DEBUG_PRINT_ERROR("\nERROR: ETBProxyA: Invalid buffer[%p]\n",buffer);
   4544     return OMX_ErrorBadParameter;
   4545   }
   4546   nBufIndex = buffer - meta_buffer_hdr;
   4547   if(nBufIndex >= m_sInPortDef.nBufferCountActual) {
   4548     DEBUG_PRINT_ERROR("\nERROR: ETBProxyA: Invalid bufindex = %u\n",
   4549                       nBufIndex);
   4550     return OMX_ErrorBadParameter;
   4551   }
   4552   media_buffer = (encoder_media_buffer_type *)buffer->pBuffer;
   4553   private_handle_t *handle = (private_handle_t *)media_buffer->meta_handle;
   4554   /*Enable following code once private handle color format is
   4555     updated correctly*/
   4556 
   4557   if(buffer->nFilledLen > 0) {
   4558     if(c2d_opened && handle->format != c2d_conv.get_src_format()) {
   4559       c2d_conv.close();
   4560       c2d_opened = false;
   4561     }
   4562     if (!c2d_opened) {
   4563         if (handle->format == HAL_PIXEL_FORMAT_RGBA_8888) {
   4564           DEBUG_PRINT_ERROR("\n open Color conv for RGBA888");
   4565           if(!c2d_conv.open(m_sInPortDef.format.video.nFrameHeight,
   4566                m_sInPortDef.format.video.nFrameWidth,RGBA8888,NV12_2K)){
   4567              m_pCallbacks.EmptyBufferDone(hComp,m_app_data,buffer);
   4568              DEBUG_PRINT_ERROR("\n Color conv open failed");
   4569              return OMX_ErrorBadParameter;
   4570           }
   4571           c2d_opened = true;
   4572         } else if(handle->format != HAL_PIXEL_FORMAT_NV12_ENCODEABLE) {
   4573           DEBUG_PRINT_ERROR("\n Incorrect color format");
   4574           m_pCallbacks.EmptyBufferDone(hComp,m_app_data,buffer);
   4575           return OMX_ErrorBadParameter;
   4576         }
   4577     }
   4578   }
   4579 
   4580   if(input_flush_progress == true)
   4581   {
   4582     m_pCallbacks.EmptyBufferDone(hComp,m_app_data,buffer);
   4583     DEBUG_PRINT_ERROR("\nERROR: ETBProxyA: Input flush in progress");
   4584     return OMX_ErrorNone;
   4585   }
   4586 
   4587   if(!psource_frame) {
   4588     psource_frame = buffer;
   4589     ret = push_input_buffer(hComp);
   4590   } else {
   4591     if (!m_opq_meta_q.insert_entry((unsigned)buffer,0,0)) {
   4592       DEBUG_PRINT_ERROR("\nERROR: ETBProxy: Queue is full");
   4593       ret = OMX_ErrorBadParameter;
   4594     }
   4595   }
   4596   if(ret != OMX_ErrorNone) {
   4597     m_pCallbacks.EmptyBufferDone(hComp,m_app_data,buffer);
   4598     DEBUG_PRINT_LOW("\nERROR: ETBOpaque failed:");
   4599   }
   4600   return ret;
   4601 }
   4602 OMX_ERRORTYPE omx_video::queue_meta_buffer(OMX_HANDLETYPE hComp,
   4603      struct pmem &Input_pmem_info) {
   4604 
   4605   OMX_ERRORTYPE ret = OMX_ErrorNone;
   4606   unsigned address = 0,p2,id;
   4607 
   4608   DEBUG_PRINT_LOW("\n In queue Meta Buffer");
   4609   if(!psource_frame || !pdest_frame) {
   4610     DEBUG_PRINT_ERROR("\n convert_queue_buffer invalid params");
   4611     return OMX_ErrorBadParameter;
   4612   }
   4613 
   4614   if(psource_frame->nFilledLen > 0) {
   4615    if(dev_use_buf(&Input_pmem_info,PORT_INDEX_IN,0) != true) {
   4616      DEBUG_PRINT_ERROR("\nERROR: in dev_use_buf");
   4617      post_event ((unsigned int)psource_frame,0,OMX_COMPONENT_GENERATE_EBD);
   4618      ret = OMX_ErrorBadParameter;
   4619    }
   4620   }
   4621 
   4622   if(ret == OMX_ErrorNone)
   4623     ret = empty_this_buffer_proxy(hComp,psource_frame);
   4624 
   4625   if(ret == OMX_ErrorNone) {
   4626     psource_frame = NULL;
   4627     if(!psource_frame && m_opq_meta_q.m_size) {
   4628       m_opq_meta_q.pop_entry(&address,&p2,&id);
   4629       psource_frame = (OMX_BUFFERHEADERTYPE* ) address;
   4630     }
   4631   }
   4632   return ret;
   4633 }
   4634 
   4635 OMX_ERRORTYPE omx_video::convert_queue_buffer(OMX_HANDLETYPE hComp,
   4636      struct pmem &Input_pmem_info,unsigned &index){
   4637 
   4638   unsigned char *uva;
   4639   OMX_ERRORTYPE ret = OMX_ErrorNone;
   4640   unsigned address = 0,p2,id;
   4641 
   4642   DEBUG_PRINT_LOW("\n In Convert and queue Meta Buffer");
   4643   if(!psource_frame || !pdest_frame) {
   4644     DEBUG_PRINT_ERROR("\n convert_queue_buffer invalid params");
   4645     return OMX_ErrorBadParameter;
   4646   }
   4647 
   4648   if(!psource_frame->nFilledLen){
   4649     if(psource_frame->nFlags & OMX_BUFFERFLAG_EOS){
   4650         pdest_frame->nFilledLen = psource_frame->nFilledLen;
   4651         pdest_frame->nTimeStamp = psource_frame->nTimeStamp;
   4652         pdest_frame->nFlags = psource_frame->nFlags;
   4653         DEBUG_PRINT_HIGH("\n Skipping color conversion for empty EOS \
   4654           Buffer header=%p filled-len=%d", pdest_frame,pdest_frame->nFilledLen);
   4655     } else {
   4656         pdest_frame->nOffset = 0;
   4657         pdest_frame->nFilledLen = 0;
   4658         pdest_frame->nTimeStamp = psource_frame->nTimeStamp;
   4659         pdest_frame->nFlags = psource_frame->nFlags;
   4660         DEBUG_PRINT_LOW("\n Buffer header %p Filled len size %d",
   4661            pdest_frame,pdest_frame->nFilledLen);
   4662     }
   4663   } else {
   4664      uva = (unsigned char *)mmap(NULL, Input_pmem_info.size,
   4665                            PROT_READ|PROT_WRITE,
   4666                            MAP_SHARED,Input_pmem_info.fd,0);
   4667      if(uva == MAP_FAILED) {
   4668        ret = OMX_ErrorBadParameter;
   4669      } else {
   4670        if(!c2d_conv.convert(Input_pmem_info.fd, uva, uva,
   4671           m_pInput_pmem[index].fd, pdest_frame->pBuffer, pdest_frame->pBuffer)) {
   4672           DEBUG_PRINT_ERROR("\n Color Conversion failed");
   4673           ret = OMX_ErrorBadParameter;
   4674        } else {
   4675           unsigned int buf_size = 0;
   4676           if (!c2d_conv.get_buffer_size(C2D_OUTPUT,buf_size))
   4677             ret = OMX_ErrorBadParameter;
   4678           else {
   4679             pdest_frame->nOffset = 0;
   4680             if(!buf_size || buf_size > pdest_frame->nAllocLen) {
   4681               DEBUG_PRINT_ERROR("\n convert_queue_buffer buffer"
   4682                "size mismatch buf size %d alloc size %d",
   4683                       buf_size, pdest_frame->nAllocLen);
   4684               ret = OMX_ErrorBadParameter;
   4685               buf_size = 0;
   4686             }
   4687             pdest_frame->nFilledLen = buf_size;
   4688             pdest_frame->nTimeStamp = psource_frame->nTimeStamp;
   4689             pdest_frame->nFlags = psource_frame->nFlags;
   4690             DEBUG_PRINT_LOW("\n Buffer header %p Filled len size %d",
   4691                pdest_frame,pdest_frame->nFilledLen);
   4692            }
   4693          }
   4694          munmap(uva,Input_pmem_info.size);
   4695       }
   4696     }
   4697     if((ret == OMX_ErrorNone) &&
   4698        dev_use_buf(&m_pInput_pmem[index],PORT_INDEX_IN,0) != true) {
   4699       DEBUG_PRINT_ERROR("\nERROR: in dev_use_buf");
   4700       post_event ((unsigned int)pdest_frame,0,OMX_COMPONENT_GENERATE_EBD);
   4701       ret = OMX_ErrorBadParameter;
   4702     }
   4703     if(ret == OMX_ErrorNone)
   4704       ret = empty_this_buffer_proxy(hComp,pdest_frame);
   4705     if(ret == OMX_ErrorNone) {
   4706       m_pCallbacks.EmptyBufferDone(hComp ,m_app_data, psource_frame);
   4707       psource_frame = NULL;
   4708       pdest_frame = NULL;
   4709       if(!psource_frame && m_opq_meta_q.m_size) {
   4710         m_opq_meta_q.pop_entry(&address,&p2,&id);
   4711         psource_frame = (OMX_BUFFERHEADERTYPE* ) address;
   4712       }
   4713       if(!pdest_frame && m_opq_pmem_q.m_size) {
   4714         m_opq_pmem_q.pop_entry(&address,&p2,&id);
   4715         pdest_frame = (OMX_BUFFERHEADERTYPE* ) address;
   4716         DEBUG_PRINT_LOW("\n pdest_frame pop address is %p",pdest_frame);
   4717       }
   4718     }
   4719     return ret;
   4720 }
   4721 
   4722 OMX_ERRORTYPE omx_video::push_input_buffer(OMX_HANDLETYPE hComp)
   4723 {
   4724   unsigned address = 0,p2,id, index = 0;
   4725   OMX_ERRORTYPE ret = OMX_ErrorNone;
   4726 
   4727   if(!psource_frame && m_opq_meta_q.m_size) {
   4728     m_opq_meta_q.pop_entry(&address,&p2,&id);
   4729     psource_frame = (OMX_BUFFERHEADERTYPE* ) address;
   4730   }
   4731   if(!pdest_frame && m_opq_pmem_q.m_size) {
   4732     m_opq_pmem_q.pop_entry(&address,&p2,&id);
   4733     pdest_frame = (OMX_BUFFERHEADERTYPE* ) address;
   4734   }
   4735   while(psource_frame != NULL && pdest_frame != NULL &&
   4736         ret == OMX_ErrorNone) {
   4737     struct pmem Input_pmem_info;
   4738     encoder_media_buffer_type *media_buffer;
   4739     index = pdest_frame - m_inp_mem_ptr;
   4740     if(index >= m_sInPortDef.nBufferCountActual){
   4741        DEBUG_PRINT_ERROR("\n Output buffer index is wrong %d act count %d",
   4742                          index,m_sInPortDef.nBufferCountActual);
   4743        return OMX_ErrorBadParameter;
   4744     }
   4745     media_buffer = (encoder_media_buffer_type *)psource_frame->pBuffer;
   4746     /*Will enable to verify camcorder in current TIPS can be removed*/
   4747     if(media_buffer->buffer_type == kMetadataBufferTypeCameraSource) {
   4748       Input_pmem_info.buffer = media_buffer;
   4749       Input_pmem_info.fd = media_buffer->meta_handle->data[0];
   4750       Input_pmem_info.offset = media_buffer->meta_handle->data[1];
   4751       Input_pmem_info.size = media_buffer->meta_handle->data[2];
   4752       DEBUG_PRINT_LOW("ETB fd = %d, offset = %d, size = %d",Input_pmem_info.fd,
   4753                         Input_pmem_info.offset,
   4754                         Input_pmem_info.size);
   4755       ret = queue_meta_buffer(hComp,Input_pmem_info);
   4756     } else if(psource_frame->nFlags & OMX_BUFFERFLAG_EOS & mUseProxyColorFormat) {
   4757        ret = convert_queue_buffer(hComp,Input_pmem_info,index);
   4758     } else {
   4759       private_handle_t *handle = (private_handle_t *)media_buffer->meta_handle;
   4760       Input_pmem_info.buffer = media_buffer;
   4761       Input_pmem_info.fd = handle->fd;
   4762       Input_pmem_info.offset = 0;
   4763       Input_pmem_info.size = handle->size;
   4764       if(handle->format == HAL_PIXEL_FORMAT_RGBA_8888)
   4765         ret = convert_queue_buffer(hComp,Input_pmem_info,index);
   4766       else if(handle->format == HAL_PIXEL_FORMAT_NV12_ENCODEABLE)
   4767         ret = queue_meta_buffer(hComp,Input_pmem_info);
   4768       else
   4769         ret = OMX_ErrorBadParameter;
   4770     }
   4771    }
   4772   return ret;
   4773 }
   4774