hardware/qcom/media/mm-video/vidc/vdec/src/omx_vdec.cpp

   1 /*--------------------------------------------------------------------------
   2 Copyright (c) 2010, 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 /*============================================================================
  30                             O p e n M A X   w r a p p e r s
  31                              O p e n  M A X   C o r e
  32
  33 *//** @file omx_vdec.cpp
  34   This module contains the implementation of the OpenMAX core & component.
  35
  36 *//*========================================================================*/
  37
  38 //////////////////////////////////////////////////////////////////////////////
  39 //                             Include Files
  40 //////////////////////////////////////////////////////////////////////////////
  41
  42 #include <string.h>
  43 #include <pthread.h>
  44 #include <stdlib.h>
  45 #include <unistd.h>
  46 #include <errno.h>
  47 #include "omx_vdec.h"
  48 #include <fcntl.h>
  49
  50 #define BITSTREAM_LOG 0
  51
  52 #if BITSTREAM_LOG
  53 FILE *outputBufferFile1;
  54 char filename [] = "/data/input-bitstream.m4v";
  55 #endif
  56
  57 #define H264_SUPPORTED_WIDTH (480)
  58 #define H264_SUPPORTED_HEIGHT (368)
  59
  60 #define MPEG4_SUPPORTED_WIDTH (480)
  61 #define MPEG4_SUPPORTED_HEIGHT (368)
  62
  63 #define VC1_SP_MP_START_CODE        0xC5000000
  64 #define VC1_SP_MP_START_CODE_MASK   0xFF000000
  65 #define VC1_AP_SEQ_START_CODE       0x0F010000
  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 #ifdef _ANDROID_
  80     extern "C"{
  81         #include<utils/Log.h>
  82     }
  83 #endif//_ANDROID_
  84
  85 #define DEBUG_PRINT(...) printf(__VA_ARGS__)
  86 #define DEBUG_PRINT_ERROR(...) printf(__VA_ARGS__)
  87 #define DEBUG_PRINT_LOW(...) printf(__VA_ARGS__)
  88
  89
  90 void* async_message_thread (void *input)
  91 {
  92   struct vdec_ioctl_msg ioctl_msg;
  93   struct vdec_msginfo vdec_msg;
  94   omx_vdec *omx = reinterpret_cast<omx_vdec*>(input);
  95
  96   DEBUG_PRINT_HIGH("omx_vdec: Async thread start\n");
  97   while (1)
  98   {
  99     ioctl_msg.inputparam = NULL;
 100     ioctl_msg.outputparam = (void*)&vdec_msg;
 101
 102     /*Wait for a message from the video decoder driver*/
 103     if (ioctl ( omx->driver_context.video_driver_fd,VDEC_IOCTL_GET_NEXT_MSG,
 104                 (void*)&ioctl_msg) < 0)
 105     {
 106       DEBUG_PRINT_ERROR("\n Error in ioctl read next msg");
 107       break;
 108     }
 109     else
 110     {
 111       /*Call Instance specific process function*/
 112       if (omx->async_message_process(input,&vdec_msg) < 0)
 113       {
 114         DEBUG_PRINT_ERROR("\nERROR:Wrong ioctl message");
 115       }
 116     }
 117   }
 118   DEBUG_PRINT_HIGH("omx_vdec: Async thread stop\n");
 119   return NULL;
 120 }
 121
 122 void* message_thread(void *input)
 123 {
 124   omx_vdec* omx = reinterpret_cast<omx_vdec*>(input);
 125   unsigned char id;
 126   int n;
 127
 128   DEBUG_PRINT_HIGH("omx_vdec: message thread start\n");
 129   while (1)
 130   {
 131
 132     n = read(omx->m_pipe_in, &id, 1);
 133
 134     if(0 == n)
 135     {
 136       break;
 137     }
 138
 139     if (1 == n)
 140     {
 141         omx->process_event_cb(omx, id);
 142     }
 143     if ((n < 0) && (errno != EINTR))
 144     {
 145       DEBUG_PRINT_ERROR("\nERROR: read from pipe failed, ret %d errno %d", n, errno);
 146       break;
 147     }
 148   }
 149   DEBUG_PRINT_HIGH("omx_vdec: message thread stop\n");
 150   return 0;
 151 }
 152
 153 void post_message(omx_vdec *omx, unsigned char id)
 154 {
 155       int ret_value;
 156       DEBUG_PRINT_LOW("omx_vdec: post_message %d pipe out%d\n", id,omx->m_pipe_out);
 157       ret_value = write(omx->m_pipe_out, &id, 1);
 158       DEBUG_PRINT_LOW("post_message to pipe done %d\n",ret_value);
 159 }
 160
 161 // omx_cmd_queue destructor
 162 omx_vdec::omx_cmd_queue::~omx_cmd_queue()
 163 {
 164   // Nothing to do
 165 }
 166
 167 // omx cmd queue constructor
 168 omx_vdec::omx_cmd_queue::omx_cmd_queue(): m_read(0),m_write(0),m_size(0)
 169 {
 170     memset(m_q,0,sizeof(omx_event)*OMX_CORE_CONTROL_CMDQ_SIZE);
 171 }
 172
 173 // omx cmd queue insert
 174 bool omx_vdec::omx_cmd_queue::insert_entry(unsigned p1, unsigned p2, unsigned id)
 175 {
 176   bool ret = true;
 177   if(m_size < OMX_CORE_CONTROL_CMDQ_SIZE)
 178   {
 179     m_q[m_write].id       = id;
 180     m_q[m_write].param1   = p1;
 181     m_q[m_write].param2   = p2;
 182     m_write++;
 183     m_size ++;
 184     if(m_write >= OMX_CORE_CONTROL_CMDQ_SIZE)
 185     {
 186       m_write = 0;
 187     }
 188   }
 189   else
 190   {
 191     ret = false;
 192     DEBUG_PRINT_ERROR("ERROR: %s()::Command Queue Full\n", __func__);
 193   }
 194   return ret;
 195 }
 196
 197 // omx cmd queue pop
 198 bool omx_vdec::omx_cmd_queue::pop_entry(unsigned *p1, unsigned *p2, unsigned *id)
 199 {
 200   bool ret = true;
 201   if (m_size > 0)
 202   {
 203     *id = m_q[m_read].id;
 204     *p1 = m_q[m_read].param1;
 205     *p2 = m_q[m_read].param2;
 206     // Move the read pointer ahead
 207     ++m_read;
 208     --m_size;
 209     if(m_read >= OMX_CORE_CONTROL_CMDQ_SIZE)
 210     {
 211       m_read = 0;
 212     }
 213   }
 214   else
 215   {
 216     ret = false;
 217   }
 218   return ret;
 219 }
 220
 221 // Retrieve the first mesg type in the queue
 222 unsigned omx_vdec::omx_cmd_queue::get_q_msg_type()
 223 {
 224     return m_q[m_read].id;
 225 }
 226
 227 // factory function executed by the core to create instances
 228 void *get_omx_component_factory_fn(void)
 229 {
 230   return (new omx_vdec);
 231 }
 232
 233 #ifdef _ANDROID_
 234 VideoHeap::VideoHeap(int fd, size_t size, void* base)
 235 {
 236     // dup file descriptor, map once, use pmem
 237     init(dup(fd), base, size, 0 , "/dev/pmem_adsp");
 238 }
 239 #endif // _ANDROID_
 240
 241 /* ======================================================================
 242 FUNCTION
 243   omx_vdec::omx_vdec
 244
 245 DESCRIPTION
 246   Constructor
 247
 248 PARAMETERS
 249   None
 250
 251 RETURN VALUE
 252   None.
 253 ========================================================================== */
 254 omx_vdec::omx_vdec(): m_state(OMX_StateInvalid),
 255                       m_app_data(NULL),
 256                       m_color_format(OMX_COLOR_FormatYUV420Planar),
 257                       m_inp_mem_ptr(NULL),
 258                       m_out_mem_ptr(NULL),
 259                       pending_input_buffers(0),
 260                       pending_output_buffers(0),
 261                       m_out_bm_count(0),
 262                       m_out_buf_count(0),
 263                       m_inp_buf_count(OMX_VIDEO_DEC_NUM_INPUT_BUFFERS),
 264                       m_inp_buf_size(OMX_VIDEO_DEC_INPUT_BUFFER_SIZE),
 265                       m_inp_bm_count(0),
 266                       m_inp_bPopulated(OMX_FALSE),
 267                       m_out_bPopulated(OMX_FALSE),
 268                       m_height(0),
 269                       m_width(0),
 270                       m_port_height(0),
 271                       m_port_width(0),
 272                       m_crop_x(0),
 273                       m_crop_y(0),
 274                       m_crop_dx(0),
 275                       m_crop_dy(0),
 276                       m_flags(0),
 277                       m_inp_bEnabled(OMX_TRUE),
 278                       m_out_bEnabled(OMX_TRUE),
 279                       m_event_port_settings_sent(false),
 280                       input_flush_progress (false),
 281                       output_flush_progress (false),
 282                       m_platform_list(NULL),
 283                       m_platform_entry(NULL),
 284                       m_pmem_info(NULL),
 285                       input_use_buffer (false),
 286                       output_use_buffer (false),
 287                       m_ineos_reached (0),
 288                       m_outeos_pending (0),
 289                       m_outeos_reached (0),
 290                       arbitrary_bytes (true),
 291                       psource_frame (NULL),
 292                       pdest_frame (NULL),
 293                       m_inp_heap_ptr (NULL),
 294                       m_heap_inp_bm_count (0),
 295                       codec_type_parse ((codec_type)0),
 296                       first_frame_meta (true),
 297                       frame_count (0),
 298                       nal_count (0),
 299                       nal_length(0),
 300                       look_ahead_nal (false),
 301                       first_frame(0),
 302                       first_buffer(NULL),
 303                       first_frame_size (0),
 304                       set_seq_header_done(false),
 305                       gate_output_buffers(true),
 306                       gate_input_buffers(false),
 307                       stride(0),
 308                       sent_first_frame(false),
 309                       m_error_propogated(false),
 310                       scan_lines(0),
 311                       m_device_file_ptr(NULL),
 312                       m_vc1_profile((vc1_profile_type)0)
 313 {
 314   /* Assumption is that , to begin with , we have all the frames with decoder */
 315   DEBUG_PRINT_HIGH("\n In OMX vdec Constuctor");
 316   memset(&m_cmp,0,sizeof(m_cmp));
 317   memset(&m_cb,0,sizeof(m_cb));
 318   memset (&driver_context,0,sizeof(driver_context));
 319   memset (&h264_scratch,0,sizeof (OMX_BUFFERHEADERTYPE));
 320   memset (m_hwdevice_name,0,sizeof(m_hwdevice_name));
 321   driver_context.video_driver_fd = -1;
 322   m_vendor_config.pData = NULL;
 323   pthread_mutex_init(&m_lock, NULL);
 324   sem_init(&m_cmd_lock,0,0);
 325 }
 326
 327
 328 /* ======================================================================
 329 FUNCTION
 330   omx_vdec::~omx_vdec
 331
 332 DESCRIPTION
 333   Destructor
 334
 335 PARAMETERS
 336   None
 337
 338 RETURN VALUE
 339   None.
 340 ========================================================================== */
 341 omx_vdec::~omx_vdec()
 342 {
 343   m_pmem_info = NULL;
 344   m_port_width = m_port_height = 0;
 345   DEBUG_PRINT_HIGH("\n In OMX vdec Destructor");
 346   if(m_pipe_in) close(m_pipe_in);
 347   if(m_pipe_out) close(m_pipe_out);
 348   m_pipe_in = -1;
 349   m_pipe_out = -1;
 350   DEBUG_PRINT_HIGH("\n Waiting on OMX Msg Thread exit");
 351   pthread_join(msg_thread_id,NULL);
 352   DEBUG_PRINT_HIGH("\n Waiting on OMX Async Thread exit");
 353   pthread_join(async_thread_id,NULL);
 354   pthread_mutex_destroy(&m_lock);
 355   sem_destroy(&m_cmd_lock);
 356   DEBUG_PRINT_HIGH("\n Exit OMX vdec Destructor");
 357 }
 358
 359 /* ======================================================================
 360 FUNCTION
 361   omx_vdec::OMXCntrlProcessMsgCb
 362
 363 DESCRIPTION
 364   IL Client callbacks are generated through this routine. The decoder
 365   provides the thread context for this routine.
 366
 367 PARAMETERS
 368   ctxt -- Context information related to the self.
 369   id   -- Event identifier. This could be any of the following:
 370           1. Command completion event
 371           2. Buffer done callback event
 372           3. Frame done callback event
 373
 374 RETURN VALUE
 375   None.
 376
 377 ========================================================================== */
 378 void omx_vdec::process_event_cb(void *ctxt, unsigned char id)
 379 {
 380   unsigned p1; // Parameter - 1
 381   unsigned p2; // Parameter - 2
 382   unsigned ident;
 383   unsigned qsize=0; // qsize
 384   omx_vdec *pThis = (omx_vdec *) ctxt;
 385
 386   if(!pThis)
 387   {
 388     DEBUG_PRINT_ERROR("ERROR: %s()::Context is incorrect, bailing out\n",
 389         __func__);
 390     return;
 391   }
 392
 393   // Protect the shared queue data structure
 394   do
 395   {
 396     /*Read the message id's from the queue*/
 397     pthread_mutex_lock(&pThis->m_lock);
 398     qsize = pThis->m_cmd_q.m_size;
 399     if(qsize)
 400     {
 401       pThis->m_cmd_q.pop_entry(&p1,&p2,&ident);
 402     }
 403
 404     if (qsize == 0 && !pThis->gate_output_buffers)
 405     {
 406       qsize = pThis->m_ftb_q.m_size;
 407       if (qsize)
 408       {
 409         pThis->m_ftb_q.pop_entry(&p1,&p2,&ident);
 410       }
 411     }
 412
 413     if (qsize == 0)
 414     {
 415       qsize = pThis->m_etb_q.m_size;
 416       if (qsize)
 417       {
 418         pThis->m_etb_q.pop_entry(&p1,&p2,&ident);
 419       }
 420     }
 421     pthread_mutex_unlock(&pThis->m_lock);
 422
 423     /*process message if we have one*/
 424     if(qsize > 0)
 425     {
 426       id = ident;
 427       switch (id)
 428       {
 429         case OMX_COMPONENT_GENERATE_EVENT:
 430           if (pThis->m_cb.EventHandler)
 431           {
 432             switch (p1)
 433             {
 434               case OMX_CommandStateSet:
 435                 pThis->m_state = (OMX_STATETYPE) p2;
 436                 DEBUG_PRINT_HIGH("\n OMX_CommandStateSet complete, m_state = %d",
 437                     pThis->m_state);
 438                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
 439                                       OMX_EventCmdComplete, p1, p2, NULL);
 440                 break;
 441
 442               case OMX_EventError:
 443                 if(p2 == OMX_StateInvalid)
 444                 {
 445                     DEBUG_PRINT_ERROR("\n OMX_EventError: p2 is OMX_StateInvalid");
 446                     pThis->m_state = (OMX_STATETYPE) p2;
 447                     pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
 448                                OMX_EventError, OMX_ErrorInvalidState, p2, NULL);
 449                 }
 450                 else if (p2 == (unsigned)OMX_ErrorHardware)
 451                 {
 452                    pThis->omx_report_error();
 453                 }
 454                 else
 455                 {
 456                     pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
 457                                       OMX_EventError, p2, NULL, NULL );
 458                 }
 459                 break;
 460
 461               case OMX_CommandPortDisable:
 462                 DEBUG_PRINT_HIGH("\n OMX_CommandPortDisable complete for port [%d]", p2);
 463                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
 464                                       OMX_EventCmdComplete, p1, p2, NULL );
 465                 //TODO: Check if output port is one that got disabled
 466                 pThis->gate_output_buffers = false;
 467                 break;
 468               case OMX_CommandPortEnable:
 469                 DEBUG_PRINT_HIGH("\n OMX_CommandPortEnable complete for port [%d]", p2);
 470                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,\
 471                                       OMX_EventCmdComplete, p1, p2, NULL );
 472                 break;
 473
 474               default:
 475                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
 476                                          OMX_EventCmdComplete, p1, p2, NULL );
 477                 break;
 478
 479             }
 480           }
 481           else
 482           {
 483             DEBUG_PRINT_ERROR("ERROR: %s()::EventHandler is NULL\n", __func__);
 484           }
 485           break;
 486         case OMX_COMPONENT_GENERATE_ETB_ARBITRARY:
 487           if (pThis->empty_this_buffer_proxy_arbitrary((OMX_HANDLETYPE)p1,\
 488               (OMX_BUFFERHEADERTYPE *)p2) != OMX_ErrorNone)
 489           {
 490             DEBUG_PRINT_ERROR("\n empty_this_buffer_proxy_arbitrary failure");
 491             pThis->omx_report_error ();
 492           }
 493       break;
 494         case OMX_COMPONENT_GENERATE_ETB:
 495           if (pThis->empty_this_buffer_proxy((OMX_HANDLETYPE)p1,\
 496               (OMX_BUFFERHEADERTYPE *)p2) != OMX_ErrorNone)
 497           {
 498             DEBUG_PRINT_ERROR("\n empty_this_buffer_proxy failure");
 499             pThis->omx_report_error ();
 500           }
 501          break;
 502
 503         case OMX_COMPONENT_GENERATE_FTB:
 504           if ( pThis->fill_this_buffer_proxy((OMX_HANDLETYPE)p1,\
 505                (OMX_BUFFERHEADERTYPE *)p2) != OMX_ErrorNone)
 506           {
 507              DEBUG_PRINT_ERROR("\n fill_this_buffer_proxy failure");
 508              pThis->omx_report_error ();
 509           }
 510         break;
 511
 512         case OMX_COMPONENT_GENERATE_COMMAND:
 513           pThis->send_command_proxy(&pThis->m_cmp,(OMX_COMMANDTYPE)p1,\
 514                                     (OMX_U32)p2,(OMX_PTR)NULL);
 515           break;
 516
 517         case OMX_COMPONENT_GENERATE_EBD:
 518
 519           if (p2 != VDEC_S_SUCCESS)
 520           {
 521             DEBUG_PRINT_ERROR("\n OMX_COMPONENT_GENERATE_EBD failure");
 522             pThis->omx_report_error ();
 523           }
 524           else
 525           {
 526             if ( pThis->empty_buffer_done(&pThis->m_cmp,
 527                  (OMX_BUFFERHEADERTYPE *)p1) != OMX_ErrorNone)
 528             {
 529                DEBUG_PRINT_ERROR("\n empty_buffer_done failure");
 530                pThis->omx_report_error ();
 531             }
 532           }
 533           break;
 534
 535         case OMX_COMPONENT_GENERATE_FBD:
 536           if (p2 != VDEC_S_SUCCESS)
 537           {
 538             DEBUG_PRINT_ERROR("\n OMX_COMPONENT_GENERATE_FBD failure");
 539             pThis->omx_report_error ();
 540           }
 541           else
 542           {
 543              if ( pThis->fill_buffer_done(&pThis->m_cmp,
 544                   (OMX_BUFFERHEADERTYPE *)p1) != OMX_ErrorNone )
 545              {
 546                DEBUG_PRINT_ERROR("\n fill_buffer_done failure");
 547                pThis->omx_report_error ();
 548              }
 549           }
 550           break;
 551
 552         case OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH:
 553           DEBUG_PRINT_HIGH("\n Flush i/p Port complete");
 554           pThis->input_flush_progress = false;
 555           DEBUG_PRINT_LOW("\n Input flush done pending input %d",
 556                              pThis->pending_input_buffers);
 557
 558           if (pThis->m_cb.EventHandler)
 559           {
 560             if (p2 != VDEC_S_SUCCESS)
 561             {
 562               DEBUG_PRINT_ERROR("\nOMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH failure");
 563               pThis->omx_report_error ();
 564             }
 565             else
 566             {
 567               /*Check if we need generate event for Flush done*/
 568               if(BITMASK_PRESENT(&pThis->m_flags,
 569                                  OMX_COMPONENT_INPUT_FLUSH_PENDING))
 570               {
 571                 BITMASK_CLEAR (&pThis->m_flags,OMX_COMPONENT_INPUT_FLUSH_PENDING);
 572                 DEBUG_PRINT_LOW("\n Input Flush completed - Notify Client");
 573                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
 574                                          OMX_EventCmdComplete,OMX_CommandFlush,
 575                                          OMX_CORE_INPUT_PORT_INDEX,NULL );
 576               }
 577               if (BITMASK_PRESENT(&pThis->m_flags,
 578                                        OMX_COMPONENT_IDLE_PENDING))
 579               {
 580                 if (!pThis->output_flush_progress)
 581                 {
 582                    DEBUG_PRINT_LOW("\n Output flush done hence issue stop");
 583                    if (ioctl (pThis->driver_context.video_driver_fd,
 584                               VDEC_IOCTL_CMD_STOP,NULL ) < 0)
 585                    {
 586                      DEBUG_PRINT_ERROR("\n VDEC_IOCTL_CMD_STOP failed");
 587                      pThis->omx_report_error ();
 588                    }
 589                 }
 590               }
 591             }
 592           }
 593
 594           break;
 595
 596         case OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH:
 597         DEBUG_PRINT_HIGH("\n Flush o/p Port complete");
 598         pThis->output_flush_progress = false;
 599         DEBUG_PRINT_LOW("\n Output flush done pending buf %d",pThis->pending_output_buffers);
 600
 601         if (pThis->m_cb.EventHandler)
 602         {
 603           if (p2 != VDEC_S_SUCCESS)
 604           {
 605             DEBUG_PRINT_ERROR("\n OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH failed");
 606             pThis->omx_report_error ();
 607           }
 608           else
 609           {
 610             /*Check if we need generate event for Flush done*/
 611             if(BITMASK_PRESENT(&pThis->m_flags,
 612                                OMX_COMPONENT_OUTPUT_FLUSH_PENDING))
 613             {
 614               DEBUG_PRINT_LOW("\n Notify Output Flush done");
 615               BITMASK_CLEAR (&pThis->m_flags,OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
 616
 617               pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
 618                                        OMX_EventCmdComplete,OMX_CommandFlush,
 619                                        OMX_CORE_OUTPUT_PORT_INDEX,NULL );
 620             }
 621             if (BITMASK_PRESENT(&pThis->m_flags ,OMX_COMPONENT_IDLE_PENDING))
 622             {
 623               if (!pThis->input_flush_progress)
 624               {
 625                 DEBUG_PRINT_LOW("\n Input flush done hence issue stop");
 626                 if (ioctl (pThis->driver_context.video_driver_fd,
 627                            VDEC_IOCTL_CMD_STOP,NULL ) < 0)
 628                 {
 629                   DEBUG_PRINT_ERROR("\n VDEC_IOCTL_CMD_STOP failed");
 630                   pThis->omx_report_error ();
 631                 }
 632               }
 633             }
 634           }
 635         }
 636         break;
 637
 638         case OMX_COMPONENT_GENERATE_START_DONE:
 639           DEBUG_PRINT_HIGH("\n Rxd OMX_COMPONENT_GENERATE_START_DONE");
 640
 641           if (pThis->m_cb.EventHandler)
 642           {
 643             if (p2 != VDEC_S_SUCCESS)
 644             {
 645               DEBUG_PRINT_ERROR("\n OMX_COMPONENT_GENERATE_START_DONE Failure");
 646               pThis->omx_report_error ();
 647             }
 648             else
 649             {
 650               DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_START_DONE Success");
 651               if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
 652               {
 653                 DEBUG_PRINT_LOW("\n Move to executing");
 654                 // Send the callback now
 655                 BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_EXECUTE_PENDING);
 656                 pThis->m_state = OMX_StateExecuting;
 657                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
 658                                        OMX_EventCmdComplete,OMX_CommandStateSet,
 659                                        OMX_StateExecuting, NULL);
 660               }
 661               else if (BITMASK_PRESENT(&pThis->m_flags,
 662                                        OMX_COMPONENT_PAUSE_PENDING))
 663               {
 664                 if (ioctl (pThis->driver_context.video_driver_fd,
 665                            VDEC_IOCTL_CMD_PAUSE,NULL ) < 0)
 666                 {
 667                   DEBUG_PRINT_ERROR("\n VDEC_IOCTL_CMD_PAUSE failed");
 668                   pThis->omx_report_error ();
 669                 }
 670               }
 671             }
 672           }
 673           else
 674           {
 675             DEBUG_PRINT_LOW("\n Event Handler callback is NULL");
 676           }
 677           break;
 678
 679         case OMX_COMPONENT_GENERATE_PAUSE_DONE:
 680           DEBUG_PRINT_HIGH("\n Rxd OMX_COMPONENT_GENERATE_PAUSE_DONE");
 681           if (pThis->m_cb.EventHandler)
 682           {
 683             if (p2 != VDEC_S_SUCCESS)
 684             {
 685               DEBUG_PRINT_ERROR("OMX_COMPONENT_GENERATE_PAUSE_DONE ret failed");
 686               pThis->omx_report_error ();
 687             }
 688             else
 689             {
 690               if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_PAUSE_PENDING))
 691               {
 692                 DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_PAUSE_DONE nofity");
 693                 //Send the callback now
 694                 BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_PAUSE_PENDING);
 695                 pThis->m_state = OMX_StatePause;
 696                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
 697                                        OMX_EventCmdComplete,OMX_CommandStateSet,
 698                                        OMX_StatePause, NULL);
 699               }
 700             }
 701           }
 702
 703           break;
 704
 705         case OMX_COMPONENT_GENERATE_RESUME_DONE:
 706           DEBUG_PRINT_HIGH("\n Rxd OMX_COMPONENT_GENERATE_RESUME_DONE");
 707           if (pThis->m_cb.EventHandler)
 708           {
 709             if (p2 != VDEC_S_SUCCESS)
 710             {
 711               DEBUG_PRINT_ERROR("\n OMX_COMPONENT_GENERATE_RESUME_DONE failed");
 712               pThis->omx_report_error ();
 713             }
 714             else
 715             {
 716               if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
 717               {
 718                 DEBUG_PRINT_LOW("\n Moving the decoder to execute state");
 719                 // Send the callback now
 720                 BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_EXECUTE_PENDING);
 721                 pThis->m_state = OMX_StateExecuting;
 722                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
 723                                        OMX_EventCmdComplete,OMX_CommandStateSet,
 724                                        OMX_StateExecuting,NULL);
 725               }
 726             }
 727           }
 728
 729           break;
 730
 731         case OMX_COMPONENT_GENERATE_STOP_DONE:
 732           DEBUG_PRINT_HIGH("\n Rxd OMX_COMPONENT_GENERATE_STOP_DONE");
 733           if (pThis->m_cb.EventHandler)
 734           {
 735             if (p2 != VDEC_S_SUCCESS)
 736             {
 737               DEBUG_PRINT_ERROR("\n OMX_COMPONENT_GENERATE_STOP_DONE ret failed");
 738               pThis->omx_report_error ();
 739             }
 740             else
 741             {
 742               if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_IDLE_PENDING))
 743               {
 744                 DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_STOP_DONE Success");
 745                 // Send the callback now
 746                 BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_IDLE_PENDING);
 747                 pThis->m_state = OMX_StateIdle;
 748                 DEBUG_PRINT_LOW("\n Move to Idle State");
 749                 pThis->m_cb.EventHandler(&pThis->m_cmp,pThis->m_app_data,
 750                                        OMX_EventCmdComplete,OMX_CommandStateSet,
 751                                          OMX_StateIdle,NULL);
 752               }
 753             }
 754           }
 755
 756           break;
 757
 758         case OMX_COMPONENT_GENERATE_HARDWARE_ERROR:
 759           DEBUG_PRINT_ERROR("\n OMX_COMPONENT_GENERATE_HARDWARE_ERROR");
 760           pThis->omx_report_error ();
 761           break;
 762
 763         default:
 764           break;
 765         }
 766       }
 767     pthread_mutex_lock(&pThis->m_lock);
 768     if(!pThis->gate_output_buffers)
 769     {
 770     qsize = pThis->m_cmd_q.m_size + pThis->m_ftb_q.m_size +\
 771             pThis->m_etb_q.m_size;
 772     }
 773     else
 774     {
 775       qsize = pThis->m_cmd_q.m_size + pThis->m_etb_q.m_size;
 776     }
 777     pthread_mutex_unlock(&pThis->m_lock);
 778   }
 779   while(qsize>0);
 780
 781 }
 782
 783
 784
 785 /* ======================================================================
 786 FUNCTION
 787   omx_vdec::ComponentInit
 788
 789 DESCRIPTION
 790   Initialize the component.
 791
 792 PARAMETERS
 793   ctxt -- Context information related to the self.
 794   id   -- Event identifier. This could be any of the following:
 795           1. Command completion event
 796           2. Buffer done callback event
 797           3. Frame done callback event
 798
 799 RETURN VALUE
 800   None.
 801
 802 ========================================================================== */
 803 OMX_ERRORTYPE omx_vdec::component_init(OMX_STRING role)
 804 {
 805
 806   OMX_ERRORTYPE eRet = OMX_ErrorNone;
 807   struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
 808   unsigned int   alignment = 0,buffer_size = 0;
 809   int fds[2];
 810   int r;
 811    bool is_fluid = false;
 812
 813   if (!m_device_file_ptr) {
 814     int bytes_read = 0,count = 0;
 815     unsigned min_size;
 816     m_device_file_ptr = fopen("/sys/devices/system/soc/soc0/hw_platform","rb");
 817     if (m_device_file_ptr) {
 818       (void)fgets((char *)m_hwdevice_name,sizeof(m_hwdevice_name),m_device_file_ptr);
 819       DEBUG_PRINT_HIGH ("\n Name of the device is %s",m_hwdevice_name);
 820       min_size = strnlen((const char *)m_hwdevice_name,sizeof(m_hwdevice_name));
 821       if (strlen("Fluid") < min_size) {
 822           min_size = strnlen("Fluid",sizeof("Fluid"));
 823       }
 824       if  (!strncmp("Fluid",(const char *)m_hwdevice_name,min_size)) {
 825         is_fluid = true;
 826       }
 827       fclose (m_device_file_ptr);
 828     } else {
 829       DEBUG_PRINT_HIGH("\n Could not open hw_platform file");
 830     }
 831   }
 832
 833   DEBUG_PRINT_HIGH("\n omx_vdec::component_init(): Start of New Playback");
 834   driver_context.video_driver_fd = open ("/dev/msm_vidc_dec",\
 835                       O_RDWR|O_NONBLOCK);
 836
 837   DEBUG_PRINT_HIGH("\n omx_vdec::component_init(): Open returned fd %d",
 838                    driver_context.video_driver_fd);
 839
 840   if(driver_context.video_driver_fd == 0){
 841     driver_context.video_driver_fd = open ("/dev/msm_vidc_dec",\
 842                       O_RDWR|O_NONBLOCK);
 843   }
 844
 845   if(driver_context.video_driver_fd < 0)
 846   {
 847     DEBUG_PRINT_ERROR("Omx_vdec::Comp Init Returning failure\n");
 848     return OMX_ErrorInsufficientResources;
 849   }
 850
 851 #ifndef MULTI_DEC_INST
 852   unsigned int instance_count = 0;
 853   if (!is_fluid) {
 854     ioctl_msg.outputparam = &instance_count;
 855     if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_GET_NUMBER_INSTANCES,
 856                (void*)&ioctl_msg) < 0){
 857         DEBUG_PRINT_ERROR("\n Instance Query Failed");
 858         return OMX_ErrorInsufficientResources;
 859     }
 860     if (instance_count > 1) {
 861       close(driver_context.video_driver_fd);
 862       DEBUG_PRINT_ERROR("\n Reject Second instance of Decoder");
 863       driver_context.video_driver_fd = -1;
 864       return OMX_ErrorInsufficientResources;
 865     }
 866   }
 867 #endif
 868
 869 #if BITSTREAM_LOG
 870   outputBufferFile1 = fopen (filename, "ab");
 871 #endif
 872
 873   // Copy the role information which provides the decoder kind
 874   strncpy(driver_context.kind,role,128);
 875
 876   if(!strncmp(driver_context.kind,"OMX.qcom.video.decoder.mpeg4",\
 877       OMX_MAX_STRINGNAME_SIZE))
 878   {
 879      strncpy((char *)m_cRole, "video_decoder.mpeg4",\
 880      OMX_MAX_STRINGNAME_SIZE);
 881      driver_context.decoder_format = VDEC_CODECTYPE_MPEG4;
 882      eCompressionFormat = OMX_VIDEO_CodingMPEG4;
 883      /*Initialize Start Code for MPEG4*/
 884      codec_type_parse = CODEC_TYPE_MPEG4;
 885      m_frame_parser.init_start_codes (codec_type_parse);
 886   }
 887   else if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.h263",\
 888          OMX_MAX_STRINGNAME_SIZE))
 889   {
 890      strncpy((char *)m_cRole, "video_decoder.h263",OMX_MAX_STRINGNAME_SIZE);
 891      DEBUG_PRINT_LOW("\n H263 Decoder selected");
 892      driver_context.decoder_format = VDEC_CODECTYPE_H263;
 893      eCompressionFormat = OMX_VIDEO_CodingH263;
 894      codec_type_parse = CODEC_TYPE_H263;
 895      m_frame_parser.init_start_codes (codec_type_parse);
 896   }
 897   else if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.avc",\
 898          OMX_MAX_STRINGNAME_SIZE))
 899   {
 900     strncpy((char *)m_cRole, "video_decoder.avc",OMX_MAX_STRINGNAME_SIZE);
 901     driver_context.decoder_format = VDEC_CODECTYPE_H264;
 902     eCompressionFormat = OMX_VIDEO_CodingAVC;
 903     codec_type_parse = CODEC_TYPE_H264;
 904     m_frame_parser.init_start_codes (codec_type_parse);
 905     m_frame_parser.init_nal_length(nal_length);
 906   }
 907   else if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.vc1",\
 908          OMX_MAX_STRINGNAME_SIZE))
 909   {
 910     strncpy((char *)m_cRole, "video_decoder.vc1",OMX_MAX_STRINGNAME_SIZE);
 911     driver_context.decoder_format = VDEC_CODECTYPE_VC1;
 912     eCompressionFormat = OMX_VIDEO_CodingWMV;
 913     codec_type_parse = CODEC_TYPE_VC1;
 914     m_frame_parser.init_start_codes (codec_type_parse);
 915   }
 916   else
 917   {
 918     DEBUG_PRINT_ERROR("\nERROR:Unknown Component\n");
 919     eRet = OMX_ErrorInvalidComponentName;
 920   }
 921
 922   if (eRet == OMX_ErrorNone)
 923   {
 924     driver_context.output_format = VDEC_YUV_FORMAT_NV12;
 925
 926     if  (is_fluid) {
 927
 928          FILE * pFile;
 929          char disable_overlay = '0';
 930          pFile = fopen
 931          ("/data/data/com.arcsoft.videowall/files/disableoverlay.txt", "rb" );
 932          if (pFile == NULL) {
 933            DEBUG_PRINT_HIGH(" fopen FAiLED  for disableoverlay.txt\n");
 934          } else {
 935             int count  = fread(&disable_overlay, 1, 1, pFile);
 936             fclose(pFile);
 937          }
 938
 939          if(disable_overlay == '1') {
 940              DEBUG_PRINT_HIGH(" vdec : TILE format \n");
 941              driver_context.output_format = VDEC_YUV_FORMAT_TILE_4x2;
 942          } else {
 943              DEBUG_PRINT_HIGH("  vdec : NV 12 format \n");
 944              driver_context.output_format = VDEC_YUV_FORMAT_NV12;
 945          }
 946       }
 947
 948     /*Initialize Decoder with codec type and resolution*/
 949     ioctl_msg.inputparam = &driver_context.decoder_format;
 950     ioctl_msg.outputparam = NULL;
 951
 952     if ( (eRet == OMX_ErrorNone) &&
 953          ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_CODEC,
 954                 (void*)&ioctl_msg) < 0)
 955
 956     {
 957       DEBUG_PRINT_ERROR("\n Set codec type failed");
 958       eRet = OMX_ErrorInsufficientResources;
 959     }
 960
 961     /*Set the output format*/
 962     ioctl_msg.inputparam = &driver_context.output_format;
 963     ioctl_msg.outputparam = NULL;
 964
 965     if ( (eRet == OMX_ErrorNone) &&
 966          ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_OUTPUT_FORMAT,
 967            (void*)&ioctl_msg) < 0)
 968     {
 969       DEBUG_PRINT_ERROR("\n Set output format failed");
 970       eRet = OMX_ErrorInsufficientResources;
 971     }
 972
 973 #ifdef MAX_RES_720P
 974     driver_context.video_resoultion.frame_height = 720;
 975     driver_context.video_resoultion.frame_width = 1280;
 976     driver_context.video_resoultion.stride = 1280;
 977     driver_context.video_resoultion.scan_lines = 720;
 978 #endif
 979 #ifdef MAX_RES_1080P
 980     driver_context.video_resoultion.frame_height = 1088;
 981     driver_context.video_resoultion.frame_width = 1920;
 982     driver_context.video_resoultion.stride = 1920;
 983     driver_context.video_resoultion.scan_lines = 1088;
 984 #endif
 985
 986     ioctl_msg.inputparam = &driver_context.video_resoultion;
 987     ioctl_msg.outputparam = NULL;
 988
 989     if ( (eRet == OMX_ErrorNone) &&
 990         ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_PICRES,
 991            (void*)&ioctl_msg) < 0)
 992     {
 993       DEBUG_PRINT_ERROR("\n Set Resolution failed");
 994       eRet = OMX_ErrorInsufficientResources;
 995     }
 996
 997     /*Get the Buffer requirements for input and output ports*/
 998     driver_context.input_buffer.buffer_type = VDEC_BUFFER_TYPE_INPUT;
 999     ioctl_msg.inputparam = NULL;
1000     ioctl_msg.outputparam = &driver_context.input_buffer;
1001
1002     if ( (eRet == OMX_ErrorNone) &&
1003          ioctl (driver_context.video_driver_fd,VDEC_IOCTL_GET_BUFFER_REQ,
1004            (void*)&ioctl_msg) < 0)
1005     {
1006       DEBUG_PRINT_ERROR("\n Requesting for input buffer requirements failed");
1007       eRet = OMX_ErrorInsufficientResources;
1008     }
1009
1010     m_inp_buf_count = driver_context.input_buffer.actualcount;
1011     buffer_size = driver_context.input_buffer.buffer_size;
1012     alignment = driver_context.input_buffer.alignment;
1013     m_inp_buf_size = ((buffer_size + alignment -1 ) & (~(alignment -1)));
1014     m_inp_buf_count_min = driver_context.input_buffer.mincount;
1015
1016     /*Get the Buffer requirements for input and output ports*/
1017     driver_context.input_buffer.buffer_type = VDEC_BUFFER_TYPE_INPUT;
1018     ioctl_msg.inputparam = &driver_context.input_buffer;
1019     ioctl_msg.outputparam = NULL;
1020
1021     m_inp_buf_count_min = m_inp_buf_count = driver_context.input_buffer.actualcount =
1022      driver_context.input_buffer.mincount + 3;
1023
1024     if ( (eRet == OMX_ErrorNone) &&
1025          ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_BUFFER_REQ,
1026            (void*)&ioctl_msg) < 0)
1027     {
1028       DEBUG_PRINT_ERROR("\n Set input buffer requirements failed");
1029       eRet = OMX_ErrorInsufficientResources;
1030     }
1031
1032
1033     driver_context.output_buffer.buffer_type = VDEC_BUFFER_TYPE_OUTPUT;
1034     ioctl_msg.inputparam = NULL;
1035     ioctl_msg.outputparam = &driver_context.output_buffer;
1036
1037     if ((eRet == OMX_ErrorNone) &&
1038         ioctl (driver_context.video_driver_fd,VDEC_IOCTL_GET_BUFFER_REQ,
1039            (void*)&ioctl_msg) < 0)
1040     {
1041       DEBUG_PRINT_ERROR("\n Requesting for output buffer requirements failed");
1042       eRet = OMX_ErrorInsufficientResources;
1043     }
1044
1045     m_out_buf_count_recon = m_out_buf_count = driver_context.output_buffer.actualcount;
1046     m_out_buf_count_min_recon = m_out_buf_count_min = driver_context.output_buffer.mincount;
1047
1048     alignment = driver_context.output_buffer.alignment;
1049     buffer_size = driver_context.output_buffer.buffer_size;
1050     m_out_buf_size_recon = m_out_buf_size =
1051       ((buffer_size + alignment - 1) & (~(alignment -1)));
1052 #ifdef MAX_RES_720P
1053     scan_lines = m_crop_dy = m_height = 720;
1054     stride = m_crop_dx = m_width = 1280;
1055 #endif
1056 #ifdef MAX_RES_1080P
1057     scan_lines = m_crop_dy = m_height = 1088;
1058     stride = m_crop_dx = m_width = 1920;
1059 #endif
1060     m_port_height             = m_height;
1061     m_port_width              = m_width;
1062     m_state                   = OMX_StateLoaded;
1063
1064     if(pipe(fds))
1065     {
1066       DEBUG_PRINT_ERROR("pipe creation failed\n");
1067       eRet = OMX_ErrorInsufficientResources;
1068     }
1069     else
1070     {
1071       int temp1[2];
1072       if(fds[0] == 0 || fds[1] == 0)
1073       {
1074         if (pipe (temp1))
1075         {
1076           DEBUG_PRINT_ERROR("pipe creation failed\n");
1077           return OMX_ErrorInsufficientResources;
1078         }
1079         //close (fds[0]);
1080         //close (fds[1]);
1081         fds[0] = temp1 [0];
1082         fds[1] = temp1 [1];
1083       }
1084       m_pipe_in = fds[0];
1085       m_pipe_out = fds[1];
1086       r = pthread_create(&msg_thread_id,0,message_thread,this);
1087
1088       if(r < 0)
1089       {
1090         DEBUG_PRINT_ERROR("\n component_init(): message_thread creation failed");
1091         eRet = OMX_ErrorInsufficientResources;
1092       }
1093       else
1094       {
1095         r = pthread_create(&async_thread_id,0,async_message_thread,this);
1096         if(r < 0)
1097         {
1098           DEBUG_PRINT_ERROR("\n component_init(): async_message_thread creation failed");
1099           eRet = OMX_ErrorInsufficientResources;
1100         }
1101       }
1102     }
1103   }
1104
1105   if (eRet != OMX_ErrorNone)
1106   {
1107     DEBUG_PRINT_ERROR("\n Component Init Failed");
1108     DEBUG_PRINT_HIGH("\n Calling VDEC_IOCTL_STOP_NEXT_MSG");
1109     (void)ioctl(driver_context.video_driver_fd, VDEC_IOCTL_STOP_NEXT_MSG,
1110         NULL);
1111     DEBUG_PRINT_HIGH("\n Calling close() on Video Driver");
1112     close (driver_context.video_driver_fd);
1113     driver_context.video_driver_fd = -1;
1114   }
1115   else
1116   {
1117     DEBUG_PRINT_HIGH("\n omx_vdec::component_init() success");
1118   }
1119
1120   return eRet;
1121 }
1122
1123 /* ======================================================================
1124 FUNCTION
1125   omx_vdec::GetComponentVersion
1126
1127 DESCRIPTION
1128   Returns the component version.
1129
1130 PARAMETERS
1131   TBD.
1132
1133 RETURN VALUE
1134   OMX_ErrorNone.
1135
1136 ========================================================================== */
1137 OMX_ERRORTYPE  omx_vdec::get_component_version
1138                                      (
1139                                       OMX_IN OMX_HANDLETYPE hComp,
1140                                       OMX_OUT OMX_STRING componentName,
1141                                       OMX_OUT OMX_VERSIONTYPE* componentVersion,
1142                                       OMX_OUT OMX_VERSIONTYPE* specVersion,
1143                                       OMX_OUT OMX_UUIDTYPE* componentUUID
1144                                       )
1145 {
1146     if(m_state == OMX_StateInvalid)
1147     {
1148         DEBUG_PRINT_ERROR("Get Comp Version in Invalid State\n");
1149         return OMX_ErrorInvalidState;
1150     }
1151   /* TBD -- Return the proper version */
1152   return OMX_ErrorNone;
1153 }
1154 /* ======================================================================
1155 FUNCTION
1156   omx_vdec::SendCommand
1157
1158 DESCRIPTION
1159   Returns zero if all the buffers released..
1160
1161 PARAMETERS
1162   None.
1163
1164 RETURN VALUE
1165   true/false
1166
1167 ========================================================================== */
1168 OMX_ERRORTYPE  omx_vdec::send_command(OMX_IN OMX_HANDLETYPE hComp,
1169                                       OMX_IN OMX_COMMANDTYPE cmd,
1170                                       OMX_IN OMX_U32 param1,
1171                                       OMX_IN OMX_PTR cmdData
1172                                       )
1173 {
1174     DEBUG_PRINT_LOW("\n send_command: Recieved a Command from Client");
1175     if(m_state == OMX_StateInvalid)
1176     {
1177         DEBUG_PRINT_ERROR("ERROR: Send Command in Invalid State\n");
1178         return OMX_ErrorInvalidState;
1179     }
1180     post_event((unsigned)cmd,(unsigned)param1,OMX_COMPONENT_GENERATE_COMMAND);
1181     sem_wait(&m_cmd_lock);
1182     DEBUG_PRINT_LOW("\n send_command: Command Processed\n");
1183     return OMX_ErrorNone;
1184 }
1185
1186 /* ======================================================================
1187 FUNCTION
1188   omx_vdec::SendCommand
1189
1190 DESCRIPTION
1191   Returns zero if all the buffers released..
1192
1193 PARAMETERS
1194   None.
1195
1196 RETURN VALUE
1197   true/false
1198
1199 ========================================================================== */
1200 OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
1201                                             OMX_IN OMX_COMMANDTYPE cmd,
1202                                             OMX_IN OMX_U32 param1,
1203                                             OMX_IN OMX_PTR cmdData
1204                                             )
1205 {
1206   OMX_ERRORTYPE eRet = OMX_ErrorNone;
1207   OMX_STATETYPE eState = (OMX_STATETYPE) param1;
1208   int bFlag = 1,sem_posted = 0;;
1209
1210   DEBUG_PRINT_LOW("\n send_command_proxy(): cmd = %d", cmd);
1211   DEBUG_PRINT_HIGH("\n send_command_proxy(): Current State %d, Expected State %d",
1212     m_state, eState);
1213
1214   if(cmd == OMX_CommandStateSet)
1215   {
1216     DEBUG_PRINT_HIGH("\n send_command_proxy(): OMX_CommandStateSet issued");
1217     DEBUG_PRINT_HIGH("\n Current State %d, Expected State %d", m_state, eState);
1218     /***************************/
1219     /* Current State is Loaded */
1220     /***************************/
1221     if(m_state == OMX_StateLoaded)
1222     {
1223       if(eState == OMX_StateIdle)
1224       {
1225         //if all buffers are allocated or all ports disabled
1226         if(allocate_done() ||
1227           (m_inp_bEnabled == OMX_FALSE && m_out_bEnabled == OMX_FALSE))
1228         {
1229           DEBUG_PRINT_LOW("send_command_proxy(): Loaded-->Idle\n");
1230         }
1231         else
1232         {
1233           DEBUG_PRINT_LOW("send_command_proxy(): Loaded-->Idle-Pending\n");
1234           BITMASK_SET(&m_flags, OMX_COMPONENT_IDLE_PENDING);
1235           // Skip the event notification
1236           bFlag = 0;
1237         }
1238       }
1239       /* Requesting transition from Loaded to Loaded */
1240       else if(eState == OMX_StateLoaded)
1241       {
1242         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Loaded-->Loaded\n");
1243         post_event(OMX_EventError,OMX_ErrorSameState,\
1244                    OMX_COMPONENT_GENERATE_EVENT);
1245         eRet = OMX_ErrorSameState;
1246       }
1247       /* Requesting transition from Loaded to WaitForResources */
1248       else if(eState == OMX_StateWaitForResources)
1249       {
1250         /* Since error is None , we will post an event
1251            at the end of this function definition */
1252         DEBUG_PRINT_LOW("send_command_proxy(): Loaded-->WaitForResources\n");
1253       }
1254       /* Requesting transition from Loaded to Executing */
1255       else if(eState == OMX_StateExecuting)
1256       {
1257         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Loaded-->Executing\n");
1258         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
1259                    OMX_COMPONENT_GENERATE_EVENT);
1260         eRet = OMX_ErrorIncorrectStateTransition;
1261       }
1262       /* Requesting transition from Loaded to Pause */
1263       else if(eState == OMX_StatePause)
1264       {
1265         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Loaded-->Pause\n");
1266         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
1267                    OMX_COMPONENT_GENERATE_EVENT);
1268         eRet = OMX_ErrorIncorrectStateTransition;
1269       }
1270       /* Requesting transition from Loaded to Invalid */
1271       else if(eState == OMX_StateInvalid)
1272       {
1273         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Loaded-->Invalid\n");
1274         post_event(OMX_EventError,eState,OMX_COMPONENT_GENERATE_EVENT);
1275         eRet = OMX_ErrorInvalidState;
1276       }
1277       else
1278       {
1279         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Loaded-->Invalid(%d Not Handled)\n",\
1280                           eState);
1281         eRet = OMX_ErrorBadParameter;
1282       }
1283     }
1284
1285     /***************************/
1286     /* Current State is IDLE */
1287     /***************************/
1288     else if(m_state == OMX_StateIdle)
1289     {
1290       if(eState == OMX_StateLoaded)
1291       {
1292         if(release_done())
1293         {
1294           /*
1295              Since error is None , we will post an event at the end
1296              of this function definition
1297           */
1298           DEBUG_PRINT_LOW("send_command_proxy(): Idle-->Loaded\n");
1299         }
1300         else
1301         {
1302           DEBUG_PRINT_LOW("send_command_proxy(): Idle-->Loaded-Pending\n");
1303           BITMASK_SET(&m_flags, OMX_COMPONENT_LOADING_PENDING);
1304           // Skip the event notification
1305           bFlag = 0;
1306         }
1307       }
1308       /* Requesting transition from Idle to Executing */
1309       else if(eState == OMX_StateExecuting)
1310       {
1311         BITMASK_SET(&m_flags,OMX_COMPONENT_EXECUTE_PENDING);
1312         DEBUG_PRINT_LOW("send_command_proxy(): Idle-->Executing\n");
1313         post_event (NULL,VDEC_S_SUCCESS,OMX_COMPONENT_GENERATE_START_DONE);
1314         bFlag = 0;
1315       }
1316       /* Requesting transition from Idle to Idle */
1317       else if(eState == OMX_StateIdle)
1318       {
1319         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Idle-->Idle\n");
1320         post_event(OMX_EventError,OMX_ErrorSameState,\
1321                    OMX_COMPONENT_GENERATE_EVENT);
1322         eRet = OMX_ErrorSameState;
1323       }
1324       /* Requesting transition from Idle to WaitForResources */
1325       else if(eState == OMX_StateWaitForResources)
1326       {
1327         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Idle-->WaitForResources\n");
1328         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
1329                    OMX_COMPONENT_GENERATE_EVENT);
1330         eRet = OMX_ErrorIncorrectStateTransition;
1331       }
1332        /* Requesting transition from Idle to Pause */
1333        else if(eState == OMX_StatePause)
1334       {
1335          /*To pause the Video core we need to start the driver*/
1336          if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_CMD_START,
1337                     NULL) < 0)
1338          {
1339            DEBUG_PRINT_ERROR("\n VDEC_IOCTL_CMD_START FAILED");
1340            omx_report_error ();
1341            eRet = OMX_ErrorHardware;
1342          }
1343          else
1344          {
1345            BITMASK_SET(&m_flags,OMX_COMPONENT_PAUSE_PENDING);
1346            DEBUG_PRINT_LOW("send_command_proxy(): Idle-->Pause\n");
1347            bFlag = 0;
1348          }
1349       }
1350       /* Requesting transition from Idle to Invalid */
1351        else if(eState == OMX_StateInvalid)
1352       {
1353         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Idle-->Invalid\n");
1354         post_event(OMX_EventError,eState,OMX_COMPONENT_GENERATE_EVENT);
1355         eRet = OMX_ErrorInvalidState;
1356       }
1357       else
1358       {
1359         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Idle --> %d Not Handled\n",eState);
1360         eRet = OMX_ErrorBadParameter;
1361       }
1362     }
1363
1364     /******************************/
1365     /* Current State is Executing */
1366     /******************************/
1367     else if(m_state == OMX_StateExecuting)
1368     {
1369        DEBUG_PRINT_LOW("\n Command Recieved in OMX_StateExecuting");
1370        /* Requesting transition from Executing to Idle */
1371        if(eState == OMX_StateIdle)
1372        {
1373          /* Since error is None , we will post an event
1374          at the end of this function definition
1375          */
1376          DEBUG_PRINT_LOW("\n send_command_proxy(): Executing --> Idle \n");
1377          BITMASK_SET(&m_flags,OMX_COMPONENT_IDLE_PENDING);
1378          if(!sem_posted)
1379          {
1380            sem_posted = 1;
1381            sem_post (&m_cmd_lock);
1382            execute_omx_flush(OMX_ALL);
1383          }
1384          bFlag = 0;
1385        }
1386        /* Requesting transition from Executing to Paused */
1387        else if(eState == OMX_StatePause)
1388        {
1389          DEBUG_PRINT_LOW("\n PAUSE Command Issued");
1390          if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_CMD_PAUSE,
1391                     NULL) < 0)
1392          {
1393            DEBUG_PRINT_ERROR("\n Error In Pause State");
1394            post_event(OMX_EventError,OMX_ErrorHardware,\
1395                       OMX_COMPONENT_GENERATE_EVENT);
1396            eRet = OMX_ErrorHardware;
1397          }
1398          else
1399          {
1400            BITMASK_SET(&m_flags,OMX_COMPONENT_PAUSE_PENDING);
1401            DEBUG_PRINT_LOW("send_command_proxy(): Pause-->Executing\n");
1402            bFlag = 0;
1403          }
1404        }
1405        /* Requesting transition from Executing to Loaded */
1406        else if(eState == OMX_StateLoaded)
1407        {
1408          DEBUG_PRINT_ERROR("\n send_command_proxy(): Executing --> Loaded \n");
1409          post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
1410                     OMX_COMPONENT_GENERATE_EVENT);
1411          eRet = OMX_ErrorIncorrectStateTransition;
1412        }
1413        /* Requesting transition from Executing to WaitForResources */
1414        else if(eState == OMX_StateWaitForResources)
1415        {
1416          DEBUG_PRINT_ERROR("\n send_command_proxy(): Executing --> WaitForResources \n");
1417          post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
1418                     OMX_COMPONENT_GENERATE_EVENT);
1419          eRet = OMX_ErrorIncorrectStateTransition;
1420        }
1421        /* Requesting transition from Executing to Executing */
1422        else if(eState == OMX_StateExecuting)
1423        {
1424          DEBUG_PRINT_ERROR("\n send_command_proxy(): Executing --> Executing \n");
1425          post_event(OMX_EventError,OMX_ErrorSameState,\
1426                     OMX_COMPONENT_GENERATE_EVENT);
1427          eRet = OMX_ErrorSameState;
1428        }
1429        /* Requesting transition from Executing to Invalid */
1430        else if(eState == OMX_StateInvalid)
1431        {
1432          DEBUG_PRINT_ERROR("\n send_command_proxy(): Executing --> Invalid \n");
1433          post_event(OMX_EventError,eState,OMX_COMPONENT_GENERATE_EVENT);
1434          eRet = OMX_ErrorInvalidState;
1435        }
1436        else
1437        {
1438          DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Executing --> %d Not Handled\n",eState);
1439          eRet = OMX_ErrorBadParameter;
1440        }
1441     }
1442     /***************************/
1443     /* Current State is Pause  */
1444     /***************************/
1445     else if(m_state == OMX_StatePause)
1446     {
1447       /* Requesting transition from Pause to Executing */
1448       if(eState == OMX_StateExecuting)
1449       {
1450         DEBUG_PRINT_LOW("\n Pause --> Executing \n");
1451         if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_CMD_RESUME,
1452                    NULL) < 0)
1453         {
1454           DEBUG_PRINT_ERROR("\n VDEC_IOCTL_CMD_RESUME failed");
1455           post_event(OMX_EventError,OMX_ErrorHardware,\
1456                      OMX_COMPONENT_GENERATE_EVENT);
1457           eRet = OMX_ErrorHardware;
1458         }
1459         else
1460         {
1461           BITMASK_SET(&m_flags,OMX_COMPONENT_EXECUTE_PENDING);
1462           DEBUG_PRINT_LOW("send_command_proxy(): Idle-->Executing\n");
1463           post_event (NULL,VDEC_S_SUCCESS,\
1464                       OMX_COMPONENT_GENERATE_RESUME_DONE);
1465           bFlag = 0;
1466         }
1467       }
1468       /* Requesting transition from Pause to Idle */
1469       else if(eState == OMX_StateIdle)
1470       {
1471         /* Since error is None , we will post an event
1472         at the end of this function definition */
1473         DEBUG_PRINT_LOW("\n Pause --> Idle \n");
1474          BITMASK_SET(&m_flags,OMX_COMPONENT_IDLE_PENDING);
1475          if(!sem_posted)
1476          {
1477            sem_posted = 1;
1478            sem_post (&m_cmd_lock);
1479            execute_omx_flush(OMX_ALL);
1480          }
1481          bFlag = 0;
1482       }
1483       /* Requesting transition from Pause to loaded */
1484       else if(eState == OMX_StateLoaded)
1485       {
1486         DEBUG_PRINT_ERROR("\n Pause --> loaded \n");
1487         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
1488                    OMX_COMPONENT_GENERATE_EVENT);
1489         eRet = OMX_ErrorIncorrectStateTransition;
1490       }
1491       /* Requesting transition from Pause to WaitForResources */
1492       else if(eState == OMX_StateWaitForResources)
1493       {
1494         DEBUG_PRINT_ERROR("\n Pause --> WaitForResources \n");
1495         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
1496                    OMX_COMPONENT_GENERATE_EVENT);
1497         eRet = OMX_ErrorIncorrectStateTransition;
1498       }
1499       /* Requesting transition from Pause to Pause */
1500       else if(eState == OMX_StatePause)
1501       {
1502         DEBUG_PRINT_ERROR("\n Pause --> Pause \n");
1503         post_event(OMX_EventError,OMX_ErrorSameState,\
1504                    OMX_COMPONENT_GENERATE_EVENT);
1505         eRet = OMX_ErrorSameState;
1506       }
1507        /* Requesting transition from Pause to Invalid */
1508       else if(eState == OMX_StateInvalid)
1509       {
1510         DEBUG_PRINT_ERROR("\n Pause --> Invalid \n");
1511         post_event(OMX_EventError,eState,OMX_COMPONENT_GENERATE_EVENT);
1512         eRet = OMX_ErrorInvalidState;
1513       }
1514       else
1515       {
1516         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Paused --> %d Not Handled\n",eState);
1517         eRet = OMX_ErrorBadParameter;
1518       }
1519     }
1520      /***************************/
1521     /* Current State is WaitForResources  */
1522     /***************************/
1523     else if(m_state == OMX_StateWaitForResources)
1524     {
1525       /* Requesting transition from WaitForResources to Loaded */
1526       if(eState == OMX_StateLoaded)
1527       {
1528         /* Since error is None , we will post an event
1529         at the end of this function definition */
1530         DEBUG_PRINT_LOW("send_command_proxy(): WaitForResources-->Loaded\n");
1531       }
1532       /* Requesting transition from WaitForResources to WaitForResources */
1533       else if (eState == OMX_StateWaitForResources)
1534       {
1535         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): WaitForResources-->WaitForResources\n");
1536         post_event(OMX_EventError,OMX_ErrorSameState,
1537                    OMX_COMPONENT_GENERATE_EVENT);
1538         eRet = OMX_ErrorSameState;
1539       }
1540       /* Requesting transition from WaitForResources to Executing */
1541       else if(eState == OMX_StateExecuting)
1542       {
1543         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): WaitForResources-->Executing\n");
1544         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
1545                    OMX_COMPONENT_GENERATE_EVENT);
1546         eRet = OMX_ErrorIncorrectStateTransition;
1547       }
1548       /* Requesting transition from WaitForResources to Pause */
1549       else if(eState == OMX_StatePause)
1550       {
1551         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): WaitForResources-->Pause\n");
1552         post_event(OMX_EventError,OMX_ErrorIncorrectStateTransition,\
1553                    OMX_COMPONENT_GENERATE_EVENT);
1554         eRet = OMX_ErrorIncorrectStateTransition;
1555       }
1556       /* Requesting transition from WaitForResources to Invalid */
1557       else if(eState == OMX_StateInvalid)
1558       {
1559         DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): WaitForResources-->Invalid\n");
1560         post_event(OMX_EventError,eState,OMX_COMPONENT_GENERATE_EVENT);
1561         eRet = OMX_ErrorInvalidState;
1562       }
1563       /* Requesting transition from WaitForResources to Loaded -
1564       is NOT tested by Khronos TS */
1565
1566     }
1567     else
1568     {
1569       DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): %d --> %d(Not Handled)\n",m_state,eState);
1570       eRet = OMX_ErrorBadParameter;
1571     }
1572   }
1573   /********************************/
1574   /* Current State is Invalid */
1575   /*******************************/
1576   else if(m_state == OMX_StateInvalid)
1577   {
1578     /* State Transition from Inavlid to any state */
1579     if(eState == (OMX_StateLoaded || OMX_StateWaitForResources
1580                   || OMX_StateIdle || OMX_StateExecuting
1581                   || OMX_StatePause || OMX_StateInvalid))
1582     {
1583       DEBUG_PRINT_ERROR("ERROR::send_command_proxy(): Invalid -->Loaded\n");
1584       post_event(OMX_EventError,OMX_ErrorInvalidState,\
1585                  OMX_COMPONENT_GENERATE_EVENT);
1586       eRet = OMX_ErrorInvalidState;
1587     }
1588   }
1589   else if (cmd == OMX_CommandFlush)
1590   {
1591     DEBUG_PRINT_HIGH("\n send_command_proxy(): OMX_CommandFlush issued"
1592         "with param1: %d", param1);
1593     if(0 == param1 || OMX_ALL == param1)
1594     {
1595       BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_FLUSH_PENDING);
1596     }
1597     if(1 == param1 || OMX_ALL == param1)
1598     {
1599       //generate output flush event only.
1600       BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
1601     }
1602     if (!sem_posted){
1603       sem_posted = 1;
1604       DEBUG_PRINT_LOW("\n Set the Semaphore");
1605       sem_post (&m_cmd_lock);
1606       execute_omx_flush(param1);
1607     }
1608     bFlag = 0;
1609   }
1610   else if ( cmd == OMX_CommandPortEnable)
1611   {
1612     DEBUG_PRINT_HIGH("\n send_command_proxy(): OMX_CommandPortEnable issued"
1613         "with param1: %d", param1);
1614     if(param1 == OMX_CORE_INPUT_PORT_INDEX || param1 == OMX_ALL)
1615       {
1616         m_inp_bEnabled = OMX_TRUE;
1617
1618         if( (m_state == OMX_StateLoaded &&
1619              !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
1620             || allocate_input_done())
1621         {
1622           post_event(OMX_CommandPortEnable,OMX_CORE_INPUT_PORT_INDEX,
1623                      OMX_COMPONENT_GENERATE_EVENT);
1624         }
1625         else
1626         {
1627           DEBUG_PRINT_LOW("send_command_proxy(): Disabled-->Enabled Pending\n");
1628           BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_ENABLE_PENDING);
1629           // Skip the event notification
1630           bFlag = 0;
1631         }
1632       }
1633       if(param1 == OMX_CORE_OUTPUT_PORT_INDEX || param1 == OMX_ALL)
1634       {
1635           DEBUG_PRINT_LOW("\n Enable output Port command recieved");
1636           m_out_bEnabled = OMX_TRUE;
1637
1638           if( (m_state == OMX_StateLoaded &&
1639               !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
1640               || (allocate_output_done()))
1641           {
1642              post_event(OMX_CommandPortEnable,OMX_CORE_OUTPUT_PORT_INDEX,
1643                         OMX_COMPONENT_GENERATE_EVENT);
1644
1645           }
1646           else
1647           {
1648               DEBUG_PRINT_LOW("send_command_proxy(): Disabled-->Enabled Pending\n");
1649               BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
1650               // Skip the event notification
1651               bFlag = 0;
1652           }
1653       }
1654   }
1655   else if (cmd == OMX_CommandPortDisable)
1656   {
1657       DEBUG_PRINT_HIGH("\n send_command_proxy(): OMX_CommandPortDisable issued"
1658           "with param1: %d", param1);
1659       if(param1 == OMX_CORE_INPUT_PORT_INDEX || param1 == OMX_ALL)
1660       {
1661           m_inp_bEnabled = OMX_FALSE;
1662           if((m_state == OMX_StateLoaded || m_state == OMX_StateIdle)
1663               && release_input_done())
1664           {
1665              post_event(OMX_CommandPortDisable,OMX_CORE_INPUT_PORT_INDEX,
1666                         OMX_COMPONENT_GENERATE_EVENT);
1667           }
1668           else
1669           {
1670              BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_DISABLE_PENDING);
1671              if(m_state == OMX_StatePause ||m_state == OMX_StateExecuting)
1672              {
1673                if(!sem_posted)
1674                {
1675                  sem_posted = 1;
1676                  sem_post (&m_cmd_lock);
1677                 execute_omx_flush(OMX_CORE_INPUT_PORT_INDEX);
1678                }
1679              }
1680
1681              // Skip the event notification
1682              bFlag = 0;
1683           }
1684       }
1685       if(param1 == OMX_CORE_OUTPUT_PORT_INDEX || param1 == OMX_ALL)
1686       {
1687           m_out_bEnabled = OMX_FALSE;
1688           DEBUG_PRINT_LOW("\n Disable output Port command recieved");
1689           if((m_state == OMX_StateLoaded || m_state == OMX_StateIdle)
1690               && release_output_done())
1691           {
1692              post_event(OMX_CommandPortDisable,OMX_CORE_OUTPUT_PORT_INDEX,\
1693                         OMX_COMPONENT_GENERATE_EVENT);
1694           }
1695           else
1696          {
1697             BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
1698             if(m_state == OMX_StatePause ||m_state == OMX_StateExecuting)
1699             {
1700               if(!sem_posted)
1701               {
1702                 sem_posted = 1;
1703                 sem_post (&m_cmd_lock);
1704                 execute_omx_flush(OMX_CORE_OUTPUT_PORT_INDEX);
1705               }
1706             }
1707             // Skip the event notification
1708             bFlag = 0;
1709
1710          }
1711       }
1712   }
1713   else
1714   {
1715     DEBUG_PRINT_ERROR("Error: Invalid Command other than StateSet (%d)\n",cmd);
1716     eRet = OMX_ErrorNotImplemented;
1717   }
1718   if(eRet == OMX_ErrorNone && bFlag)
1719   {
1720     post_event(cmd,eState,OMX_COMPONENT_GENERATE_EVENT);
1721   }
1722   if(!sem_posted)
1723   {
1724     sem_post(&m_cmd_lock);
1725   }
1726
1727   return eRet;
1728 }
1729
1730 /* ======================================================================
1731 FUNCTION
1732   omx_vdec::ExecuteOmxFlush
1733
1734 DESCRIPTION
1735   Executes the OMX flush.
1736
1737 PARAMETERS
1738   flushtype - input flush(1)/output flush(0)/ both.
1739
1740 RETURN VALUE
1741   true/false
1742
1743 ========================================================================== */
1744 bool omx_vdec::execute_omx_flush(OMX_U32 flushType)
1745 {
1746   struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
1747   enum vdec_bufferflush flush_dir = VDEC_FLUSH_TYPE_ALL;
1748   bool bRet = false;
1749
1750   if(flushType == 0 || flushType == OMX_ALL)
1751   {
1752     input_flush_progress = true;
1753     //flush input only
1754     bRet = execute_input_flush(flushType);
1755   }
1756   if(flushType == 1 || flushType == OMX_ALL)
1757   {
1758     //flush output only
1759     output_flush_progress = true;
1760     bRet = execute_output_flush(flushType);
1761   }
1762
1763   if(flushType == OMX_ALL)
1764   {
1765     /*Check if there are buffers with the Driver*/
1766     DEBUG_PRINT_LOW("\n Flush ALL ioctl issued");
1767     ioctl_msg.inputparam = &flush_dir;
1768     ioctl_msg.outputparam = NULL;
1769
1770     if (ioctl(driver_context.video_driver_fd,VDEC_IOCTL_CMD_FLUSH,&ioctl_msg) < 0)
1771     {
1772       DEBUG_PRINT_ERROR("\n Flush ALL Failed ");
1773       return false;
1774     }
1775   }
1776
1777   return bRet;
1778 }
1779 /*=========================================================================
1780 FUNCTION : execute_output_flush
1781
1782 DESCRIPTION
1783   Executes the OMX flush at OUTPUT PORT.
1784
1785 PARAMETERS
1786   None.
1787
1788 RETURN VALUE
1789   true/false
1790 ==========================================================================*/
1791 bool omx_vdec::execute_output_flush(OMX_U32 flushType)
1792 {
1793   struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
1794   enum vdec_bufferflush flush_dir = VDEC_FLUSH_TYPE_OUTPUT;
1795   unsigned      p1 = 0; // Parameter - 1
1796   unsigned      p2 = 0; // Parameter - 2
1797   unsigned      ident = 0;
1798   bool bRet = true;
1799
1800   /*Generate FBD for all Buffers in the FTBq*/
1801   pthread_mutex_lock(&m_lock);
1802   DEBUG_PRINT_LOW("\n Initiate Output Flush");
1803   while (m_ftb_q.m_size)
1804   {
1805     DEBUG_PRINT_LOW("\n Buffer queue size %d pending buf cnt %d",
1806                        m_ftb_q.m_size,pending_output_buffers);
1807     m_ftb_q.pop_entry(&p1,&p2,&ident);
1808
1809     if(ident == OMX_COMPONENT_GENERATE_FTB )
1810     {
1811       DEBUG_PRINT_LOW("\n Inside Flush Buffer OMX_COMPONENT_GENERATE_FTB");
1812       pending_output_buffers++;
1813       fill_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p2);
1814     }
1815     else if (ident == OMX_COMPONENT_GENERATE_FBD)
1816     {
1817       fill_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p1);
1818     }
1819   }
1820   pthread_mutex_unlock(&m_lock);
1821
1822   if(gate_output_buffers)
1823   {
1824     DEBUG_PRINT_LOW("\n Output Buffers gated Check flush response");
1825     if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_FLUSH_PENDING))
1826     {
1827       DEBUG_PRINT_LOW("\n Notify Output Flush done");
1828       BITMASK_CLEAR (&m_flags,OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
1829       m_cb.EventHandler(&m_cmp,m_app_data,OMX_EventCmdComplete,OMX_CommandFlush,
1830                                OMX_CORE_OUTPUT_PORT_INDEX,NULL );
1831     }
1832     output_flush_progress = false;
1833     return bRet;
1834   }
1835
1836   DEBUG_PRINT_LOW("\n output buffers count = %d",pending_output_buffers);
1837
1838   if(flushType == 1)
1839   {
1840     /*Check if there are buffers with the Driver*/
1841     DEBUG_PRINT_LOW("\n ioctl command flush for output");
1842     ioctl_msg.inputparam = &flush_dir;
1843     ioctl_msg.outputparam = NULL;
1844
1845     if (ioctl(driver_context.video_driver_fd,VDEC_IOCTL_CMD_FLUSH,&ioctl_msg) < 0)
1846     {
1847       DEBUG_PRINT_ERROR("\n output flush failed");
1848       return false;
1849     }
1850   }
1851
1852   return bRet;
1853 }
1854 /*=========================================================================
1855 FUNCTION : execute_input_flush
1856
1857 DESCRIPTION
1858   Executes the OMX flush at INPUT PORT.
1859
1860 PARAMETERS
1861   None.
1862
1863 RETURN VALUE
1864   true/false
1865 ==========================================================================*/
1866 bool omx_vdec::execute_input_flush(OMX_U32 flushType)
1867 {
1868   struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
1869   enum vdec_bufferflush flush_dir = VDEC_FLUSH_TYPE_INPUT;
1870   unsigned       i =0;
1871   unsigned      p1 = 0; // Parameter - 1
1872   unsigned      p2 = 0; // Parameter - 2
1873   unsigned      ident = 0;
1874   bool bRet = true;
1875
1876   /*Generate EBD for all Buffers in the ETBq*/
1877   DEBUG_PRINT_LOW("\n Initiate Input Flush \n");
1878
1879   pthread_mutex_lock(&m_lock);
1880   DEBUG_PRINT_LOW("\n Check if the Queue is empty \n");
1881   while (m_etb_q.m_size)
1882   {
1883     m_etb_q.pop_entry(&p1,&p2,&ident);
1884
1885     if (ident == OMX_COMPONENT_GENERATE_ETB_ARBITRARY)
1886     {
1887       DEBUG_PRINT_LOW("\n Flush Input Heap Buffer %p",(OMX_BUFFERHEADERTYPE *)p2);
1888       m_cb.EmptyBufferDone(&m_cmp ,m_app_data, (OMX_BUFFERHEADERTYPE *)p2);
1889     }
1890     else if(ident == OMX_COMPONENT_GENERATE_ETB)
1891     {
1892       pending_input_buffers++;
1893       empty_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p2);
1894     }
1895     else if (ident == OMX_COMPONENT_GENERATE_EBD)
1896     {
1897       empty_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p1);
1898     }
1899   }
1900
1901   /*Check if Heap Buffers are to be flushed*/
1902   if (arbitrary_bytes)
1903   {
1904     DEBUG_PRINT_LOW("\n Reset all the variables before flusing");
1905     h264_scratch.nFilledLen = 0;
1906     nal_count = 0;
1907     look_ahead_nal = false;
1908     frame_count = 0;
1909     DEBUG_PRINT_LOW("\n Initialize parser");
1910     if (m_frame_parser.mutils)
1911     {
1912       m_frame_parser.mutils->initialize_frame_checking_environment();
1913     }
1914
1915     while (m_input_pending_q.m_size)
1916     {
1917       m_input_pending_q.pop_entry(&p1,&p2,&ident);
1918       m_cb.EmptyBufferDone(&m_cmp ,m_app_data, (OMX_BUFFERHEADERTYPE *)p1);
1919     }
1920
1921     if (psource_frame)
1922     {
1923       m_cb.EmptyBufferDone(&m_cmp ,m_app_data,psource_frame);
1924       psource_frame = NULL;
1925     }
1926
1927     if (pdest_frame)
1928     {
1929       pdest_frame->nFilledLen = 0;
1930       m_input_free_q.insert_entry((unsigned) pdest_frame,NULL,NULL);
1931       pdest_frame = NULL;
1932     }
1933     m_frame_parser.flush();
1934   }
1935
1936   pthread_mutex_unlock(&m_lock);
1937   DEBUG_PRINT_LOW("\n Value of pending input buffers %d \n",pending_input_buffers);
1938
1939   if(flushType == 0)
1940   {
1941     /*Check if there are buffers with the Driver*/
1942     DEBUG_PRINT_LOW("\n Input Flush ioctl issued");
1943     ioctl_msg.inputparam = &flush_dir;
1944     ioctl_msg.outputparam = NULL;
1945
1946     if (ioctl(driver_context.video_driver_fd,VDEC_IOCTL_CMD_FLUSH,&ioctl_msg) < 0)
1947     {
1948       DEBUG_PRINT_ERROR("\n Input Flush Failed ");
1949       return false;
1950     }
1951   }
1952
1953   return bRet;
1954 }
1955
1956
1957 /* ======================================================================
1958 FUNCTION
1959   omx_vdec::SendCommandEvent
1960
1961 DESCRIPTION
1962   Send the event to decoder pipe.  This is needed to generate the callbacks
1963   in decoder thread context.
1964
1965 PARAMETERS
1966   None.
1967
1968 RETURN VALUE
1969   true/false
1970
1971 ========================================================================== */
1972 bool omx_vdec::post_event(unsigned int p1,
1973                           unsigned int p2,
1974                           unsigned int id)
1975 {
1976   bool bRet      =                      false;
1977
1978
1979   pthread_mutex_lock(&m_lock);
1980
1981   if( id == OMX_COMPONENT_GENERATE_FTB || \
1982       (id == OMX_COMPONENT_GENERATE_FBD)||
1983       (id == OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH))
1984   {
1985     m_ftb_q.insert_entry(p1,p2,id);
1986   }
1987   else if((id == OMX_COMPONENT_GENERATE_ETB) \
1988           || (id == OMX_COMPONENT_GENERATE_EBD)||
1989           (id == OMX_COMPONENT_GENERATE_ETB_ARBITRARY)||
1990           (id == OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH))
1991   {
1992     m_etb_q.insert_entry(p1,p2,id);
1993   }
1994   else
1995   {
1996     m_cmd_q.insert_entry(p1,p2,id);
1997   }
1998
1999   bRet = true;
2000   DEBUG_PRINT_LOW("\n Value of this pointer in post_event %p",this);
2001   post_message(this, id);
2002
2003   pthread_mutex_unlock(&m_lock);
2004
2005   return bRet;
2006 }
2007
2008 /* ======================================================================
2009 FUNCTION
2010   omx_vdec::GetParameter
2011
2012 DESCRIPTION
2013   OMX Get Parameter method implementation
2014
2015 PARAMETERS
2016   <TBD>.
2017
2018 RETURN VALUE
2019   Error None if successful.
2020
2021 ========================================================================== */
2022 OMX_ERRORTYPE  omx_vdec::get_parameter(OMX_IN OMX_HANDLETYPE     hComp,
2023                                            OMX_IN OMX_INDEXTYPE paramIndex,
2024                                            OMX_INOUT OMX_PTR     paramData)
2025 {
2026     OMX_ERRORTYPE eRet = OMX_ErrorNone;
2027     unsigned int height=0,width = 0;
2028
2029     DEBUG_PRINT_LOW("get_parameter: \n");
2030     if(m_state == OMX_StateInvalid)
2031     {
2032         DEBUG_PRINT_ERROR("Get Param in Invalid State\n");
2033         return OMX_ErrorInvalidState;
2034     }
2035     if(paramData == NULL)
2036     {
2037         DEBUG_PRINT_LOW("Get Param in Invalid paramData \n");
2038         return OMX_ErrorBadParameter;
2039     }
2040   switch(paramIndex)
2041   {
2042     case OMX_IndexParamPortDefinition:
2043     {
2044       OMX_PARAM_PORTDEFINITIONTYPE *portDefn;
2045       portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData;
2046
2047       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamPortDefinition\n");
2048
2049         portDefn->nVersion.nVersion = OMX_SPEC_VERSION;
2050         portDefn->nSize = sizeof(portDefn);
2051         portDefn->eDomain    = OMX_PortDomainVideo;
2052         portDefn->format.video.nFrameHeight =  m_crop_dy;
2053         portDefn->format.video.nFrameWidth  =  m_crop_dx;
2054         portDefn->format.video.nStride = m_width;
2055         portDefn->format.video.nSliceHeight = m_height;
2056         portDefn->format.video.xFramerate= 25;
2057
2058       if (0 == portDefn->nPortIndex)
2059       {
2060         portDefn->eDir =  OMX_DirInput;
2061         /*Actual count is based on input buffer count*/
2062         portDefn->nBufferCountActual = m_inp_buf_count;
2063         /*Set the Min count*/
2064         portDefn->nBufferCountMin    = m_inp_buf_count_min;
2065         portDefn->nBufferSize        = m_inp_buf_size;
2066         portDefn->format.video.eColorFormat = OMX_COLOR_FormatUnused;
2067         portDefn->format.video.eCompressionFormat = eCompressionFormat;
2068         portDefn->bEnabled   = m_inp_bEnabled;
2069         portDefn->bPopulated = m_inp_bPopulated;
2070       }
2071       else if (1 == portDefn->nPortIndex)
2072       {
2073         m_out_buf_count = m_out_buf_count_recon;
2074         m_out_buf_count_min = m_out_buf_count_min_recon;
2075         m_out_buf_size = m_out_buf_size_recon;
2076         portDefn->eDir =  OMX_DirOutput;
2077         portDefn->nBufferCountActual = m_out_buf_count;
2078         portDefn->nBufferCountMin    = m_out_buf_count_min;
2079         portDefn->nBufferSize = m_out_buf_size;
2080         portDefn->bEnabled   = m_out_bEnabled;
2081         portDefn->bPopulated = m_out_bPopulated;
2082         height = driver_context.video_resoultion.frame_height;
2083         width = driver_context.video_resoultion.frame_width;
2084
2085         portDefn->format.video.nFrameHeight =  height;
2086         portDefn->format.video.nFrameWidth  =  width;
2087         portDefn->format.video.nStride      = stride;
2088         portDefn->format.video.nSliceHeight = scan_lines;
2089         DEBUG_PRINT_LOW("\n Get Param Slice Height %d Slice Width %d",
2090                            scan_lines,stride);
2091         //TODO: Need to add color format
2092         portDefn->format.video.eColorFormat = m_color_format;
2093         portDefn->format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2094         DEBUG_PRINT_LOW("\n Output Actual %d Output Min %d",
2095                            portDefn->nBufferCountActual,portDefn->nBufferCountMin);
2096       }
2097       else
2098       {
2099         portDefn->eDir =  OMX_DirMax;
2100         DEBUG_PRINT_LOW(" get_parameter: Bad Port idx %d",
2101                  (int)portDefn->nPortIndex);
2102         eRet = OMX_ErrorBadPortIndex;
2103       }
2104
2105       break;
2106     }
2107     case OMX_IndexParamVideoInit:
2108     {
2109       OMX_PORT_PARAM_TYPE *portParamType =
2110                               (OMX_PORT_PARAM_TYPE *) paramData;
2111       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoInit\n");
2112
2113       portParamType->nVersion.nVersion = OMX_SPEC_VERSION;
2114       portParamType->nSize = sizeof(portParamType);
2115       portParamType->nPorts           = 2;
2116       portParamType->nStartPortNumber = 0;
2117       break;
2118     }
2119     case OMX_IndexParamVideoPortFormat:
2120     {
2121       OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt =
2122                      (OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData;
2123       DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoPortFormat\n");
2124
2125       portFmt->nVersion.nVersion = OMX_SPEC_VERSION;
2126       portFmt->nSize             = sizeof(portFmt);
2127
2128       if (0 == portFmt->nPortIndex)
2129       {
2130         if (0 == portFmt->nIndex)
2131         {
2132               portFmt->eColorFormat =  OMX_COLOR_FormatUnused;
2133               portFmt->eCompressionFormat = eCompressionFormat;
2134         }
2135         else
2136         {
2137           DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamVideoPortFormat:"\
2138               " NoMore compression formats\n");
2139           eRet =  OMX_ErrorNoMore;
2140         }
2141       }
2142       else if (1 == portFmt->nPortIndex)
2143       {
2144         if (0 == portFmt->nIndex)
2145         {
2146            if (driver_context.output_format == VDEC_YUV_FORMAT_NV12)
2147              portFmt->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2148            else
2149             portFmt->eColorFormat = (OMX_COLOR_FORMATTYPE)0x7F000000;
2150
2151            portFmt->eCompressionFormat =  OMX_VIDEO_CodingUnused;
2152         }
2153         else
2154         {
2155            DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoPortFormat:"\
2156                   " NoMore Color formats\n");
2157            eRet =  OMX_ErrorNoMore;
2158         }
2159       }
2160       else
2161       {
2162         DEBUG_PRINT_ERROR("get_parameter: Bad port index %d\n",
2163                           (int)portFmt->nPortIndex);
2164         eRet = OMX_ErrorBadPortIndex;
2165       }
2166       break;
2167     }
2168     /*Component should support this port definition*/
2169     case OMX_IndexParamAudioInit:
2170     {
2171         OMX_PORT_PARAM_TYPE *audioPortParamType =
2172                                               (OMX_PORT_PARAM_TYPE *) paramData;
2173         DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamAudioInit\n");
2174         audioPortParamType->nVersion.nVersion = OMX_SPEC_VERSION;
2175         audioPortParamType->nSize = sizeof(audioPortParamType);
2176         audioPortParamType->nPorts           = 0;
2177         audioPortParamType->nStartPortNumber = 0;
2178         break;
2179     }
2180     /*Component should support this port definition*/
2181     case OMX_IndexParamImageInit:
2182     {
2183         OMX_PORT_PARAM_TYPE *imagePortParamType =
2184                                               (OMX_PORT_PARAM_TYPE *) paramData;
2185         DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamImageInit\n");
2186         imagePortParamType->nVersion.nVersion = OMX_SPEC_VERSION;
2187         imagePortParamType->nSize = sizeof(imagePortParamType);
2188         imagePortParamType->nPorts           = 0;
2189         imagePortParamType->nStartPortNumber = 0;
2190         break;
2191
2192     }
2193     /*Component should support this port definition*/
2194     case OMX_IndexParamOtherInit:
2195     {
2196         DEBUG_PRINT_ERROR("get_parameter: OMX_IndexParamOtherInit %08x\n",
2197                           paramIndex);
2198         eRet =OMX_ErrorUnsupportedIndex;
2199         break;
2200     }
2201     case OMX_IndexParamStandardComponentRole:
2202     {
2203         OMX_PARAM_COMPONENTROLETYPE *comp_role;
2204         comp_role = (OMX_PARAM_COMPONENTROLETYPE *) paramData;
2205         comp_role->nVersion.nVersion = OMX_SPEC_VERSION;
2206         comp_role->nSize = sizeof(*comp_role);
2207
2208         DEBUG_PRINT_LOW("Getparameter: OMX_IndexParamStandardComponentRole %d\n",
2209                     paramIndex);
2210         strncpy((char*)comp_role->cRole,(const char*)m_cRole,
2211                     OMX_MAX_STRINGNAME_SIZE);
2212         break;
2213     }
2214     /* Added for parameter test */
2215     case OMX_IndexParamPriorityMgmt:
2216         {
2217
2218             OMX_PRIORITYMGMTTYPE *priorityMgmType =
2219                                              (OMX_PRIORITYMGMTTYPE *) paramData;
2220             DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamPriorityMgmt\n");
2221             priorityMgmType->nVersion.nVersion = OMX_SPEC_VERSION;
2222             priorityMgmType->nSize = sizeof(priorityMgmType);
2223
2224             break;
2225         }
2226     /* Added for parameter test */
2227     case OMX_IndexParamCompBufferSupplier:
2228         {
2229             OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType =
2230                                      (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData;
2231             DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamCompBufferSupplier\n");
2232
2233             bufferSupplierType->nSize = sizeof(bufferSupplierType);
2234             bufferSupplierType->nVersion.nVersion = OMX_SPEC_VERSION;
2235             if(0 == bufferSupplierType->nPortIndex)
2236                 bufferSupplierType->nPortIndex = OMX_BufferSupplyUnspecified;
2237             else if (1 == bufferSupplierType->nPortIndex)
2238                 bufferSupplierType->nPortIndex = OMX_BufferSupplyUnspecified;
2239             else
2240                 eRet = OMX_ErrorBadPortIndex;
2241
2242
2243             break;
2244         }
2245     case OMX_IndexParamVideoAvc:
2246         {
2247             DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoAvc %08x\n",
2248                         paramIndex);
2249             break;
2250         }
2251     case OMX_IndexParamVideoH263:
2252         {
2253             DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoH263 %08x\n",
2254                         paramIndex);
2255             break;
2256         }
2257     case OMX_IndexParamVideoMpeg4:
2258         {
2259             DEBUG_PRINT_LOW("get_parameter: OMX_IndexParamVideoMpeg4 %08x\n",
2260                         paramIndex);
2261             break;
2262         }
2263     default:
2264     {
2265       DEBUG_PRINT_ERROR("get_parameter: unknown param %08x\n", paramIndex);
2266       eRet =OMX_ErrorUnsupportedIndex;
2267     }
2268
2269   }
2270
2271   DEBUG_PRINT_LOW("\n get_parameter returning Height %d , Width %d \n",
2272               m_height, m_width);
2273   return eRet;
2274
2275 }
2276
2277 /* ======================================================================
2278 FUNCTION
2279   omx_vdec::Setparameter
2280
2281 DESCRIPTION
2282   OMX Set Parameter method implementation.
2283
2284 PARAMETERS
2285   <TBD>.
2286
2287 RETURN VALUE
2288   OMX Error None if successful.
2289
2290 ========================================================================== */
2291 OMX_ERRORTYPE  omx_vdec::set_parameter(OMX_IN OMX_HANDLETYPE     hComp,
2292                                            OMX_IN OMX_INDEXTYPE paramIndex,
2293                                            OMX_IN OMX_PTR        paramData)
2294 {
2295     OMX_ERRORTYPE eRet = OMX_ErrorNone;
2296     struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
2297     unsigned int   alignment = 0,buffer_size = 0;
2298     int           i;
2299
2300     if(m_state == OMX_StateInvalid)
2301     {
2302         DEBUG_PRINT_ERROR("Set Param in Invalid State\n");
2303         return OMX_ErrorInvalidState;
2304     }
2305     if(paramData == NULL)
2306     {
2307          DEBUG_PRINT_ERROR("Get Param in Invalid paramData \n");
2308          return OMX_ErrorBadParameter;
2309     }
2310   switch(paramIndex)
2311   {
2312     case OMX_IndexParamPortDefinition:
2313     {
2314       OMX_PARAM_PORTDEFINITIONTYPE *portDefn;
2315       portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData;
2316
2317       /*set_parameter can be called in loaded state
2318       or disabled port */
2319
2320       /* When the component is in Loaded state and IDLE Pending*/
2321       if(((m_state == OMX_StateLoaded)&&
2322           !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
2323          /* Or while the I/P or the O/P port or disabled */
2324          ||((OMX_DirInput == portDefn->eDir && m_inp_bEnabled == OMX_FALSE)||
2325          (OMX_DirOutput == portDefn->eDir && m_out_bEnabled == OMX_FALSE)))
2326       {
2327        DEBUG_PRINT_LOW("Set Parameter called in valid state");
2328       }
2329       else
2330       {
2331          DEBUG_PRINT_ERROR("Set Parameter called in Invalid State\n");
2332          return OMX_ErrorIncorrectStateOperation;
2333       }
2334       DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPortDefinition H= %d, W = %d\n",
2335              (int)portDefn->format.video.nFrameHeight,
2336              (int)portDefn->format.video.nFrameWidth);
2337
2338       eRet = omx_vdec_validate_port_param(portDefn->format.video.nFrameHeight,
2339                                           portDefn->format.video.nFrameWidth);
2340       if(eRet != OMX_ErrorNone)
2341       {
2342          return OMX_ErrorUnsupportedSetting;
2343       }
2344       if(OMX_DirOutput == portDefn->eDir)
2345       {
2346           if ( portDefn->nBufferCountActual < m_out_buf_count_min ||
2347                portDefn->nBufferSize !=  m_out_buf_size
2348               )
2349           {
2350               return OMX_ErrorBadParameter;
2351           }
2352           driver_context.output_buffer.buffer_type = VDEC_BUFFER_TYPE_OUTPUT;
2353           ioctl_msg.inputparam = NULL;
2354           ioctl_msg.outputparam = &driver_context.output_buffer;
2355
2356           if (ioctl (driver_context.video_driver_fd,
2357                      VDEC_IOCTL_GET_BUFFER_REQ,(void*)&ioctl_msg) < 0)
2358           {
2359               DEBUG_PRINT_ERROR("\n Request output buffer requirements failed");
2360               return OMX_ErrorUnsupportedSetting;
2361           }
2362           driver_context.output_buffer.buffer_type = VDEC_BUFFER_TYPE_OUTPUT;
2363           driver_context.output_buffer.actualcount =
2364                                                 portDefn->nBufferCountActual;
2365           ioctl_msg.inputparam = &driver_context.output_buffer;
2366           ioctl_msg.outputparam = NULL;
2367
2368           if (ioctl (driver_context.video_driver_fd,
2369                      VDEC_IOCTL_SET_BUFFER_REQ,(void*)&ioctl_msg) < 0)
2370           {
2371               DEBUG_PRINT_ERROR("\n Request output buffer requirements failed");
2372               return OMX_ErrorUnsupportedSetting;
2373           }
2374           m_out_buf_count = portDefn->nBufferCountActual;
2375           m_out_buf_count_recon = m_out_buf_count;
2376         DEBUG_PRINT_LOW("set_parameter:OMX_IndexParamPortDefinition output port\n");
2377       }
2378       else if(OMX_DirInput == portDefn->eDir)
2379       {
2380          if(m_height != portDefn->format.video.nFrameHeight ||
2381             m_width  != portDefn->format.video.nFrameWidth)
2382          {
2383            DEBUG_PRINT_LOW("set_parameter ip port: stride %d\n",
2384                        (int)portDefn->format.video.nStride);
2385            // set the HxW only if non-zero
2386            if((portDefn->format.video.nFrameHeight != 0x0)
2387               && (portDefn->format.video.nFrameWidth != 0x0))
2388            {
2389                m_crop_x = m_crop_y = 0;
2390                m_crop_dy = m_port_height = m_height =
2391                  portDefn->format.video.nFrameHeight;
2392                m_crop_dx = m_port_width = m_width  =
2393                  portDefn->format.video.nFrameWidth;
2394                scan_lines = portDefn->format.video.nSliceHeight;
2395                stride = portDefn->format.video.nStride;
2396                DEBUG_PRINT_LOW("\n SetParam with new H %d and W %d\n",
2397                            m_height, m_width );
2398                driver_context.video_resoultion.frame_height = m_height;
2399                driver_context.video_resoultion.frame_width = m_width;
2400                driver_context.video_resoultion.stride = stride;
2401                driver_context.video_resoultion.scan_lines = scan_lines;
2402                ioctl_msg.inputparam = &driver_context.video_resoultion;
2403                ioctl_msg.outputparam = NULL;
2404
2405                if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_PICRES,
2406                           (void*)&ioctl_msg) < 0)
2407                {
2408                    DEBUG_PRINT_ERROR("\n Set Resolution failed");
2409                    return OMX_ErrorUnsupportedSetting;
2410                }
2411                driver_context.output_buffer.buffer_type =
2412                                                         VDEC_BUFFER_TYPE_OUTPUT;
2413                ioctl_msg.inputparam = NULL;
2414                ioctl_msg.outputparam = &driver_context.output_buffer;
2415
2416                if (ioctl (driver_context.video_driver_fd,
2417                           VDEC_IOCTL_GET_BUFFER_REQ,(void*)&ioctl_msg) < 0)
2418                {
2419                    DEBUG_PRINT_ERROR("\n Request output buffer requirements failed");
2420                    return OMX_ErrorUnsupportedSetting;
2421                }
2422
2423                m_out_buf_count_recon = m_out_buf_count = driver_context.output_buffer.actualcount;
2424                m_out_buf_count_min_recon = m_out_buf_count_min = driver_context.output_buffer.mincount;
2425
2426                alignment = driver_context.output_buffer.alignment;
2427                buffer_size = driver_context.output_buffer.buffer_size;
2428                m_out_buf_size_recon = m_out_buf_size =
2429                  ((buffer_size + alignment - 1) & (~(alignment - 1)));
2430            }
2431         }
2432         else
2433         {
2434             /*
2435               If actual buffer count is greater than the Min buffer
2436               count,change the actual count.
2437               m_inp_buf_count is initialized to OMX_CORE_NUM_INPUT_BUFFERS
2438               in the constructor
2439             */
2440             if ( portDefn->nBufferCountActual < m_inp_buf_count_min ||
2441                  portDefn->nBufferSize !=  m_inp_buf_size
2442                 )
2443             {
2444                 return OMX_ErrorBadParameter;
2445             }
2446                /*Get the Buffer requirements for input and output ports*/
2447                driver_context.input_buffer.buffer_type = VDEC_BUFFER_TYPE_INPUT;
2448                ioctl_msg.inputparam = NULL;
2449                ioctl_msg.outputparam = &driver_context.input_buffer;
2450
2451                if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_GET_BUFFER_REQ,
2452                           (void*)&ioctl_msg) < 0)
2453                {
2454                    DEBUG_PRINT_ERROR("\n Request input buffer requirements failed");
2455                    return OMX_ErrorUnsupportedSetting;
2456                }
2457
2458                driver_context.input_buffer.buffer_type = VDEC_BUFFER_TYPE_INPUT;
2459                driver_context.input_buffer.actualcount =
2460                  portDefn->nBufferCountActual;
2461                ioctl_msg.inputparam = &driver_context.input_buffer;
2462                ioctl_msg.outputparam = NULL;
2463
2464                if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_BUFFER_REQ,
2465                           (void*)&ioctl_msg) < 0)
2466                {
2467                    DEBUG_PRINT_ERROR("\n Request input buffer requirements failed");
2468                    return OMX_ErrorUnsupportedSetting;
2469                }
2470
2471             m_inp_buf_count = portDefn->nBufferCountActual;
2472           DEBUG_PRINT_LOW("\n set_parameter: Image Dimensions same  \n");
2473         }
2474
2475       }
2476       else if (portDefn->eDir ==  OMX_DirMax)
2477       {
2478           DEBUG_PRINT_ERROR(" Set_parameter: Bad Port idx %d",
2479                       (int)portDefn->nPortIndex);
2480           eRet = OMX_ErrorBadPortIndex;
2481       }
2482     }
2483     break;
2484
2485
2486     case OMX_IndexParamVideoPortFormat:
2487     {
2488       OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt =
2489                      (OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData;
2490       DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %d\n",
2491               portFmt->eColorFormat);
2492
2493       DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %d\n",
2494              portFmt->eColorFormat);
2495       if(1 == portFmt->nPortIndex)
2496       {
2497
2498          m_color_format = portFmt->eColorFormat;
2499       }
2500     }
2501     break;
2502
2503     case OMX_QcomIndexPortDefn:
2504     {
2505         OMX_QCOM_PARAM_PORTDEFINITIONTYPE *portFmt =
2506             (OMX_QCOM_PARAM_PORTDEFINITIONTYPE *) paramData;
2507         DEBUG_PRINT_LOW("set_parameter: OMX_IndexQcomParamPortDefinitionType %d\n",
2508             portFmt->nFramePackingFormat);
2509
2510         /* Input port */
2511         if (portFmt->nPortIndex == 0)
2512         {
2513             if (portFmt->nFramePackingFormat == OMX_QCOM_FramePacking_Arbitrary)
2514             {
2515                arbitrary_bytes = true;
2516             }
2517             else if (portFmt->nFramePackingFormat ==
2518                 OMX_QCOM_FramePacking_OnlyOneCompleteFrame)
2519             {
2520                arbitrary_bytes = false;
2521             }
2522             else
2523             {
2524                 DEBUG_PRINT_ERROR("Setparameter: unknown FramePacking format %d\n",
2525                     portFmt->nFramePackingFormat);
2526                 eRet = OMX_ErrorUnsupportedSetting;
2527             }
2528         }
2529     }
2530     break;
2531
2532      case OMX_IndexParamStandardComponentRole:
2533      {
2534           OMX_PARAM_COMPONENTROLETYPE *comp_role;
2535           comp_role = (OMX_PARAM_COMPONENTROLETYPE *) paramData;
2536           DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamStandardComponentRole %s\n",
2537                        comp_role->cRole);
2538
2539           if((m_state == OMX_StateLoaded)&&
2540               !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
2541           {
2542            DEBUG_PRINT_LOW("Set Parameter called in valid state");
2543           }
2544           else
2545           {
2546              DEBUG_PRINT_ERROR("Set Parameter called in Invalid State\n");
2547              return OMX_ErrorIncorrectStateOperation;
2548           }
2549
2550           if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.avc",OMX_MAX_STRINGNAME_SIZE))
2551           {
2552               if(!strncmp((char*)comp_role->cRole,"video_decoder.avc",OMX_MAX_STRINGNAME_SIZE))
2553               {
2554                   strncpy((char*)m_cRole,"video_decoder.avc",OMX_MAX_STRINGNAME_SIZE);
2555               }
2556               else
2557               {
2558                   DEBUG_PRINT_ERROR("Setparameter: unknown Index %s\n", comp_role->cRole);
2559                   eRet =OMX_ErrorUnsupportedSetting;
2560               }
2561           }
2562           else if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.mpeg4",OMX_MAX_STRINGNAME_SIZE))
2563           {
2564               if(!strncmp((const char*)comp_role->cRole,"video_decoder.mpeg4",OMX_MAX_STRINGNAME_SIZE))
2565               {
2566                   strncpy((char*)m_cRole,"video_decoder.mpeg4",OMX_MAX_STRINGNAME_SIZE);
2567               }
2568               else
2569               {
2570                   DEBUG_PRINT_ERROR("Setparameter: unknown Index %s\n", comp_role->cRole);
2571                   eRet = OMX_ErrorUnsupportedSetting;
2572               }
2573           }
2574           else if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.h263",OMX_MAX_STRINGNAME_SIZE))
2575           {
2576               if(!strncmp((const char*)comp_role->cRole,"video_decoder.h263",OMX_MAX_STRINGNAME_SIZE))
2577               {
2578                   strncpy((char*)m_cRole,"video_decoder.h263",OMX_MAX_STRINGNAME_SIZE);
2579               }
2580               else
2581               {
2582                   DEBUG_PRINT_ERROR("Setparameter: unknown Index %s\n", comp_role->cRole);
2583                   eRet =OMX_ErrorUnsupportedSetting;
2584               }
2585           }
2586           else if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.vc1",OMX_MAX_STRINGNAME_SIZE))
2587           {
2588               if(!strncmp((const char*)comp_role->cRole,"video_decoder.vc1",OMX_MAX_STRINGNAME_SIZE))
2589               {
2590                   strncpy((char*)m_cRole,"video_decoder.vc1",OMX_MAX_STRINGNAME_SIZE);
2591               }
2592               else
2593               {
2594                   DEBUG_PRINT_ERROR("Setparameter: unknown Index %s\n", comp_role->cRole);
2595                   eRet =OMX_ErrorUnsupportedSetting;
2596               }
2597           }
2598           else
2599           {
2600                DEBUG_PRINT_ERROR("Setparameter: unknown param %s\n", driver_context.kind);
2601                eRet = OMX_ErrorInvalidComponentName;
2602           }
2603           break;
2604      }
2605
2606     case OMX_IndexParamPriorityMgmt:
2607         {
2608             if(m_state != OMX_StateLoaded)
2609             {
2610                DEBUG_PRINT_ERROR("Set Parameter called in Invalid State\n");
2611                return OMX_ErrorIncorrectStateOperation;
2612             }
2613             OMX_PRIORITYMGMTTYPE *priorityMgmtype = (OMX_PRIORITYMGMTTYPE*) paramData;
2614             DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt %d\n",
2615               priorityMgmtype->nGroupID);
2616
2617             DEBUG_PRINT_LOW("set_parameter: priorityMgmtype %d\n",
2618              priorityMgmtype->nGroupPriority);
2619
2620             m_priority_mgm.nGroupID = priorityMgmtype->nGroupID;
2621             m_priority_mgm.nGroupPriority = priorityMgmtype->nGroupPriority;
2622
2623             break;
2624         }
2625
2626       case OMX_IndexParamCompBufferSupplier:
2627       {
2628           OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData;
2629             DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier %d\n",
2630                 bufferSupplierType->eBufferSupplier);
2631              if(bufferSupplierType->nPortIndex == 0 || bufferSupplierType->nPortIndex ==1)
2632                 m_buffer_supplier.eBufferSupplier = bufferSupplierType->eBufferSupplier;
2633
2634              else
2635
2636              eRet = OMX_ErrorBadPortIndex;
2637
2638           break;
2639
2640       }
2641       case OMX_IndexParamVideoAvc:
2642           {
2643               DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoAvc %d\n",
2644                     paramIndex);
2645               break;
2646           }
2647       case OMX_IndexParamVideoH263:
2648           {
2649               DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoH263 %d\n",
2650                     paramIndex);
2651               break;
2652           }
2653       case OMX_IndexParamVideoMpeg4:
2654           {
2655               DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoMpeg4 %d\n",
2656                     paramIndex);
2657               break;
2658           }
2659
2660     default:
2661     {
2662       DEBUG_PRINT_ERROR("Setparameter: unknown param %d\n", paramIndex);
2663       eRet = OMX_ErrorUnsupportedIndex;
2664     }
2665   }
2666
2667   return eRet;
2668 }
2669
2670 /* ======================================================================
2671 FUNCTION
2672   omx_vdec::GetConfig
2673
2674 DESCRIPTION
2675   OMX Get Config Method implementation.
2676
2677 PARAMETERS
2678   <TBD>.
2679
2680 RETURN VALUE
2681   OMX Error None if successful.
2682
2683 ========================================================================== */
2684 OMX_ERRORTYPE  omx_vdec::get_config(OMX_IN OMX_HANDLETYPE      hComp,
2685                                         OMX_IN OMX_INDEXTYPE configIndex,
2686                                         OMX_INOUT OMX_PTR     configData)
2687 {
2688   OMX_ERRORTYPE eRet = OMX_ErrorNone;
2689
2690   if (m_state == OMX_StateInvalid)
2691   {
2692      DEBUG_PRINT_ERROR("Get Config in Invalid State\n");
2693      return OMX_ErrorInvalidState;
2694   }
2695
2696   switch (configIndex)
2697   {
2698     case OMX_QcomIndexConfigInterlaced:
2699     {
2700       OMX_QCOM_CONFIG_INTERLACETYPE *configFmt =
2701                                    (OMX_QCOM_CONFIG_INTERLACETYPE *) configData;
2702       if (configFmt->nPortIndex == 1)
2703       {
2704         if (configFmt->nIndex == 0)
2705         {
2706           configFmt->eInterlaceType = OMX_QCOM_InterlaceFrameProgressive;
2707         }
2708         else if (configFmt->nIndex == 1)
2709         {
2710           configFmt->eInterlaceType =
2711                                   OMX_QCOM_InterlaceInterleaveFrameTopFieldFirst;
2712         }
2713         else if (configFmt->nIndex == 2)
2714         {
2715           configFmt->eInterlaceType =
2716           OMX_QCOM_InterlaceInterleaveFrameBottomFieldFirst;
2717         }
2718         else
2719         {
2720           DEBUG_PRINT_ERROR("get_config: OMX_QcomIndexConfigInterlaced:"
2721                             " NoMore Interlaced formats\n");
2722           eRet = OMX_ErrorNoMore;
2723         }
2724
2725       }
2726       else
2727       {
2728         DEBUG_PRINT_ERROR("get_config: Bad port index %d queried on only o/p port\n",
2729         (int)configFmt->nPortIndex);
2730         eRet = OMX_ErrorBadPortIndex;
2731       }
2732     break;
2733     }
2734     case OMX_QcomIndexQueryNumberOfVideoDecInstance:
2735     {
2736         struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
2737         QOMX_VIDEO_QUERY_DECODER_INSTANCES *decoderinstances =
2738           (QOMX_VIDEO_QUERY_DECODER_INSTANCES*)configData;
2739         ioctl_msg.outputparam = (void*)&decoderinstances->nNumOfInstances;
2740         (void)(ioctl(driver_context.video_driver_fd,
2741                VDEC_IOCTL_GET_NUMBER_INSTANCES,&ioctl_msg));
2742     break;
2743     }
2744     default:
2745     {
2746       DEBUG_PRINT_ERROR("get_config: unknown param %d\n",configIndex);
2747       eRet = OMX_ErrorBadParameter;
2748     }
2749
2750   }
2751
2752   return eRet;
2753 }
2754
2755 /* ======================================================================
2756 FUNCTION
2757   omx_vdec::SetConfig
2758
2759 DESCRIPTION
2760   OMX Set Config method implementation
2761
2762 PARAMETERS
2763   <TBD>.
2764
2765 RETURN VALUE
2766   OMX Error None if successful.
2767 ========================================================================== */
2768 OMX_ERRORTYPE  omx_vdec::set_config(OMX_IN OMX_HANDLETYPE      hComp,
2769                                         OMX_IN OMX_INDEXTYPE configIndex,
2770                                         OMX_IN OMX_PTR        configData)
2771 {
2772   if(m_state == OMX_StateInvalid)
2773   {
2774       DEBUG_PRINT_ERROR("Get Config in Invalid State\n");
2775       return OMX_ErrorInvalidState;
2776   }
2777
2778   OMX_ERRORTYPE ret = OMX_ErrorNone;
2779   OMX_VIDEO_CONFIG_NALSIZE *pNal;
2780
2781   DEBUG_PRINT_LOW("\n Set Config Called");
2782
2783   if (m_state == OMX_StateExecuting)
2784   {
2785      DEBUG_PRINT_ERROR("set_config:Ignore in Exe state\n");
2786      return ret;
2787   }
2788
2789   if (configIndex == OMX_IndexVendorVideoExtraData)
2790   {
2791     OMX_VENDOR_EXTRADATATYPE *config = (OMX_VENDOR_EXTRADATATYPE *) configData;
2792     DEBUG_PRINT_LOW("\n Index OMX_IndexVendorVideoExtraData called");
2793     if (!strcmp(driver_context.kind, "OMX.qcom.video.decoder.avc"))
2794     {
2795       DEBUG_PRINT_LOW("\n Index OMX_IndexVendorVideoExtraData AVC");
2796       OMX_U32 extra_size;
2797       // Parsing done here for the AVC atom is definitely not generic
2798       // Currently this piece of code is working, but certainly
2799       // not tested with all .mp4 files.
2800       // Incase of failure, we might need to revisit this
2801       // for a generic piece of code.
2802
2803       // Retrieve size of NAL length field
2804       // byte #4 contains the size of NAL lenght field
2805       nal_length = (config->pData[4] & 0x03) + 1;
2806
2807       extra_size = 0;
2808       if (nal_length > 2)
2809       {
2810         /* Presently we assume that only one SPS and one PPS in AvC1 Atom */
2811         extra_size = (nal_length - 2) * 2;
2812       }
2813
2814       // SPS starts from byte #6
2815       OMX_U8 *pSrcBuf = (OMX_U8 *) (&config->pData[6]);
2816       OMX_U8 *pDestBuf;
2817       m_vendor_config.nPortIndex = config->nPortIndex;
2818
2819       // minus 6 --> SPS starts from byte #6
2820       // minus 1 --> picture param set byte to be ignored from avcatom
2821       m_vendor_config.nDataSize = config->nDataSize - 6 - 1 + extra_size;
2822       m_vendor_config.pData = (OMX_U8 *) malloc(m_vendor_config.nDataSize);
2823       OMX_U32 len;
2824       OMX_U8 index = 0;
2825       // case where SPS+PPS is sent as part of set_config
2826       pDestBuf = m_vendor_config.pData;
2827
2828       DEBUG_PRINT_LOW("Rxd SPS+PPS nPortIndex[%d] len[%d] data[0x%x]\n",
2829            m_vendor_config.nPortIndex,
2830            m_vendor_config.nDataSize,
2831            m_vendor_config.pData);
2832       while (index < 2)
2833       {
2834         uint8 *psize;
2835         len = *pSrcBuf;
2836         len = len << 8;
2837         len |= *(pSrcBuf + 1);
2838         psize = (uint8 *) & len;
2839         memcpy(pDestBuf + nal_length, pSrcBuf + 2,len);
2840         for (int i = 0; i < nal_length; i++)
2841         {
2842           pDestBuf[i] = psize[nal_length - 1 - i];
2843         }
2844         //memcpy(pDestBuf,pSrcBuf,(len+2));
2845         pDestBuf += len + nal_length;
2846         pSrcBuf += len + 2;
2847         index++;
2848         pSrcBuf++;   // skip picture param set
2849         len = 0;
2850       }
2851     }
2852     else if (!strcmp(driver_context.kind, "OMX.qcom.video.decoder.mpeg4"))
2853     {
2854       m_vendor_config.nPortIndex = config->nPortIndex;
2855       m_vendor_config.nDataSize = config->nDataSize;
2856       m_vendor_config.pData = (OMX_U8 *) malloc((config->nDataSize));
2857       memcpy(m_vendor_config.pData, config->pData,config->nDataSize);
2858     }
2859     else if (!strcmp(driver_context.kind, "OMX.qcom.video.decoder.vc1"))
2860     {
2861         if(m_vendor_config.pData)
2862         {
2863             free(m_vendor_config.pData);
2864             m_vendor_config.pData = NULL;
2865             m_vendor_config.nDataSize = 0;
2866         }
2867
2868         if (((*((OMX_U32 *) config->pData)) &
2869              VC1_SP_MP_START_CODE_MASK) ==
2870              VC1_SP_MP_START_CODE)
2871         {
2872             DEBUG_PRINT_LOW("set_config - VC1 simple/main profile\n");
2873             m_vendor_config.nPortIndex = config->nPortIndex;
2874             m_vendor_config.nDataSize = config->nDataSize;
2875             m_vendor_config.pData =
2876                 (OMX_U8 *) malloc(config->nDataSize);
2877             memcpy(m_vendor_config.pData, config->pData,
2878                    config->nDataSize);
2879             m_vc1_profile = VC1_SP_MP_RCV;
2880         }
2881         else if (*((OMX_U32 *) config->pData) == VC1_AP_SEQ_START_CODE)
2882         {
2883             DEBUG_PRINT_LOW("set_config - VC1 Advance profile\n");
2884             m_vendor_config.nPortIndex = config->nPortIndex;
2885             m_vendor_config.nDataSize = config->nDataSize;
2886             m_vendor_config.pData =
2887                 (OMX_U8 *) malloc((config->nDataSize));
2888             memcpy(m_vendor_config.pData, config->pData,
2889                    config->nDataSize);
2890             m_vc1_profile = VC1_AP;
2891         }
2892         else if ((config->nDataSize == VC1_STRUCT_C_LEN))
2893         {
2894             DEBUG_PRINT_LOW("set_config - VC1 Simple/Main profile struct C only\n");
2895             m_vendor_config.nPortIndex = config->nPortIndex;
2896             m_vendor_config.nDataSize  = config->nDataSize;
2897             m_vendor_config.pData = (OMX_U8*)malloc(config->nDataSize);
2898             memcpy(m_vendor_config.pData,config->pData,config->nDataSize);
2899             m_vc1_profile = VC1_SP_MP_RCV;
2900         }
2901         else
2902         {
2903             DEBUG_PRINT_LOW("set_config - Error: Unknown VC1 profile\n");
2904         }
2905     }
2906     return ret;
2907   }
2908   else if (configIndex == OMX_IndexConfigVideoNalSize)
2909   {
2910
2911     pNal = reinterpret_cast < OMX_VIDEO_CONFIG_NALSIZE * >(configData);
2912     nal_length = pNal->nNaluBytes;
2913     m_frame_parser.init_nal_length(nal_length);
2914     DEBUG_PRINT_LOW("\n Nal Length option called with Size %d",nal_length);
2915     return ret;
2916   }
2917
2918   return OMX_ErrorNotImplemented;
2919 }
2920
2921 /* ======================================================================
2922 FUNCTION
2923   omx_vdec::GetExtensionIndex
2924
2925 DESCRIPTION
2926   OMX GetExtensionIndex method implementaion.  <TBD>
2927
2928 PARAMETERS
2929   <TBD>.
2930
2931 RETURN VALUE
2932   OMX Error None if everything successful.
2933
2934 ========================================================================== */
2935 OMX_ERRORTYPE  omx_vdec::get_extension_index(OMX_IN OMX_HANDLETYPE      hComp,
2936                                                 OMX_IN OMX_STRING      paramName,
2937                                                 OMX_OUT OMX_INDEXTYPE* indexType)
2938 {
2939     DEBUG_PRINT_ERROR("get_extension_index: Error, Not implemented\n");
2940     if(m_state == OMX_StateInvalid)
2941     {
2942         DEBUG_PRINT_ERROR("Get Extension Index in Invalid State\n");
2943         return OMX_ErrorInvalidState;
2944     }
2945     return OMX_ErrorNotImplemented;
2946 }
2947
2948 /* ======================================================================
2949 FUNCTION
2950   omx_vdec::GetState
2951
2952 DESCRIPTION
2953   Returns the state information back to the caller.<TBD>
2954
2955 PARAMETERS
2956   <TBD>.
2957
2958 RETURN VALUE
2959   Error None if everything is successful.
2960 ========================================================================== */
2961 OMX_ERRORTYPE  omx_vdec::get_state(OMX_IN OMX_HANDLETYPE  hComp,
2962                                        OMX_OUT OMX_STATETYPE* state)
2963 {
2964   *state = m_state;
2965   DEBUG_PRINT_LOW("get_state: Returning the state %d\n",*state);
2966   return OMX_ErrorNone;
2967 }
2968
2969 /* ======================================================================
2970 FUNCTION
2971   omx_vdec::ComponentTunnelRequest
2972
2973 DESCRIPTION
2974   OMX Component Tunnel Request method implementation. <TBD>
2975
2976 PARAMETERS
2977   None.
2978
2979 RETURN VALUE
2980   OMX Error None if everything successful.
2981
2982 ========================================================================== */
2983 OMX_ERRORTYPE  omx_vdec::component_tunnel_request(OMX_IN OMX_HANDLETYPE                hComp,
2984                                                      OMX_IN OMX_U32                        port,
2985                                                      OMX_IN OMX_HANDLETYPE        peerComponent,
2986                                                      OMX_IN OMX_U32                    peerPort,
2987                                                      OMX_INOUT OMX_TUNNELSETUPTYPE* tunnelSetup)
2988 {
2989   DEBUG_PRINT_ERROR("Error: component_tunnel_request Not Implemented\n");
2990   return OMX_ErrorNotImplemented;
2991 }
2992
2993 /* ======================================================================
2994 FUNCTION
2995   omx_vdec::UseInputBuffer
2996
2997 DESCRIPTION
2998   Helper function for Use buffer in the input pin
2999
3000 PARAMETERS
3001   None.
3002
3003 RETURN VALUE
3004   true/false
3005
3006 ========================================================================== */
3007 OMX_ERRORTYPE  omx_vdec::use_input_buffer(
3008                          OMX_IN OMX_HANDLETYPE            hComp,
3009                          OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
3010                          OMX_IN OMX_U32                   port,
3011                          OMX_IN OMX_PTR                   appData,
3012                          OMX_IN OMX_U32                   bytes,
3013                          OMX_IN OMX_U8*                   buffer)
3014 {
3015   OMX_ERRORTYPE eRet = OMX_ErrorNone;
3016   struct vdec_setbuffer_cmd setbuffers;
3017   OMX_BUFFERHEADERTYPE *input = NULL;
3018   struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
3019   unsigned   i = 0;
3020   unsigned char *buf_addr = NULL;
3021   int pmem_fd = -1;
3022
3023   if(bytes != m_inp_buf_size)
3024   {
3025     return OMX_ErrorBadParameter;
3026   }
3027
3028   if(!m_inp_mem_ptr)
3029   {
3030     DEBUG_PRINT_HIGH("\n Use i/p buffer case - Header List allocation");
3031     input_use_buffer = true;
3032     m_inp_mem_ptr = (OMX_BUFFERHEADERTYPE*) \
3033     calloc( (sizeof(OMX_BUFFERHEADERTYPE)), m_inp_buf_count);
3034
3035     if (m_inp_mem_ptr == NULL)
3036     {
3037       return OMX_ErrorInsufficientResources;
3038     }
3039
3040     driver_context.ptr_inputbuffer = (struct vdec_bufferpayload *) \
3041     calloc ((sizeof (struct vdec_bufferpayload)),m_inp_buf_count);
3042
3043     if (driver_context.ptr_inputbuffer == NULL)
3044     {
3045       return OMX_ErrorInsufficientResources;
3046     }
3047
3048     for (i=0; i < m_inp_buf_count; i++)
3049     {
3050       driver_context.ptr_inputbuffer [i].pmem_fd = -1;
3051     }
3052   }
3053
3054   for(i=0; i< m_inp_buf_count; i++)
3055   {
3056     if(BITMASK_ABSENT(&m_inp_bm_count,i))
3057     {
3058       break;
3059     }
3060   }
3061
3062   if(i < m_inp_buf_count)
3063   {
3064     pmem_fd = open ("/dev/pmem_adsp",O_RDWR | O_SYNC);
3065
3066     if (pmem_fd < 0)
3067     {
3068       return OMX_ErrorInsufficientResources;
3069     }
3070
3071     if(pmem_fd == 0)
3072     {
3073       pmem_fd = open ("/dev/pmem_adsp",O_RDWR | O_SYNC);
3074       if (pmem_fd < 0)
3075       {
3076         return OMX_ErrorInsufficientResources;
3077       }
3078     }
3079
3080     if(!align_pmem_buffers(pmem_fd, m_inp_buf_size,
3081       driver_context.input_buffer.alignment))
3082     {
3083       DEBUG_PRINT_ERROR("\n align_pmem_buffers() failed");
3084       close(pmem_fd);
3085       return OMX_ErrorInsufficientResources;
3086     }
3087
3088     buf_addr = (unsigned char *)mmap(NULL,m_inp_buf_size,PROT_READ|PROT_WRITE,
3089                     MAP_SHARED,pmem_fd,0);
3090
3091     if (buf_addr == MAP_FAILED)
3092     {
3093       return OMX_ErrorInsufficientResources;
3094     }
3095
3096     driver_context.ptr_inputbuffer [i].bufferaddr = buf_addr;
3097     driver_context.ptr_inputbuffer [i].pmem_fd = pmem_fd;
3098     driver_context.ptr_inputbuffer [i].mmaped_size = m_inp_buf_size;
3099     driver_context.ptr_inputbuffer [i].offset = 0;
3100
3101     setbuffers.buffer_type = VDEC_BUFFER_TYPE_INPUT;
3102     memcpy (&setbuffers.buffer,&driver_context.ptr_inputbuffer [i],
3103             sizeof (vdec_bufferpayload));
3104     ioctl_msg.inputparam  = &setbuffers;
3105     ioctl_msg.outputparam = NULL;
3106
3107     if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_BUFFER,
3108          &ioctl_msg) < 0)
3109     {
3110       return OMX_ErrorInsufficientResources;
3111     }
3112
3113     *bufferHdr = (m_inp_mem_ptr + i);
3114     input = *bufferHdr;
3115     BITMASK_SET(&m_inp_bm_count,i);
3116
3117     input->pBuffer           = (OMX_U8 *)buffer;
3118     input->nSize             = sizeof(OMX_BUFFERHEADERTYPE);
3119     input->nVersion.nVersion = OMX_SPEC_VERSION;
3120     input->nAllocLen         = m_inp_buf_size;
3121     input->pAppPrivate       = appData;
3122     input->nInputPortIndex   = OMX_CORE_INPUT_PORT_INDEX;
3123     input->pInputPortPrivate = (void *)&driver_context.ptr_inputbuffer [i];
3124   }
3125   else
3126   {
3127     eRet = OMX_ErrorInsufficientResources;
3128   }
3129   return eRet;
3130 }
3131
3132
3133 /* ======================================================================
3134 FUNCTION
3135   omx_vdec::UseOutputBuffer
3136
3137 DESCRIPTION
3138   Helper function for Use buffer in the input pin
3139
3140 PARAMETERS
3141   None.
3142
3143 RETURN VALUE
3144   true/false
3145
3146 ========================================================================== */
3147 OMX_ERRORTYPE  omx_vdec::use_output_buffer(
3148                          OMX_IN OMX_HANDLETYPE            hComp,
3149                          OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
3150                          OMX_IN OMX_U32                   port,
3151                          OMX_IN OMX_PTR                   appData,
3152                          OMX_IN OMX_U32                   bytes,
3153                          OMX_IN OMX_U8*                   buffer)
3154 {
3155   OMX_ERRORTYPE eRet = OMX_ErrorNone;
3156   OMX_BUFFERHEADERTYPE       *bufHdr= NULL; // buffer header
3157   unsigned                         i= 0; // Temporary counter
3158
3159   if(!m_out_mem_ptr)
3160   {
3161     DEBUG_PRINT_HIGH("\n Use o/p buffer case - Header List allocation");
3162     output_use_buffer = true;
3163     int nBufHdrSize        = 0;
3164     int nPlatformEntrySize = 0;
3165     int nPlatformListSize  = 0;
3166     int nPMEMInfoSize = 0;
3167     OMX_QCOM_PLATFORM_PRIVATE_LIST      *pPlatformList;
3168     OMX_QCOM_PLATFORM_PRIVATE_ENTRY     *pPlatformEntry;
3169     OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO *pPMEMInfo;
3170
3171     DEBUG_PRINT_LOW("Allocating First Output Buffer(%d)\n",m_out_buf_count);
3172     nBufHdrSize        = m_out_buf_count * sizeof(OMX_BUFFERHEADERTYPE);
3173
3174     nPMEMInfoSize      = m_out_buf_count *
3175                          sizeof(OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO);
3176     nPlatformListSize  = m_out_buf_count *
3177                          sizeof(OMX_QCOM_PLATFORM_PRIVATE_LIST);
3178     nPlatformEntrySize = m_out_buf_count *
3179                          sizeof(OMX_QCOM_PLATFORM_PRIVATE_ENTRY);
3180
3181     DEBUG_PRINT_LOW("TotalBufHdr %d BufHdrSize %d PMEM %d PL %d\n",nBufHdrSize,
3182                          sizeof(OMX_BUFFERHEADERTYPE),
3183                          nPMEMInfoSize,
3184                          nPlatformListSize);
3185     DEBUG_PRINT_LOW("PE %d bmSize %d \n",nPlatformEntrySize,
3186                          m_out_bm_count);
3187
3188     /*
3189      * Memory for output side involves the following:
3190      * 1. Array of Buffer Headers
3191      * 2. Platform specific information List
3192      * 3. Platform specific Entry List
3193      * 4. PMem Information entries
3194      * 5. Bitmask array to hold the buffer allocation details
3195      * In order to minimize the memory management entire allocation
3196      * is done in one step.
3197      */
3198     m_out_mem_ptr = (OMX_BUFFERHEADERTYPE  *)calloc(nBufHdrSize,1);
3199     // Alloc mem for platform specific info
3200     char *pPtr=NULL;
3201     pPtr = (char*) calloc(nPlatformListSize + nPlatformEntrySize +
3202                                      nPMEMInfoSize,1);
3203     driver_context.ptr_outputbuffer = (struct vdec_bufferpayload *) \
3204       calloc (sizeof(struct vdec_bufferpayload),m_out_buf_count);
3205     driver_context.ptr_respbuffer = (struct vdec_output_frameinfo  *)\
3206       calloc (sizeof (struct vdec_output_frameinfo),m_out_buf_count);
3207
3208     if(m_out_mem_ptr && pPtr && driver_context.ptr_outputbuffer
3209        && driver_context.ptr_respbuffer)
3210     {
3211       bufHdr          =  m_out_mem_ptr;
3212       m_platform_list = (OMX_QCOM_PLATFORM_PRIVATE_LIST *)(pPtr);
3213       m_platform_entry= (OMX_QCOM_PLATFORM_PRIVATE_ENTRY *)
3214                         (((char *) m_platform_list)  + nPlatformListSize);
3215       m_pmem_info     = (OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO *)
3216                         (((char *) m_platform_entry) + nPlatformEntrySize);
3217       pPlatformList   = m_platform_list;
3218       pPlatformEntry  = m_platform_entry;
3219       pPMEMInfo       = m_pmem_info;
3220
3221       DEBUG_PRINT_LOW("Memory Allocation Succeeded for OUT port%p\n",m_out_mem_ptr);
3222
3223       // Settting the entire storage nicely
3224       DEBUG_PRINT_LOW("bHdr %p OutMem %p PE %p\n",bufHdr, m_out_mem_ptr,pPlatformEntry);
3225       DEBUG_PRINT_LOW(" Pmem Info = %p \n",pPMEMInfo);
3226       for(i=0; i < m_out_buf_count ; i++)
3227       {
3228         bufHdr->nSize              = sizeof(OMX_BUFFERHEADERTYPE);
3229         bufHdr->nVersion.nVersion  = OMX_SPEC_VERSION;
3230         // Set the values when we determine the right HxW param
3231         bufHdr->nAllocLen          = bytes;
3232         bufHdr->nFilledLen         = 0;
3233         bufHdr->pAppPrivate        = appData;
3234         bufHdr->nOutputPortIndex   = OMX_CORE_OUTPUT_PORT_INDEX;
3235         // Platform specific PMEM Information
3236         // Initialize the Platform Entry
3237         //DEBUG_PRINT_LOW("Initializing the Platform Entry for %d\n",i);
3238         pPlatformEntry->type       = OMX_QCOM_PLATFORM_PRIVATE_PMEM;
3239         pPlatformEntry->entry      = pPMEMInfo;
3240         // Initialize the Platform List
3241         pPlatformList->nEntries    = 1;
3242         pPlatformList->entryList   = pPlatformEntry;
3243         // Keep pBuffer NULL till vdec is opened
3244         bufHdr->pBuffer            = NULL;
3245
3246         pPMEMInfo->offset          =  0;
3247         pPMEMInfo->pmem_fd = 0;
3248         bufHdr->pPlatformPrivate = pPlatformList;
3249
3250         driver_context.ptr_outputbuffer[i].pmem_fd = -1;
3251
3252         /*Create a mapping between buffers*/
3253         bufHdr->pOutputPortPrivate = &driver_context.ptr_respbuffer[i];
3254         driver_context.ptr_respbuffer[i].client_data = (void *) \
3255                                             &driver_context.ptr_outputbuffer[i];
3256         // Move the buffer and buffer header pointers
3257         bufHdr++;
3258         pPMEMInfo++;
3259         pPlatformEntry++;
3260         pPlatformList++;
3261       }
3262     }
3263     else
3264     {
3265       DEBUG_PRINT_ERROR("Output buf mem alloc failed[0x%x][0x%x]\n",\
3266                                         m_out_mem_ptr, pPtr);
3267       if(m_out_mem_ptr)
3268       {
3269         free(m_out_mem_ptr);
3270         m_out_mem_ptr = NULL;
3271       }
3272       if(pPtr)
3273       {
3274         free(pPtr);
3275         pPtr = NULL;
3276       }
3277       if(driver_context.ptr_outputbuffer)
3278       {
3279         free(driver_context.ptr_outputbuffer);
3280         driver_context.ptr_outputbuffer = NULL;
3281       }
3282       if(driver_context.ptr_respbuffer)
3283       {
3284         free(driver_context.ptr_respbuffer);
3285         driver_context.ptr_respbuffer = NULL;
3286       }
3287       eRet =  OMX_ErrorInsufficientResources;
3288     }
3289   }
3290
3291   for(i=0; i< m_out_buf_count; i++)
3292   {
3293     if(BITMASK_ABSENT(&m_out_bm_count,i))
3294     {
3295       break;
3296     }
3297   }
3298
3299   if (eRet == OMX_ErrorNone)
3300   {
3301     if(i < m_out_buf_count)
3302     {
3303       driver_context.ptr_outputbuffer[i].pmem_fd = \
3304         open ("/dev/pmem_adsp", O_RDWR | O_SYNC);
3305
3306       if (driver_context.ptr_outputbuffer[i].pmem_fd < 0)
3307       {
3308         return OMX_ErrorInsufficientResources;
3309       }
3310
3311       if(driver_context.ptr_outputbuffer[i].pmem_fd == 0)
3312       {
3313         driver_context.ptr_outputbuffer[i].pmem_fd = \
3314           open ("/dev/pmem_adsp", O_RDWR | O_SYNC);
3315
3316         if (driver_context.ptr_outputbuffer[i].pmem_fd < 0)
3317         {
3318           return OMX_ErrorInsufficientResources;
3319         }
3320       }
3321
3322       if(!align_pmem_buffers(driver_context.ptr_outputbuffer[i].pmem_fd,
3323         m_out_buf_size, driver_context.output_buffer.alignment))
3324       {
3325         DEBUG_PRINT_ERROR("\n align_pmem_buffers() failed");
3326         close(driver_context.ptr_outputbuffer[i].pmem_fd);
3327         return OMX_ErrorInsufficientResources;
3328       }
3329
3330       driver_context.ptr_outputbuffer[i].bufferaddr =
3331         (unsigned char *)mmap(NULL,m_out_buf_size,PROT_READ|PROT_WRITE,
3332          MAP_SHARED,driver_context.ptr_outputbuffer[i].pmem_fd,0);
3333
3334       if (driver_context.ptr_outputbuffer[i].bufferaddr == MAP_FAILED)
3335       {
3336         return OMX_ErrorInsufficientResources;
3337       }
3338       driver_context.ptr_outputbuffer[i].offset = 0;
3339       m_pmem_info[i].offset = driver_context.ptr_outputbuffer[i].offset;
3340       m_pmem_info[i].pmem_fd = driver_context.ptr_outputbuffer[i].pmem_fd;
3341
3342       // found an empty buffer at i
3343       *bufferHdr = (m_out_mem_ptr + i );
3344       (*bufferHdr)->pBuffer = buffer;
3345       (*bufferHdr)->pAppPrivate = appData;
3346       BITMASK_SET(&m_out_bm_count,i);
3347     }
3348     else
3349     {
3350       DEBUG_PRINT_ERROR("All the Output Buffers have been Allocated ; Returning Insufficient \n");
3351       eRet = OMX_ErrorInsufficientResources;
3352     }
3353   }
3354
3355   return eRet;
3356 }
3357
3358 /* ======================================================================
3359 FUNCTION
3360   omx_vdec::UseBuffer
3361
3362 DESCRIPTION
3363   OMX Use Buffer method implementation.
3364
3365 PARAMETERS
3366   <TBD>.
3367
3368 RETURN VALUE
3369   OMX Error None , if everything successful.
3370
3371 ========================================================================== */
3372 OMX_ERRORTYPE  omx_vdec::use_buffer(
3373                          OMX_IN OMX_HANDLETYPE            hComp,
3374                          OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
3375                          OMX_IN OMX_U32                   port,
3376                          OMX_IN OMX_PTR                   appData,
3377                          OMX_IN OMX_U32                   bytes,
3378                          OMX_IN OMX_U8*                   buffer)
3379 {
3380     OMX_ERRORTYPE eRet = OMX_ErrorNone;
3381     if(m_state == OMX_StateInvalid)
3382     {
3383         DEBUG_PRINT_ERROR("Use Buffer in Invalid State\n");
3384         return OMX_ErrorInvalidState;
3385     }
3386     if(port == OMX_CORE_INPUT_PORT_INDEX)
3387     {
3388       eRet = use_input_buffer(hComp,bufferHdr,port,appData,bytes,buffer);
3389     }
3390     else if(port == OMX_CORE_OUTPUT_PORT_INDEX)
3391     {
3392       eRet = use_output_buffer(hComp,bufferHdr,port,appData,bytes,buffer);
3393     }
3394     else
3395     {
3396       DEBUG_PRINT_ERROR("Error: Invalid Port Index received %d\n",(int)port);
3397       eRet = OMX_ErrorBadPortIndex;
3398     }
3399     DEBUG_PRINT_LOW("Use Buffer: port %u, buffer %p, eRet %d", port, *bufferHdr, eRet);
3400
3401     if(eRet == OMX_ErrorNone)
3402     {
3403       if(allocate_done())
3404       {
3405         if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
3406         {
3407           // Send the callback now
3408           BITMASK_CLEAR((&m_flags),OMX_COMPONENT_IDLE_PENDING);
3409           post_event(OMX_CommandStateSet,OMX_StateIdle,
3410                              OMX_COMPONENT_GENERATE_EVENT);
3411         }
3412       }
3413       if(port == OMX_CORE_INPUT_PORT_INDEX && m_inp_bPopulated)
3414       {
3415         if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
3416         {
3417           BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_ENABLE_PENDING);
3418           post_event(OMX_CommandPortEnable,
3419               OMX_CORE_INPUT_PORT_INDEX,
3420               OMX_COMPONENT_GENERATE_EVENT);
3421         }
3422
3423       }
3424       else if(port == OMX_CORE_OUTPUT_PORT_INDEX && m_out_bPopulated)
3425       {
3426         if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
3427         {
3428           BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
3429           post_event(OMX_CommandPortEnable,
3430                      OMX_CORE_OUTPUT_PORT_INDEX,
3431                      OMX_COMPONENT_GENERATE_EVENT);
3432           m_event_port_settings_sent = false;
3433         }
3434       }
3435     }
3436     return eRet;
3437 }
3438
3439 OMX_ERRORTYPE omx_vdec::free_input_buffer(OMX_BUFFERHEADERTYPE *bufferHdr)
3440 {
3441   unsigned int index = 0;
3442
3443   if (bufferHdr == NULL || m_inp_mem_ptr == NULL)
3444   {
3445     return OMX_ErrorBadParameter;
3446   }
3447
3448   index = bufferHdr - m_inp_mem_ptr;
3449   DEBUG_PRINT_LOW("\n Free Input Buffer index = %d",index);
3450
3451   if (index < m_inp_buf_count && driver_context.ptr_inputbuffer)
3452   {
3453     DEBUG_PRINT_LOW("\n Free Input Buffer index = %d",index);
3454     if (driver_context.ptr_inputbuffer[index].pmem_fd > 0)
3455     {
3456        struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
3457        struct vdec_setbuffer_cmd setbuffers;
3458        setbuffers.buffer_type = VDEC_BUFFER_TYPE_INPUT;
3459        memcpy (&setbuffers.buffer,&driver_context.ptr_inputbuffer[index],
3460           sizeof (vdec_bufferpayload));
3461        ioctl_msg.inputparam  = &setbuffers;
3462        ioctl_msg.outputparam = NULL;
3463        int ioctl_r = ioctl (driver_context.video_driver_fd,
3464                             VDEC_IOCTL_FREE_BUFFER, &ioctl_msg);
3465        if (ioctl_r < 0)
3466        {
3467           DEBUG_PRINT_ERROR("\nVDEC_IOCTL_FREE_BUFFER returned error %d", ioctl_r);
3468        }
3469
3470        DEBUG_PRINT_LOW("\n unmap the input buffer fd=%d",
3471                     driver_context.ptr_inputbuffer[index].pmem_fd);
3472        DEBUG_PRINT_LOW("\n unmap the input buffer size=%d  address = %d",
3473                     driver_context.ptr_inputbuffer[index].mmaped_size,
3474                     driver_context.ptr_inputbuffer[index].bufferaddr);
3475        munmap (driver_context.ptr_inputbuffer[index].bufferaddr,
3476                driver_context.ptr_inputbuffer[index].mmaped_size);
3477        close (driver_context.ptr_inputbuffer[index].pmem_fd);
3478        driver_context.ptr_inputbuffer[index].pmem_fd = -1;
3479     }
3480   }
3481
3482   return OMX_ErrorNone;
3483 }
3484
3485 OMX_ERRORTYPE omx_vdec::free_output_buffer(OMX_BUFFERHEADERTYPE *bufferHdr)
3486 {
3487   unsigned int index = 0;
3488
3489   if (bufferHdr == NULL || m_out_mem_ptr == NULL)
3490   {
3491     return OMX_ErrorBadParameter;
3492   }
3493
3494   index = bufferHdr - m_out_mem_ptr;
3495   DEBUG_PRINT_LOW("\n Free ouput Buffer index = %d",index);
3496
3497   if (index < m_out_buf_count && driver_context.ptr_outputbuffer)
3498   {
3499     DEBUG_PRINT_LOW("\n Free ouput Buffer index = %d addr = %x", index,
3500                     driver_context.ptr_outputbuffer[index].bufferaddr);
3501
3502     if (!gate_output_buffers)
3503     {
3504       struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
3505       struct vdec_setbuffer_cmd setbuffers;
3506       setbuffers.buffer_type = VDEC_BUFFER_TYPE_OUTPUT;
3507       memcpy (&setbuffers.buffer,&driver_context.ptr_outputbuffer[index],
3508         sizeof (vdec_bufferpayload));
3509       ioctl_msg.inputparam  = &setbuffers;
3510       ioctl_msg.outputparam = NULL;
3511       DEBUG_PRINT_LOW("\nRelease the Output Buffer");
3512       if (ioctl (driver_context.video_driver_fd, VDEC_IOCTL_FREE_BUFFER,
3513             &ioctl_msg) < 0)
3514         DEBUG_PRINT_ERROR("\nRelease output buffer failed in VCD");
3515     }
3516
3517     if (driver_context.ptr_outputbuffer[0].pmem_fd > 0)
3518     {
3519        DEBUG_PRINT_LOW("\n unmap the output buffer fd = %d",
3520                     driver_context.ptr_outputbuffer[0].pmem_fd);
3521        DEBUG_PRINT_LOW("\n unmap the ouput buffer size=%d  address = %d",
3522                     driver_context.ptr_outputbuffer[0].mmaped_size,
3523                     driver_context.ptr_outputbuffer[0].bufferaddr);
3524        munmap (driver_context.ptr_outputbuffer[0].bufferaddr,
3525                driver_context.ptr_outputbuffer[0].mmaped_size);
3526        close (driver_context.ptr_outputbuffer[0].pmem_fd);
3527        driver_context.ptr_outputbuffer[0].pmem_fd = -1;
3528     }
3529   }
3530
3531   return OMX_ErrorNone;
3532
3533 }
3534
3535 OMX_ERRORTYPE omx_vdec::allocate_input_heap_buffer(OMX_HANDLETYPE       hComp,
3536                                          OMX_BUFFERHEADERTYPE **bufferHdr,
3537                                          OMX_U32              port,
3538                                          OMX_PTR              appData,
3539                                          OMX_U32              bytes)
3540 {
3541   OMX_BUFFERHEADERTYPE *input = NULL;
3542   unsigned char *buf_addr = NULL;
3543   OMX_ERRORTYPE eRet = OMX_ErrorNone;
3544   unsigned   i = 0;
3545
3546   /* Sanity Check*/
3547   if (bufferHdr == NULL)
3548   {
3549     return OMX_ErrorBadParameter;
3550   }
3551
3552   if (m_inp_heap_ptr == NULL)
3553   {
3554     m_inp_heap_ptr = (OMX_BUFFERHEADERTYPE*) \
3555                      calloc( (sizeof(OMX_BUFFERHEADERTYPE)), m_inp_buf_count);
3556     m_phdr_pmem_ptr = (OMX_BUFFERHEADERTYPE**) \
3557                      calloc( (sizeof(OMX_BUFFERHEADERTYPE*)), m_inp_buf_count);
3558
3559     if (m_inp_heap_ptr == NULL)
3560     {
3561       DEBUG_PRINT_ERROR("\n m_inp_heap_ptr Allocation failed ");
3562       return OMX_ErrorInsufficientResources;
3563     }
3564
3565     h264_scratch.nAllocLen = m_inp_buf_size;
3566     h264_scratch.pBuffer = (OMX_U8 *)malloc (m_inp_buf_size);
3567     h264_scratch.nFilledLen = 0;
3568     h264_scratch.nOffset = 0;
3569
3570     if (h264_scratch.pBuffer == NULL)
3571     {
3572       DEBUG_PRINT_ERROR("\n h264_scratch.pBuffer Allocation failed ");
3573       return OMX_ErrorInsufficientResources;
3574     }
3575
3576     if (m_frame_parser.mutils == NULL)
3577     {
3578        m_frame_parser.mutils = new H264_Utils();
3579
3580        if (m_frame_parser.mutils == NULL)
3581        {
3582          DEBUG_PRINT_ERROR("\n parser utils Allocation failed ");
3583          return OMX_ErrorInsufficientResources;
3584        }
3585
3586        m_frame_parser.mutils->initialize_frame_checking_environment();
3587        m_frame_parser.mutils->allocate_rbsp_buffer (m_inp_buf_size);
3588     }
3589   }
3590
3591   /*Find a Free index*/
3592   for(i=0; i< m_inp_buf_count; i++)
3593   {
3594     if(BITMASK_ABSENT(&m_heap_inp_bm_count,i))
3595     {
3596       DEBUG_PRINT_LOW("\n Free Input Buffer Index %d",i);
3597       break;
3598     }
3599   }
3600
3601   if (i < m_inp_buf_count)
3602   {
3603     buf_addr = (unsigned char *)malloc (m_inp_buf_size);
3604
3605     if (buf_addr == NULL)
3606     {
3607       return OMX_ErrorInsufficientResources;
3608     }
3609
3610     *bufferHdr = (m_inp_heap_ptr + i);
3611     input = *bufferHdr;
3612     BITMASK_SET(&m_heap_inp_bm_count,i);
3613
3614     input->pBuffer           = (OMX_U8 *)buf_addr;
3615     input->nSize             = sizeof(OMX_BUFFERHEADERTYPE);
3616     input->nVersion.nVersion = OMX_SPEC_VERSION;
3617     input->nAllocLen         = m_inp_buf_size;
3618     input->pAppPrivate       = appData;
3619     input->nInputPortIndex   = OMX_CORE_INPUT_PORT_INDEX;
3620     DEBUG_PRINT_LOW("\n Address of Heap Buffer %p",*bufferHdr );
3621     eRet = allocate_input_buffer(hComp,&m_phdr_pmem_ptr [i],port,appData,bytes);
3622     DEBUG_PRINT_LOW("\n Address of Pmem Buffer %p",m_phdr_pmem_ptr [i] );
3623     /*Add the Buffers to freeq*/
3624     if (!m_input_free_q.insert_entry((unsigned)m_phdr_pmem_ptr [i],NULL,NULL))
3625     {
3626       DEBUG_PRINT_ERROR("\nERROR:Free_q is full");
3627       return OMX_ErrorInsufficientResources;
3628     }
3629   }
3630   else
3631   {
3632     return OMX_ErrorBadParameter;
3633   }
3634
3635   return eRet;
3636
3637 }
3638
3639
3640 /* ======================================================================
3641 FUNCTION
3642   omx_vdec::AllocateInputBuffer
3643
3644 DESCRIPTION
3645   Helper function for allocate buffer in the input pin
3646
3647 PARAMETERS
3648   None.
3649
3650 RETURN VALUE
3651   true/false
3652
3653 ========================================================================== */
3654 OMX_ERRORTYPE  omx_vdec::allocate_input_buffer(
3655                          OMX_IN OMX_HANDLETYPE            hComp,
3656                          OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
3657                          OMX_IN OMX_U32                   port,
3658                          OMX_IN OMX_PTR                   appData,
3659                          OMX_IN OMX_U32                   bytes)
3660 {
3661
3662   OMX_ERRORTYPE eRet = OMX_ErrorNone;
3663   struct vdec_setbuffer_cmd setbuffers;
3664   OMX_BUFFERHEADERTYPE *input = NULL;
3665   struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
3666   unsigned   i = 0;
3667   unsigned char *buf_addr = NULL;
3668   int pmem_fd = -1;
3669
3670   if(bytes != m_inp_buf_size)
3671   {
3672     DEBUG_PRINT_LOW("\n Requested Size is wrong %d epected is %d",bytes,m_inp_buf_size);
3673     //return OMX_ErrorBadParameter;
3674   }
3675
3676   if(!m_inp_mem_ptr)
3677   {
3678     DEBUG_PRINT_HIGH("\n Allocate i/p buffer case - Header List allocation");
3679     DEBUG_PRINT_LOW("\n Allocating input buffer count %d ",m_inp_buf_count);
3680     DEBUG_PRINT_LOW("\n Size of input buffer is %d",m_inp_buf_size);
3681
3682     m_inp_mem_ptr = (OMX_BUFFERHEADERTYPE*) \
3683     calloc( (sizeof(OMX_BUFFERHEADERTYPE)), m_inp_buf_count);
3684
3685     if (m_inp_mem_ptr == NULL)
3686     {
3687       return OMX_ErrorInsufficientResources;
3688     }
3689
3690     driver_context.ptr_inputbuffer = (struct vdec_bufferpayload *) \
3691     calloc ((sizeof (struct vdec_bufferpayload)),m_inp_buf_count);
3692
3693     if (driver_context.ptr_inputbuffer == NULL)
3694     {
3695       return OMX_ErrorInsufficientResources;
3696     }
3697
3698     for (i=0; i < m_inp_buf_count; i++)
3699     {
3700       driver_context.ptr_inputbuffer [i].pmem_fd = -1;
3701     }
3702   }
3703
3704   for(i=0; i< m_inp_buf_count; i++)
3705   {
3706     if(BITMASK_ABSENT(&m_inp_bm_count,i))
3707     {
3708       DEBUG_PRINT_LOW("\n Free Input Buffer Index %d",i);
3709       break;
3710     }
3711   }
3712
3713   if(i < m_inp_buf_count)
3714   {
3715     DEBUG_PRINT_LOW("\n Allocate input Buffer");
3716     pmem_fd = open ("/dev/pmem_adsp", O_RDWR, O_SYNC);
3717
3718     if (pmem_fd < 0)
3719     {
3720       DEBUG_PRINT_ERROR("\n open failed for pmem/adsp for input buffer");
3721       return OMX_ErrorInsufficientResources;
3722     }
3723
3724     if (pmem_fd == 0)
3725     {
3726       pmem_fd = open ("/dev/pmem_adsp", O_RDWR | O_SYNC);
3727
3728       if (pmem_fd < 0)
3729       {
3730         DEBUG_PRINT_ERROR("\n open failed for pmem/adsp for input buffer");
3731         return OMX_ErrorInsufficientResources;
3732       }
3733     }
3734
3735     if(!align_pmem_buffers(pmem_fd, m_inp_buf_size,
3736       driver_context.input_buffer.alignment))
3737     {
3738       DEBUG_PRINT_ERROR("\n align_pmem_buffers() failed");
3739       close(pmem_fd);
3740       return OMX_ErrorInsufficientResources;
3741     }
3742
3743     buf_addr = (unsigned char *)mmap(NULL,m_inp_buf_size,PROT_READ|PROT_WRITE,
3744                     MAP_SHARED,pmem_fd,0);
3745
3746     if (buf_addr == MAP_FAILED)
3747     {
3748       DEBUG_PRINT_ERROR("\n Map Failed to allocate input buffer");
3749       return OMX_ErrorInsufficientResources;
3750     }
3751
3752     driver_context.ptr_inputbuffer [i].bufferaddr = buf_addr;
3753     driver_context.ptr_inputbuffer [i].pmem_fd = pmem_fd;
3754     driver_context.ptr_inputbuffer [i].buffer_len = m_inp_buf_size;
3755     driver_context.ptr_inputbuffer [i].mmaped_size = m_inp_buf_size;
3756     driver_context.ptr_inputbuffer [i].offset = 0;
3757
3758     setbuffers.buffer_type = VDEC_BUFFER_TYPE_INPUT;
3759     memcpy (&setbuffers.buffer,&driver_context.ptr_inputbuffer [i],
3760             sizeof (vdec_bufferpayload));
3761     ioctl_msg.inputparam  = &setbuffers;
3762     ioctl_msg.outputparam = NULL;
3763
3764     if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_BUFFER,
3765          &ioctl_msg) < 0)
3766     {
3767       DEBUG_PRINT_ERROR("\n Set Buffers Failed");
3768       return OMX_ErrorInsufficientResources;
3769     }
3770
3771     *bufferHdr = (m_inp_mem_ptr + i);
3772     input = *bufferHdr;
3773     BITMASK_SET(&m_inp_bm_count,i);
3774     DEBUG_PRINT_LOW("\n Buffer address %p of pmem",*bufferHdr);
3775
3776     input->pBuffer           = (OMX_U8 *)buf_addr;
3777     input->nSize             = sizeof(OMX_BUFFERHEADERTYPE);
3778     input->nVersion.nVersion = OMX_SPEC_VERSION;
3779     input->nAllocLen         = m_inp_buf_size;
3780     input->pAppPrivate       = appData;
3781     input->nInputPortIndex   = OMX_CORE_INPUT_PORT_INDEX;
3782     input->pInputPortPrivate = (void *)&driver_context.ptr_inputbuffer [i];
3783   }
3784   else
3785   {
3786     DEBUG_PRINT_ERROR("\nERROR:Input Buffer Index not found");
3787     eRet = OMX_ErrorInsufficientResources;
3788   }
3789   return eRet;
3790 }
3791
3792
3793 /* ======================================================================
3794 FUNCTION
3795   omx_vdec::AllocateOutputBuffer
3796
3797 DESCRIPTION
3798   Helper fn for AllocateBuffer in the output pin
3799
3800 PARAMETERS
3801   <TBD>.
3802
3803 RETURN VALUE
3804   OMX Error None if everything went well.
3805
3806 ========================================================================== */
3807 OMX_ERRORTYPE  omx_vdec::allocate_output_buffer(
3808                          OMX_IN OMX_HANDLETYPE            hComp,
3809                          OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
3810                          OMX_IN OMX_U32                   port,
3811                          OMX_IN OMX_PTR                   appData,
3812                          OMX_IN OMX_U32                   bytes)
3813 {
3814   OMX_ERRORTYPE eRet = OMX_ErrorNone;
3815   OMX_BUFFERHEADERTYPE       *bufHdr= NULL; // buffer header
3816   unsigned                         i= 0; // Temporary counter
3817   struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
3818   struct vdec_setbuffer_cmd setbuffers;
3819
3820   if(!m_out_mem_ptr)
3821   {
3822     DEBUG_PRINT_HIGH("\n Allocate o/p buffer case - Header List allocation");
3823     int nBufHdrSize        = 0;
3824     int nPlatformEntrySize = 0;
3825     int nPlatformListSize  = 0;
3826     int nPMEMInfoSize = 0;
3827     int pmem_fd = -1;
3828     unsigned char *pmem_baseaddress = NULL;
3829
3830     OMX_QCOM_PLATFORM_PRIVATE_LIST      *pPlatformList;
3831     OMX_QCOM_PLATFORM_PRIVATE_ENTRY     *pPlatformEntry;
3832     OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO *pPMEMInfo;
3833
3834     DEBUG_PRINT_LOW("Allocating First Output Buffer(%d)\n",m_out_buf_count);
3835     nBufHdrSize        = m_out_buf_count * sizeof(OMX_BUFFERHEADERTYPE);
3836
3837     nPMEMInfoSize      = m_out_buf_count *
3838                          sizeof(OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO);
3839     nPlatformListSize  = m_out_buf_count *
3840                          sizeof(OMX_QCOM_PLATFORM_PRIVATE_LIST);
3841     nPlatformEntrySize = m_out_buf_count *
3842                          sizeof(OMX_QCOM_PLATFORM_PRIVATE_ENTRY);
3843
3844     DEBUG_PRINT_LOW("TotalBufHdr %d BufHdrSize %d PMEM %d PL %d\n",nBufHdrSize,
3845                          sizeof(OMX_BUFFERHEADERTYPE),
3846                          nPMEMInfoSize,
3847                          nPlatformListSize);
3848     DEBUG_PRINT_LOW("PE %d OutputBuffer Count %d \n",nPlatformEntrySize,
3849                          m_out_buf_count);
3850
3851     pmem_fd = open ("/dev/pmem_adsp", O_RDWR | O_SYNC);
3852
3853     if (pmem_fd < 0)
3854     {
3855       DEBUG_PRINT_ERROR("\nERROR:pmem fd for output buffer %d",m_out_buf_size);
3856       return OMX_ErrorInsufficientResources;
3857     }
3858
3859     if(pmem_fd == 0)
3860     {
3861       pmem_fd = open ("/dev/pmem_adsp", O_RDWR | O_SYNC);
3862
3863       if (pmem_fd < 0)
3864       {
3865         DEBUG_PRINT_ERROR("\nERROR:pmem fd for output buffer %d",m_out_buf_size);
3866         return OMX_ErrorInsufficientResources;
3867       }
3868     }
3869
3870     if(!align_pmem_buffers(pmem_fd, m_out_buf_size * m_out_buf_count,
3871       driver_context.output_buffer.alignment))
3872     {
3873       DEBUG_PRINT_ERROR("\n align_pmem_buffers() failed");
3874       close(pmem_fd);
3875       return OMX_ErrorInsufficientResources;
3876     }
3877
3878     pmem_baseaddress = (unsigned char *)mmap(NULL,(m_out_buf_size * m_out_buf_count),
3879                        PROT_READ|PROT_WRITE,MAP_SHARED,pmem_fd,0);
3880     m_heap_ptr = new VideoHeap (pmem_fd,
3881                                    m_out_buf_size*m_out_buf_count,
3882                                    pmem_baseaddress);
3883
3884
3885     if (pmem_baseaddress == MAP_FAILED)
3886     {
3887       DEBUG_PRINT_ERROR("\n MMAP failed for Size %d",m_out_buf_size);
3888       return OMX_ErrorInsufficientResources;
3889     }
3890     m_out_mem_ptr = (OMX_BUFFERHEADERTYPE  *)calloc(nBufHdrSize,1);
3891     // Alloc mem for platform specific info
3892     char *pPtr=NULL;
3893     pPtr = (char*) calloc(nPlatformListSize + nPlatformEntrySize +
3894                                      nPMEMInfoSize,1);
3895     driver_context.ptr_outputbuffer = (struct vdec_bufferpayload *) \
3896       calloc (sizeof(struct vdec_bufferpayload),m_out_buf_count);
3897     driver_context.ptr_respbuffer = (struct vdec_output_frameinfo  *)\
3898       calloc (sizeof (struct vdec_output_frameinfo),m_out_buf_count);
3899
3900     if(m_out_mem_ptr && pPtr && driver_context.ptr_outputbuffer
3901        && driver_context.ptr_respbuffer)
3902     {
3903       driver_context.ptr_outputbuffer[0].mmaped_size =
3904         (m_out_buf_size * m_out_buf_count);
3905       bufHdr          =  m_out_mem_ptr;
3906       m_platform_list = (OMX_QCOM_PLATFORM_PRIVATE_LIST *)(pPtr);
3907       m_platform_entry= (OMX_QCOM_PLATFORM_PRIVATE_ENTRY *)
3908                         (((char *) m_platform_list)  + nPlatformListSize);
3909       m_pmem_info     = (OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO *)
3910                         (((char *) m_platform_entry) + nPlatformEntrySize);
3911       pPlatformList   = m_platform_list;
3912       pPlatformEntry  = m_platform_entry;
3913       pPMEMInfo       = m_pmem_info;
3914
3915       DEBUG_PRINT_LOW("Memory Allocation Succeeded for OUT port%p\n",m_out_mem_ptr);
3916
3917       // Settting the entire storage nicely
3918       DEBUG_PRINT_LOW("bHdr %p OutMem %p PE %p\n",bufHdr, m_out_mem_ptr,pPlatformEntry);
3919       DEBUG_PRINT_LOW(" Pmem Info = %p \n",pPMEMInfo);
3920       for(i=0; i < m_out_buf_count ; i++)
3921       {
3922         bufHdr->nSize              = sizeof(OMX_BUFFERHEADERTYPE);
3923         bufHdr->nVersion.nVersion  = OMX_SPEC_VERSION;
3924         // Set the values when we determine the right HxW param
3925         bufHdr->nAllocLen          = bytes;
3926         bufHdr->nFilledLen         = 0;
3927         bufHdr->pAppPrivate        = appData;
3928         bufHdr->nOutputPortIndex   = OMX_CORE_OUTPUT_PORT_INDEX;
3929         // Platform specific PMEM Information
3930         // Initialize the Platform Entry
3931         //DEBUG_PRINT_LOW("Initializing the Platform Entry for %d\n",i);
3932         pPlatformEntry->type       = OMX_QCOM_PLATFORM_PRIVATE_PMEM;
3933         pPlatformEntry->entry      = pPMEMInfo;
3934         // Initialize the Platform List
3935         pPlatformList->nEntries    = 1;
3936         pPlatformList->entryList   = pPlatformEntry;
3937         // Keep pBuffer NULL till vdec is opened
3938         bufHdr->pBuffer            = NULL;
3939         bufHdr->nOffset            = 0;
3940
3941         pPMEMInfo->offset          =  m_out_buf_size*i;
3942         pPMEMInfo->pmem_fd = 0;
3943         bufHdr->pPlatformPrivate = pPlatformList;
3944
3945         driver_context.ptr_outputbuffer[i].pmem_fd = pmem_fd;
3946
3947         /*Create a mapping between buffers*/
3948         bufHdr->pOutputPortPrivate = &driver_context.ptr_respbuffer[i];
3949         driver_context.ptr_respbuffer[i].client_data = (void *) \
3950                                             &driver_context.ptr_outputbuffer[i];
3951         driver_context.ptr_outputbuffer[i].offset = m_out_buf_size*i;
3952         driver_context.ptr_outputbuffer[i].bufferaddr = \
3953           pmem_baseaddress + (m_out_buf_size*i);
3954
3955         DEBUG_PRINT_LOW("\n pmem_fd = %d offset = %d address = %p",\
3956                      pmem_fd,driver_context.ptr_outputbuffer[i].offset,driver_context.ptr_outputbuffer[i].bufferaddr);
3957         // Move the buffer and buffer header pointers
3958         bufHdr++;
3959         pPMEMInfo++;
3960         pPlatformEntry++;
3961         pPlatformList++;
3962       }
3963     }
3964     else
3965     {
3966       DEBUG_PRINT_ERROR("Output buf mem alloc failed[0x%x][0x%x]\n",\
3967                                         m_out_mem_ptr, pPtr);
3968       if(m_out_mem_ptr)
3969       {
3970         free(m_out_mem_ptr);
3971         m_out_mem_ptr = NULL;
3972       }
3973       if(pPtr)
3974       {
3975         free(pPtr);
3976         pPtr = NULL;
3977       }
3978       if(driver_context.ptr_outputbuffer)
3979       {
3980         free(driver_context.ptr_outputbuffer);
3981         driver_context.ptr_outputbuffer = NULL;
3982       }
3983       if(driver_context.ptr_respbuffer)
3984       {
3985         free(driver_context.ptr_respbuffer);
3986         driver_context.ptr_respbuffer = NULL;
3987       }
3988       eRet =  OMX_ErrorInsufficientResources;
3989     }
3990   }
3991
3992   for(i=0; i< m_out_buf_count; i++)
3993   {
3994     if(BITMASK_ABSENT(&m_out_bm_count,i))
3995     {
3996       DEBUG_PRINT_LOW("\n Found a Free Output Buffer %d",i);
3997       break;
3998     }
3999   }
4000
4001   if (eRet == OMX_ErrorNone)
4002   {
4003     if(i < m_out_buf_count)
4004     {
4005       m_pmem_info[i].offset = driver_context.ptr_outputbuffer[i].offset;
4006       m_pmem_info[i].pmem_fd = (OMX_U32) m_heap_ptr.get ();
4007       driver_context.ptr_outputbuffer[i].buffer_len = m_out_buf_size;
4008       //driver_context.ptr_outputbuffer[i].mmaped_size = m_out_buf_size;
4009      if(!gate_output_buffers)
4010      {
4011      setbuffers.buffer_type = VDEC_BUFFER_TYPE_OUTPUT;
4012      memcpy (&setbuffers.buffer,&driver_context.ptr_outputbuffer [i],
4013              sizeof (vdec_bufferpayload));
4014      ioctl_msg.inputparam  = &setbuffers;
4015      ioctl_msg.outputparam = NULL;
4016
4017      DEBUG_PRINT_LOW("\n Set the Output Buffer");
4018      if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_BUFFER,
4019           &ioctl_msg) < 0)
4020      {
4021        DEBUG_PRINT_ERROR("\n Set output buffer failed");
4022        return OMX_ErrorInsufficientResources;
4023      }
4024      }
4025
4026       // found an empty buffer at i
4027       *bufferHdr = (m_out_mem_ptr + i );
4028       (*bufferHdr)->pBuffer = driver_context.ptr_outputbuffer[i].bufferaddr;
4029       (*bufferHdr)->pAppPrivate = appData;
4030       BITMASK_SET(&m_out_bm_count,i);
4031     }
4032     else
4033     {
4034       DEBUG_PRINT_ERROR("All the Output Buffers have been Allocated ; Returning Insufficient \n");
4035       eRet = OMX_ErrorInsufficientResources;
4036     }
4037   }
4038
4039   return eRet;
4040 }
4041
4042
4043 // AllocateBuffer  -- API Call
4044 /* ======================================================================
4045 FUNCTION
4046   omx_vdec::AllocateBuffer
4047
4048 DESCRIPTION
4049   Returns zero if all the buffers released..
4050
4051 PARAMETERS
4052   None.
4053
4054 RETURN VALUE
4055   true/false
4056
4057 ========================================================================== */
4058 OMX_ERRORTYPE  omx_vdec::allocate_buffer(OMX_IN OMX_HANDLETYPE                hComp,
4059                                      OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
4060                                      OMX_IN OMX_U32                        port,
4061                                      OMX_IN OMX_PTR                     appData,
4062                                      OMX_IN OMX_U32                       bytes)
4063 {
4064     unsigned i = 0;
4065     OMX_ERRORTYPE eRet = OMX_ErrorNone; // OMX return type
4066
4067     DEBUG_PRINT_LOW("\n Allocate buffer on port %d \n", (int)port);
4068     if(m_state == OMX_StateInvalid)
4069     {
4070         DEBUG_PRINT_ERROR("Allocate Buf in Invalid State\n");
4071         return OMX_ErrorInvalidState;
4072     }
4073
4074     if(port == OMX_CORE_INPUT_PORT_INDEX)
4075     {
4076       if (arbitrary_bytes)
4077       {
4078           eRet = allocate_input_heap_buffer (hComp,bufferHdr,port,appData,bytes);
4079       }
4080       else
4081       {
4082         eRet = allocate_input_buffer(hComp,bufferHdr,port,appData,bytes);
4083       }
4084     }
4085     else if(port == OMX_CORE_OUTPUT_PORT_INDEX)
4086     {
4087       eRet = allocate_output_buffer(hComp,bufferHdr,port,appData,bytes);
4088     }
4089     else
4090     {
4091       DEBUG_PRINT_ERROR("Error: Invalid Port Index received %d\n",(int)port);
4092       eRet = OMX_ErrorBadPortIndex;
4093     }
4094     DEBUG_PRINT_LOW("Checking for Output Allocate buffer Done");
4095     if(eRet == OMX_ErrorNone)
4096     {
4097         if(allocate_done()){
4098             if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
4099             {
4100                 // Send the callback now
4101                 BITMASK_CLEAR((&m_flags),OMX_COMPONENT_IDLE_PENDING);
4102                 post_event(OMX_CommandStateSet,OMX_StateIdle,
4103                                    OMX_COMPONENT_GENERATE_EVENT);
4104             }
4105         }
4106         if(port == OMX_CORE_INPUT_PORT_INDEX && m_inp_bPopulated)
4107         {
4108           if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
4109           {
4110              BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_ENABLE_PENDING);
4111              post_event(OMX_CommandPortEnable,
4112                         OMX_CORE_INPUT_PORT_INDEX,
4113                         OMX_COMPONENT_GENERATE_EVENT);
4114           }
4115         }
4116         if(port == OMX_CORE_OUTPUT_PORT_INDEX && m_out_bPopulated)
4117             {
4118           if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
4119           {
4120              BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
4121                 post_event(OMX_CommandPortEnable,
4122                            OMX_CORE_OUTPUT_PORT_INDEX,
4123                            OMX_COMPONENT_GENERATE_EVENT);
4124                 m_event_port_settings_sent = false;
4125             }
4126         }
4127     }
4128     DEBUG_PRINT_LOW("Allocate Buffer exit with ret Code %d\n",eRet);
4129     return eRet;
4130 }
4131
4132 // Free Buffer - API call
4133 /* ======================================================================
4134 FUNCTION
4135   omx_vdec::FreeBuffer
4136
4137 DESCRIPTION
4138
4139 PARAMETERS
4140   None.
4141
4142 RETURN VALUE
4143   true/false
4144
4145 ========================================================================== */
4146 OMX_ERRORTYPE  omx_vdec::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
4147                                       OMX_IN OMX_U32                 port,
4148                                       OMX_IN OMX_BUFFERHEADERTYPE* buffer)
4149 {
4150     OMX_ERRORTYPE eRet = OMX_ErrorNone;
4151     unsigned int nPortIndex;
4152
4153     DEBUG_PRINT_LOW("In for decoder free_buffer \n");
4154
4155     if(m_state == OMX_StateIdle &&
4156        (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING)))
4157     {
4158         DEBUG_PRINT_LOW(" free buffer while Component in Loading pending\n");
4159     }
4160     else if((m_inp_bEnabled == OMX_FALSE && port == OMX_CORE_INPUT_PORT_INDEX)||
4161             (m_out_bEnabled == OMX_FALSE && port == OMX_CORE_OUTPUT_PORT_INDEX))
4162     {
4163         DEBUG_PRINT_LOW("Free Buffer while port %d disabled\n", port);
4164     }
4165     else if(m_state == OMX_StateExecuting || m_state == OMX_StatePause)
4166     {
4167         DEBUG_PRINT_ERROR("Invalid state to free buffer,ports need to be disabled\n");
4168         post_event(OMX_EventError,
4169                    OMX_ErrorPortUnpopulated,
4170                    OMX_COMPONENT_GENERATE_EVENT);
4171
4172         return eRet;
4173     }
4174     else if (m_state != OMX_StateInvalid)
4175     {
4176         DEBUG_PRINT_ERROR("Invalid state to free buffer,port lost Buffers\n");
4177         post_event(OMX_EventError,
4178                    OMX_ErrorPortUnpopulated,
4179                    OMX_COMPONENT_GENERATE_EVENT);
4180     }
4181
4182     if(port == OMX_CORE_INPUT_PORT_INDEX)
4183     {
4184       /*Check if arbitrary bytes*/
4185       if (!arbitrary_bytes)
4186       {
4187        // check if the buffer is valid
4188         nPortIndex = buffer - m_inp_mem_ptr;
4189       }
4190       else
4191       {
4192          nPortIndex = buffer - m_inp_heap_ptr;
4193       }
4194
4195         DEBUG_PRINT_LOW("free_buffer on i/p port - Port idx %d \n", nPortIndex);
4196         if(nPortIndex < m_inp_buf_count)
4197         {
4198           // Clear the bit associated with it.
4199           BITMASK_CLEAR(&m_inp_bm_count,nPortIndex);
4200
4201           if (arbitrary_bytes)
4202           {
4203             if (m_inp_heap_ptr[nPortIndex].pBuffer)
4204             {
4205               BITMASK_CLEAR(&m_heap_inp_bm_count,nPortIndex);
4206               DEBUG_PRINT_LOW("\n Free Heap Buffer index %d",nPortIndex);
4207               free (m_inp_heap_ptr[nPortIndex].pBuffer);
4208               m_inp_heap_ptr[nPortIndex].pBuffer = NULL;
4209             }
4210             if (m_phdr_pmem_ptr[nPortIndex])
4211             {
4212               DEBUG_PRINT_LOW("\n Free pmem Buffer index %d",nPortIndex);
4213               free_input_buffer(m_phdr_pmem_ptr[nPortIndex]);
4214             }
4215           }
4216           else
4217           {
4218             free_input_buffer(buffer);
4219           }
4220
4221           m_inp_bPopulated = OMX_FALSE;
4222
4223           /*Free the Buffer Header*/
4224           if (release_input_done())
4225           {
4226             DEBUG_PRINT_HIGH("\n ALL input buffers are freed/released");
4227             input_use_buffer = false;
4228             if (arbitrary_bytes)
4229             {
4230               if (m_frame_parser.mutils)
4231               {
4232                 DEBUG_PRINT_LOW("\n Free utils parser");
4233                 delete (m_frame_parser.mutils);
4234                 m_frame_parser.mutils = NULL;
4235               }
4236
4237               if (m_inp_heap_ptr)
4238               {
4239                 DEBUG_PRINT_LOW("\n Free input Heap Pointer");
4240                 free (m_inp_heap_ptr);
4241                 m_inp_heap_ptr = NULL;
4242               }
4243
4244               if (m_phdr_pmem_ptr)
4245               {
4246                 DEBUG_PRINT_LOW("\n Free input pmem header Pointer");
4247                 free (m_phdr_pmem_ptr);
4248                 m_phdr_pmem_ptr = NULL;
4249               }
4250             }
4251             if (m_inp_mem_ptr)
4252             {
4253               DEBUG_PRINT_LOW("\n Free input pmem Pointer area");
4254               free (m_inp_mem_ptr);
4255               m_inp_mem_ptr = NULL;
4256             }
4257
4258             if (driver_context.ptr_inputbuffer)
4259             {
4260               DEBUG_PRINT_LOW("\n Free Driver Context pointer");
4261               free (driver_context.ptr_inputbuffer);
4262               driver_context.ptr_inputbuffer = NULL;
4263             }
4264           }
4265
4266         }
4267         else
4268         {
4269             DEBUG_PRINT_ERROR("Error: free_buffer ,Port Index Invalid\n");
4270             eRet = OMX_ErrorBadPortIndex;
4271         }
4272
4273         if(BITMASK_PRESENT((&m_flags),OMX_COMPONENT_INPUT_DISABLE_PENDING)
4274            && release_input_done())
4275         {
4276             DEBUG_PRINT_LOW("MOVING TO DISABLED STATE \n");
4277             BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_DISABLE_PENDING);
4278             post_event(OMX_CommandPortDisable,
4279                        OMX_CORE_INPUT_PORT_INDEX,
4280                        OMX_COMPONENT_GENERATE_EVENT);
4281         }
4282     }
4283     else if(port == OMX_CORE_OUTPUT_PORT_INDEX)
4284     {
4285         // check if the buffer is valid
4286         nPortIndex = buffer - (OMX_BUFFERHEADERTYPE*)m_out_mem_ptr;
4287         if(nPortIndex < m_out_buf_count)
4288         {
4289             DEBUG_PRINT_LOW("free_buffer on o/p port - Port idx %d \n", nPortIndex);
4290             // Clear the bit associated with it.
4291             BITMASK_CLEAR(&m_out_bm_count,nPortIndex);
4292             m_out_bPopulated = OMX_FALSE;
4293             free_output_buffer (buffer);
4294
4295             if (release_output_done())
4296             {
4297               DEBUG_PRINT_HIGH("\n ALL output buffers are freed/released");
4298               output_use_buffer = false;
4299               if (m_out_mem_ptr)
4300               {
4301                 free (m_out_mem_ptr);
4302                 m_out_mem_ptr = NULL;
4303               }
4304               if (driver_context.ptr_respbuffer)
4305               {
4306                 free (driver_context.ptr_respbuffer);
4307                 driver_context.ptr_respbuffer = NULL;
4308               }
4309               if (driver_context.ptr_outputbuffer)
4310               {
4311                 free (driver_context.ptr_outputbuffer);
4312                 driver_context.ptr_outputbuffer = NULL;
4313               }
4314             }
4315         }
4316         else
4317         {
4318             DEBUG_PRINT_ERROR("Error: free_buffer , Port Index Invalid\n");
4319             eRet = OMX_ErrorBadPortIndex;
4320         }
4321         if(BITMASK_PRESENT((&m_flags),OMX_COMPONENT_OUTPUT_DISABLE_PENDING)
4322            && release_output_done() )
4323         {
4324             DEBUG_PRINT_LOW("FreeBuffer : If any Disable event pending,post it\n");
4325
4326                 DEBUG_PRINT_LOW("MOVING TO DISABLED STATE \n");
4327                 BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
4328                 post_event(OMX_CommandPortDisable,
4329                            OMX_CORE_OUTPUT_PORT_INDEX,
4330                            OMX_COMPONENT_GENERATE_EVENT);
4331         }
4332     }
4333     else
4334     {
4335         eRet = OMX_ErrorBadPortIndex;
4336     }
4337     if((eRet == OMX_ErrorNone) &&
4338        (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING)))
4339     {
4340         if(release_done())
4341         {
4342             // Send the callback now
4343             BITMASK_CLEAR((&m_flags),OMX_COMPONENT_LOADING_PENDING);
4344             post_event(OMX_CommandStateSet, OMX_StateLoaded,
4345                                       OMX_COMPONENT_GENERATE_EVENT);
4346         }
4347     }
4348     return eRet;
4349 }
4350
4351
4352 /* ======================================================================
4353 FUNCTION
4354   omx_vdec::EmptyThisBuffer
4355
4356 DESCRIPTION
4357   This routine is used to push the encoded video frames to
4358   the video decoder.
4359
4360 PARAMETERS
4361   None.
4362
4363 RETURN VALUE
4364   OMX Error None if everything went successful.
4365
4366 ========================================================================== */
4367 OMX_ERRORTYPE  omx_vdec::empty_this_buffer(OMX_IN OMX_HANDLETYPE         hComp,
4368                                            OMX_IN OMX_BUFFERHEADERTYPE* buffer)
4369 {
4370   OMX_ERRORTYPE ret1 = OMX_ErrorNone;
4371   unsigned int nBufferIndex = m_inp_buf_count;
4372
4373   if(m_state == OMX_StateInvalid)
4374   {
4375       DEBUG_PRINT_ERROR("Empty this buffer in Invalid State\n");
4376       return OMX_ErrorInvalidState;
4377   }
4378
4379   if (buffer == NULL)
4380   {
4381     DEBUG_PRINT_ERROR("\nERROR:ETB Buffer is NULL");
4382     return OMX_ErrorBadParameter;
4383   }
4384
4385   if (arbitrary_bytes)
4386   {
4387     nBufferIndex = buffer - m_inp_heap_ptr;
4388   }
4389   else
4390   {
4391     nBufferIndex = buffer - m_inp_mem_ptr;
4392   }
4393
4394   if (nBufferIndex > m_inp_buf_count )
4395   {
4396     DEBUG_PRINT_ERROR("\nERROR:ETB nBufferIndex is invalid");
4397     return OMX_ErrorBadParameter;
4398   }
4399
4400   DEBUG_PRINT_LOW("\n ETB: bufhdr = %p, bufhdr->pBuffer = %p", buffer, buffer->pBuffer);
4401   if (arbitrary_bytes)
4402   {
4403     post_event ((unsigned)hComp,(unsigned)buffer,
4404                 OMX_COMPONENT_GENERATE_ETB_ARBITRARY);
4405   }
4406   else
4407   {
4408     post_event ((unsigned)hComp,(unsigned)buffer,OMX_COMPONENT_GENERATE_ETB);
4409   }
4410   return OMX_ErrorNone;
4411 }
4412
4413 /* ======================================================================
4414 FUNCTION
4415   omx_vdec::empty_this_buffer_proxy
4416
4417 DESCRIPTION
4418   This routine is used to push the encoded video frames to
4419   the video decoder.
4420
4421 PARAMETERS
4422   None.
4423
4424 RETURN VALUE
4425   OMX Error None if everything went successful.
4426
4427 ========================================================================== */
4428 OMX_ERRORTYPE  omx_vdec::empty_this_buffer_proxy(OMX_IN OMX_HANDLETYPE         hComp,
4429                                                  OMX_IN OMX_BUFFERHEADERTYPE* buffer)
4430 {
4431   int push_cnt = 0,i=0;
4432   unsigned nPortIndex = 0;
4433   OMX_ERRORTYPE ret = OMX_ErrorNone;
4434   struct vdec_input_frameinfo frameinfo;
4435   struct vdec_bufferpayload *temp_buffer;
4436   struct vdec_ioctl_msg ioctl_msg;
4437   struct vdec_seqheader seq_header;
4438   bool port_setting_changed = true;
4439
4440   /*Should we generate a Aync error event*/
4441   if (buffer == NULL || buffer->pInputPortPrivate == NULL)
4442   {
4443     DEBUG_PRINT_ERROR("\nERROR:empty_this_buffer_proxy is invalid");
4444     return OMX_ErrorBadParameter;
4445   }
4446
4447   nPortIndex = buffer-((OMX_BUFFERHEADERTYPE *)m_inp_mem_ptr);
4448
4449   if (nPortIndex > m_inp_buf_count)
4450   {
4451     DEBUG_PRINT_ERROR("\nERROR:empty_this_buffer_proxy invalid nPortIndex[%u]",
4452         nPortIndex);
4453     return OMX_ErrorBadParameter;
4454   }
4455
4456   pending_input_buffers++;
4457
4458   if( input_flush_progress == true || m_ineos_reached == 1)
4459   {
4460     DEBUG_PRINT_LOW("\n Flush in progress return buffer ");
4461     post_event ((unsigned int)buffer,VDEC_S_SUCCESS,
4462                      OMX_COMPONENT_GENERATE_EBD);
4463     return OMX_ErrorNone;
4464   }
4465
4466   if(m_event_port_settings_sent && !arbitrary_bytes)
4467   {
4468     post_event((unsigned)hComp,(unsigned)buffer,OMX_COMPONENT_GENERATE_ETB);
4469     return OMX_ErrorNone;
4470   }
4471
4472   temp_buffer = (struct vdec_bufferpayload *)buffer->pInputPortPrivate;
4473
4474   if ((temp_buffer -  driver_context.ptr_inputbuffer) > m_inp_buf_count)
4475   {
4476     return OMX_ErrorBadParameter;
4477   }
4478
4479   DEBUG_PRINT_LOW("\n ETBProxy: bufhdr = %p, bufhdr->pBuffer = %p", buffer, buffer->pBuffer);
4480   /*for use buffer we need to memcpy the data*/
4481   temp_buffer->buffer_len = buffer->nFilledLen;
4482
4483   if (input_use_buffer)
4484   {
4485     if (buffer->nFilledLen <= temp_buffer->buffer_len)
4486     {
4487       memcpy (temp_buffer->bufferaddr,(buffer->pBuffer + buffer->nOffset),
4488               buffer->nFilledLen);
4489     }
4490     else
4491     {
4492       return OMX_ErrorBadParameter;
4493     }
4494
4495   }
4496
4497   if (!arbitrary_bytes && first_frame < 2  && codec_type_parse == CODEC_TYPE_MPEG4)
4498   {
4499
4500     if (first_frame == 0)
4501     {
4502        first_buffer = (unsigned char *)malloc (m_inp_buf_size);
4503        DEBUG_PRINT_LOW("\n Copied the first buffer data size %d ",
4504                     temp_buffer->buffer_len);
4505        first_frame = 1;
4506        memcpy (first_buffer,temp_buffer->bufferaddr,temp_buffer->buffer_len);
4507        first_frame_size = buffer->nFilledLen;
4508        buffer->nFilledLen = 0;
4509        post_event ((unsigned int)buffer,VDEC_S_SUCCESS,
4510                    OMX_COMPONENT_GENERATE_EBD);
4511        return OMX_ErrorNone;
4512     }
4513     else if (first_frame == 1)
4514     {
4515        first_frame = 2;
4516        DEBUG_PRINT_LOW("\n Second buffer copy the header size %d frame size %d",
4517                     first_frame_size,temp_buffer->buffer_len);
4518        memcpy (&first_buffer [first_frame_size],temp_buffer->bufferaddr,
4519                temp_buffer->buffer_len);
4520        first_frame_size += temp_buffer->buffer_len;
4521        memcpy (temp_buffer->bufferaddr,first_buffer,first_frame_size);
4522        temp_buffer->buffer_len = first_frame_size;
4523        free (first_buffer);
4524     }
4525   }
4526
4527   frameinfo.bufferaddr = temp_buffer->bufferaddr;
4528   frameinfo.client_data = (void *) buffer;
4529   frameinfo.datalen = temp_buffer->buffer_len;
4530   frameinfo.flags = 0;
4531   frameinfo.offset = buffer->nOffset;
4532   frameinfo.pmem_fd = temp_buffer->pmem_fd;
4533   frameinfo.pmem_offset = temp_buffer->offset;
4534   frameinfo.timestamp = buffer->nTimeStamp;
4535
4536 #if BITSTREAM_LOG
4537   int bytes_written;
4538   bytes_written = fwrite((const char *)temp_buffer->bufferaddr,
4539                           temp_buffer->buffer_len,1,outputBufferFile1);
4540
4541 #endif
4542
4543   if(!set_seq_header_done)
4544   {
4545     set_seq_header_done = true;
4546     DEBUG_PRINT_HIGH("\n Set Sequence Header");
4547     seq_header.ptr_seqheader = frameinfo.bufferaddr;
4548     seq_header.seq_header_len = frameinfo.datalen;
4549     seq_header.pmem_fd = frameinfo.pmem_fd;
4550     seq_header.pmem_offset = frameinfo.pmem_offset;
4551     ioctl_msg.inputparam = &seq_header;
4552     ioctl_msg.outputparam = NULL;
4553     if (ioctl(driver_context.video_driver_fd,VDEC_IOCTL_SET_SEQUENCE_HEADER,
4554               &ioctl_msg) < 0)
4555     {
4556       DEBUG_PRINT_ERROR("\n Set Sequence Header Failed");
4557       /*Generate an async error and move to invalid state*/
4558       return OMX_ErrorBadParameter;
4559     }
4560     if(omx_vdec_check_port_settings (&port_setting_changed) != OMX_ErrorNone)
4561     {
4562       DEBUG_PRINT_ERROR("\n Check port setting failed");
4563       return OMX_ErrorBadParameter;
4564     }
4565
4566     if(port_setting_changed)
4567     {
4568       DEBUG_PRINT_HIGH("\n Port settings changed");
4569       m_event_port_settings_sent = true;
4570       m_cb.EventHandler(&m_cmp, m_app_data,OMX_EventPortSettingsChanged,
4571                           OMX_CORE_OUTPUT_PORT_INDEX, 0, NULL );
4572       DEBUG_PRINT_HIGH("\n EventHandler for Port Setting changed done");
4573       return OMX_ErrorNone;
4574     }
4575     else
4576     {
4577       if(!register_output_buffers())
4578       {
4579         DEBUG_PRINT_ERROR("\n register output failed");
4580         return OMX_ErrorBadParameter;
4581       }
4582       DEBUG_PRINT_HIGH("\n Port settings Not changed");
4583     }
4584   }
4585
4586   if (temp_buffer->buffer_len == 0 || (buffer->nFlags & 0x01))
4587   {
4588     DEBUG_PRINT_HIGH("\n Rxd i/p EOS, Notify Driver that EOS has been reached");
4589     frameinfo.flags |= VDEC_BUFFERFLAG_EOS;
4590     m_ineos_reached = 1;
4591   }
4592
4593   sent_first_frame = true;
4594   DEBUG_PRINT_LOW("\n Decode Input Frame Size %d",frameinfo.datalen);
4595   ioctl_msg.inputparam = &frameinfo;
4596   ioctl_msg.outputparam = NULL;
4597
4598   if (ioctl(driver_context.video_driver_fd,VDEC_IOCTL_DECODE_FRAME,
4599             &ioctl_msg) < 0)
4600   {
4601     /*Generate an async error and move to invalid state*/
4602     return OMX_ErrorBadParameter;
4603   }
4604
4605   return ret;
4606 }
4607
4608 /* ======================================================================
4609 FUNCTION
4610   omx_vdec::FillThisBuffer
4611
4612 DESCRIPTION
4613   IL client uses this method to release the frame buffer
4614   after displaying them.
4615
4616 PARAMETERS
4617   None.
4618
4619 RETURN VALUE
4620   true/false
4621
4622 ========================================================================== */
4623 OMX_ERRORTYPE  omx_vdec::fill_this_buffer(OMX_IN OMX_HANDLETYPE  hComp,
4624                                           OMX_IN OMX_BUFFERHEADERTYPE* buffer)
4625 {
4626
4627   if(m_state == OMX_StateInvalid)
4628   {
4629       DEBUG_PRINT_ERROR("FTB in Invalid State\n");
4630       return OMX_ErrorInvalidState;
4631   }
4632
4633   if (buffer == NULL || ((buffer - m_out_mem_ptr) > m_out_buf_size))
4634   {
4635     return OMX_ErrorBadParameter;
4636   }
4637
4638   DEBUG_PRINT_LOW("\n FTB: bufhdr = %p, bufhdr->pBuffer = %p", buffer, buffer->pBuffer);
4639   post_event((unsigned) hComp, (unsigned)buffer,OMX_COMPONENT_GENERATE_FTB);
4640   return OMX_ErrorNone;
4641 }
4642 /* ======================================================================
4643 FUNCTION
4644   omx_vdec::fill_this_buffer_proxy
4645
4646 DESCRIPTION
4647   IL client uses this method to release the frame buffer
4648   after displaying them.
4649
4650 PARAMETERS
4651   None.
4652
4653 RETURN VALUE
4654   true/false
4655
4656 ========================================================================== */
4657 OMX_ERRORTYPE  omx_vdec::fill_this_buffer_proxy(
4658                          OMX_IN OMX_HANDLETYPE        hComp,
4659                          OMX_IN OMX_BUFFERHEADERTYPE* bufferAdd)
4660 {
4661   OMX_ERRORTYPE nRet = OMX_ErrorNone;
4662   struct vdec_ioctl_msg ioctl_msg = {NULL,NULL};
4663   OMX_BUFFERHEADERTYPE *buffer = bufferAdd;
4664   struct vdec_fillbuffer_cmd fillbuffer;
4665   struct vdec_bufferpayload     *ptr_outputbuffer = NULL;
4666   struct vdec_output_frameinfo  *ptr_respbuffer = NULL;
4667
4668
4669   if (bufferAdd == NULL || ((buffer - m_out_mem_ptr) > m_out_buf_count) )
4670   {
4671     return OMX_ErrorBadParameter;
4672   }
4673
4674   DEBUG_PRINT_LOW("\n FTBProxy: bufhdr = %p, bufhdr->pBuffer = %p",
4675       bufferAdd, bufferAdd->pBuffer);
4676   /*Return back the output buffer to client*/
4677   if( (m_event_port_settings_sent == true) || (m_out_bEnabled != OMX_TRUE)
4678       || output_flush_progress == true || m_outeos_reached == 1)
4679   {
4680     DEBUG_PRINT_LOW("\n Output Buffers return in EOS condition");
4681     buffer->nFlags |= m_outeos_reached;
4682     m_cb.FillBufferDone (hComp,m_app_data,buffer);
4683     return OMX_ErrorNone;
4684   }
4685   pending_output_buffers++;
4686   ptr_respbuffer = (struct vdec_output_frameinfo*)buffer->pOutputPortPrivate;
4687   if (ptr_respbuffer)
4688   {
4689     ptr_outputbuffer =  (struct vdec_bufferpayload*)ptr_respbuffer->client_data;
4690   }
4691
4692   if (ptr_respbuffer == NULL || ptr_outputbuffer == NULL)
4693   {
4694     return OMX_ErrorBadParameter;
4695   }
4696
4697   memcpy (&fillbuffer.buffer,ptr_outputbuffer,\
4698           sizeof(struct vdec_bufferpayload));
4699   fillbuffer.client_data = bufferAdd;
4700
4701   ioctl_msg.inputparam = &fillbuffer;
4702   ioctl_msg.outputparam = NULL;
4703   if (ioctl (driver_context.video_driver_fd,
4704          VDEC_IOCTL_FILL_OUTPUT_BUFFER,&ioctl_msg) < 0)
4705   {
4706     DEBUG_PRINT_ERROR("\n Decoder frame failed");
4707     m_cb.FillBufferDone (hComp,m_app_data,buffer);
4708     return OMX_ErrorBadParameter;
4709   }
4710
4711   if(gate_input_buffers)
4712   {
4713     gate_input_buffers = false;
4714     if(pdest_frame)
4715     {
4716       /*Push the frame to the Decoder*/
4717       if (empty_this_buffer_proxy(hComp,pdest_frame) != OMX_ErrorNone)
4718       {
4719         return OMX_ErrorBadParameter;
4720       }
4721       frame_count++;
4722       pdest_frame = NULL;
4723     }
4724   }
4725   return OMX_ErrorNone;
4726 }
4727
4728 /* ======================================================================
4729 FUNCTION
4730   omx_vdec::SetCallbacks
4731
4732 DESCRIPTION
4733   Set the callbacks.
4734
4735 PARAMETERS
4736   None.
4737
4738 RETURN VALUE
4739   OMX Error None if everything successful.
4740
4741 ========================================================================== */
4742 OMX_ERRORTYPE  omx_vdec::set_callbacks(OMX_IN OMX_HANDLETYPE        hComp,
4743                                            OMX_IN OMX_CALLBACKTYPE* callbacks,
4744                                            OMX_IN OMX_PTR             appData)
4745 {
4746
4747   m_cb       = *callbacks;
4748   DEBUG_PRINT_LOW("\n Callbacks Set %p %p %p",m_cb.EmptyBufferDone,\
4749                m_cb.EventHandler,m_cb.FillBufferDone);
4750   m_app_data =    appData;
4751   return OMX_ErrorNotImplemented;
4752 }
4753
4754 /* ======================================================================
4755 FUNCTION
4756   omx_vdec::ComponentDeInit
4757
4758 DESCRIPTION
4759   Destroys the component and release memory allocated to the heap.
4760
4761 PARAMETERS
4762   <TBD>.
4763
4764 RETURN VALUE
4765   OMX Error None if everything successful.
4766
4767 ========================================================================== */
4768 OMX_ERRORTYPE  omx_vdec::component_deinit(OMX_IN OMX_HANDLETYPE hComp)
4769 {
4770     int i = 0;
4771     if (OMX_StateLoaded != m_state)
4772     {
4773         DEBUG_PRINT_ERROR("WARNING:Rxd DeInit,OMX not in LOADED state %d\n",\
4774                           m_state);
4775         DEBUG_PRINT_ERROR("\nPlayback Ended - FAILED");
4776     }
4777     else
4778     {
4779       DEBUG_PRINT_HIGH("\n Playback Ended - PASSED");
4780     }
4781
4782     /*Check if the output buffers have to be cleaned up*/
4783     if(m_out_mem_ptr)
4784     {
4785         DEBUG_PRINT_LOW("Freeing the Output Memory\n");
4786         for (i=0; i<m_out_buf_count; i++ )
4787         {
4788           free_output_buffer (&m_out_mem_ptr[i]);
4789         }
4790         if (driver_context.ptr_outputbuffer)
4791         {
4792           free (driver_context.ptr_outputbuffer);
4793           driver_context.ptr_outputbuffer = NULL;
4794         }
4795
4796         if (driver_context.ptr_respbuffer)
4797         {
4798           free (driver_context.ptr_respbuffer);
4799           driver_context.ptr_respbuffer = NULL;
4800         }
4801         free(m_out_mem_ptr);
4802         m_out_mem_ptr = NULL;
4803     }
4804
4805     /*Check if the input buffers have to be cleaned up*/
4806     if(m_inp_mem_ptr)
4807     {
4808         DEBUG_PRINT_LOW("Freeing the Input Memory\n");
4809         for (i=0; i<m_inp_buf_count; i++ )
4810         {
4811           free_input_buffer (&m_inp_mem_ptr[i]);
4812         }
4813
4814         if (driver_context.ptr_inputbuffer)
4815         {
4816           free (driver_context.ptr_inputbuffer);
4817           driver_context.ptr_inputbuffer = NULL;
4818         }
4819
4820         free(m_inp_mem_ptr);
4821         m_inp_mem_ptr = NULL;
4822     }
4823
4824     if(h264_scratch.pBuffer)
4825     {
4826       free(h264_scratch.pBuffer);
4827       h264_scratch.pBuffer = NULL;
4828     }
4829
4830     if(m_platform_list)
4831     {
4832         free(m_platform_list);
4833         m_platform_list = NULL;
4834     }
4835     if(m_vendor_config.pData)
4836     {
4837         free(m_vendor_config.pData);
4838         m_vendor_config.pData = NULL;
4839     }
4840
4841     // Reset counters in mesg queues
4842     m_ftb_q.m_size=0;
4843     m_cmd_q.m_size=0;
4844     m_etb_q.m_size=0;
4845     m_ftb_q.m_read = m_ftb_q.m_write =0;
4846     m_cmd_q.m_read = m_cmd_q.m_write =0;
4847     m_etb_q.m_read = m_etb_q.m_write =0;
4848
4849     DEBUG_PRINT_LOW("\n Calling VDEC_IOCTL_STOP_NEXT_MSG");
4850     (void)ioctl(driver_context.video_driver_fd, VDEC_IOCTL_STOP_NEXT_MSG,
4851         NULL);
4852     DEBUG_PRINT_HIGH("\n Close the driver instance");
4853     close(driver_context.video_driver_fd);
4854
4855 #if BITSTREAM_LOG
4856     fclose (outputBufferFile1);
4857 #endif
4858 #ifdef _ANDROID_
4859     //for (i=0; i<m_out_buf_count; i++ )
4860     {
4861        // Clear the strong reference
4862       m_heap_ptr.clear();
4863     }
4864 #endif // _ANDROID_
4865   DEBUG_PRINT_HIGH("\n omx_vdec::component_deinit() complete");
4866   return OMX_ErrorNone;
4867 }
4868
4869 /* ======================================================================
4870 FUNCTION
4871   omx_vdec::UseEGLImage
4872
4873 DESCRIPTION
4874   OMX Use EGL Image method implementation <TBD>.
4875
4876 PARAMETERS
4877   <TBD>.
4878
4879 RETURN VALUE
4880   Not Implemented error.
4881
4882 ========================================================================== */
4883 OMX_ERRORTYPE  omx_vdec::use_EGL_image(OMX_IN OMX_HANDLETYPE                hComp,
4884                                           OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
4885                                           OMX_IN OMX_U32                        port,
4886                                           OMX_IN OMX_PTR                     appData,
4887                                           OMX_IN void*                      eglImage)
4888 {
4889     DEBUG_PRINT_ERROR("Error : use_EGL_image:  Not Implemented \n");
4890     return OMX_ErrorNotImplemented;
4891 }
4892
4893 /* ======================================================================
4894 FUNCTION
4895   omx_vdec::ComponentRoleEnum
4896
4897 DESCRIPTION
4898   OMX Component Role Enum method implementation.
4899
4900 PARAMETERS
4901   <TBD>.
4902
4903 RETURN VALUE
4904   OMX Error None if everything is successful.
4905 ========================================================================== */
4906 OMX_ERRORTYPE  omx_vdec::component_role_enum(OMX_IN OMX_HANDLETYPE hComp,
4907                                                 OMX_OUT OMX_U8*        role,
4908                                                 OMX_IN OMX_U32        index)
4909 {
4910   OMX_ERRORTYPE eRet = OMX_ErrorNone;
4911
4912   if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.mpeg4",OMX_MAX_STRINGNAME_SIZE))
4913   {
4914     if((0 == index) && role)
4915     {
4916       strncpy((char *)role, "video_decoder.mpeg4",OMX_MAX_STRINGNAME_SIZE);
4917       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
4918     }
4919     else
4920     {
4921       eRet = OMX_ErrorNoMore;
4922     }
4923   }
4924   else if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.h263",OMX_MAX_STRINGNAME_SIZE))
4925   {
4926     if((0 == index) && role)
4927     {
4928       strncpy((char *)role, "video_decoder.h263",OMX_MAX_STRINGNAME_SIZE);
4929       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
4930     }
4931     else
4932     {
4933       DEBUG_PRINT_LOW("\n No more roles \n");
4934       eRet = OMX_ErrorNoMore;
4935     }
4936   }
4937   else if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.avc",OMX_MAX_STRINGNAME_SIZE))
4938   {
4939     if((0 == index) && role)
4940     {
4941       strncpy((char *)role, "video_decoder.avc",OMX_MAX_STRINGNAME_SIZE);
4942       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
4943     }
4944     else
4945     {
4946       DEBUG_PRINT_LOW("\n No more roles \n");
4947       eRet = OMX_ErrorNoMore;
4948     }
4949   }
4950   else if(!strncmp(driver_context.kind, "OMX.qcom.video.decoder.vc1",OMX_MAX_STRINGNAME_SIZE))
4951   {
4952     if((0 == index) && role)
4953     {
4954       strncpy((char *)role, "video_decoder.vc1",OMX_MAX_STRINGNAME_SIZE);
4955       DEBUG_PRINT_LOW("component_role_enum: role %s\n",role);
4956     }
4957     else
4958     {
4959       DEBUG_PRINT_LOW("\n No more roles \n");
4960       eRet = OMX_ErrorNoMore;
4961     }
4962   }
4963   else
4964   {
4965     DEBUG_PRINT_ERROR("\nERROR:Querying Role on Unknown Component\n");
4966     eRet = OMX_ErrorInvalidComponentName;
4967   }
4968   return eRet;
4969 }
4970
4971
4972
4973
4974 /* ======================================================================
4975 FUNCTION
4976   omx_vdec::AllocateDone
4977
4978 DESCRIPTION
4979   Checks if entire buffer pool is allocated by IL Client or not.
4980   Need this to move to IDLE state.
4981
4982 PARAMETERS
4983   None.
4984
4985 RETURN VALUE
4986   true/false.
4987
4988 ========================================================================== */
4989 bool omx_vdec::allocate_done(void)
4990 {
4991   bool bRet = false;
4992   bool bRet_In = false;
4993   bool bRet_Out = false;
4994
4995   bRet_In = allocate_input_done();
4996   bRet_Out = allocate_output_done();
4997
4998   if(bRet_In && bRet_Out)
4999   {
5000       bRet = true;
5001   }
5002
5003   return bRet;
5004 }
5005 /* ======================================================================
5006 FUNCTION
5007   omx_vdec::AllocateInputDone
5008
5009 DESCRIPTION
5010   Checks if I/P buffer pool is allocated by IL Client or not.
5011
5012 PARAMETERS
5013   None.
5014
5015 RETURN VALUE
5016   true/false.
5017
5018 ========================================================================== */
5019 bool omx_vdec::allocate_input_done(void)
5020 {
5021   bool bRet = false;
5022   unsigned i=0;
5023
5024   if (m_inp_mem_ptr == NULL)
5025   {
5026       return bRet;
5027   }
5028   if(m_inp_mem_ptr )
5029   {
5030     for(;i<m_inp_buf_count;i++)
5031     {
5032       if(BITMASK_ABSENT(&m_inp_bm_count,i))
5033       {
5034         break;
5035       }
5036     }
5037   }
5038   if(i==m_inp_buf_count)
5039   {
5040     bRet = true;
5041     DEBUG_PRINT_HIGH("\n Allocate done for all i/p buffers");
5042   }
5043   if(i==m_inp_buf_count && m_inp_bEnabled)
5044   {
5045      m_inp_bPopulated = OMX_TRUE;
5046   }
5047   return bRet;
5048 }
5049 /* ======================================================================
5050 FUNCTION
5051   omx_vdec::AllocateOutputDone
5052
5053 DESCRIPTION
5054   Checks if entire O/P buffer pool is allocated by IL Client or not.
5055
5056 PARAMETERS
5057   None.
5058
5059 RETURN VALUE
5060   true/false.
5061
5062 ========================================================================== */
5063 bool omx_vdec::allocate_output_done(void)
5064 {
5065   bool bRet = false;
5066   unsigned j=0;
5067
5068   if (m_out_mem_ptr == NULL)
5069   {
5070       return bRet;
5071   }
5072
5073   if(m_out_mem_ptr )
5074   {
5075     for(;j<m_out_buf_count;j++)
5076     {
5077       if(BITMASK_ABSENT(&m_out_bm_count,j))
5078       {
5079         break;
5080       }
5081     }
5082   }
5083
5084   if(j==m_out_buf_count)
5085   {
5086     bRet = true;
5087     DEBUG_PRINT_HIGH("\n Allocate done for all o/p buffers");
5088   }
5089
5090   if(j==m_out_buf_count && m_out_bEnabled)
5091   {
5092      m_out_bPopulated = OMX_TRUE;
5093   }
5094   return bRet;
5095 }
5096
5097 /* ======================================================================
5098 FUNCTION
5099   omx_vdec::ReleaseDone
5100
5101 DESCRIPTION
5102   Checks if IL client has released all the buffers.
5103
5104 PARAMETERS
5105   None.
5106
5107 RETURN VALUE
5108   true/false
5109
5110 ========================================================================== */
5111 bool omx_vdec::release_done(void)
5112 {
5113   bool bRet = false;
5114
5115   if(release_input_done())
5116   {
5117     if(release_output_done())
5118     {
5119         bRet = true;
5120     }
5121   }
5122   return bRet;
5123 }
5124
5125
5126 /* ======================================================================
5127 FUNCTION
5128   omx_vdec::ReleaseOutputDone
5129
5130 DESCRIPTION
5131   Checks if IL client has released all the buffers.
5132
5133 PARAMETERS
5134   None.
5135
5136 RETURN VALUE
5137   true/false
5138
5139 ========================================================================== */
5140 bool omx_vdec::release_output_done(void)
5141 {
5142   bool bRet = false;
5143   unsigned i=0,j=0;
5144
5145   DEBUG_PRINT_LOW("\n Value of m_out_mem_ptr %p",m_inp_mem_ptr);
5146   if(m_out_mem_ptr)
5147   {
5148       for(;j<m_out_buf_count;j++)
5149       {
5150         if(BITMASK_PRESENT(&m_out_bm_count,j))
5151         {
5152           break;
5153         }
5154       }
5155     if(j==m_out_buf_count)
5156     {
5157       m_out_bm_count = 0;
5158       bRet = true;
5159     }
5160   }
5161   else
5162   {
5163     m_out_bm_count = 0;
5164     bRet = true;
5165   }
5166   return bRet;
5167 }
5168 /* ======================================================================
5169 FUNCTION
5170   omx_vdec::ReleaseInputDone
5171
5172 DESCRIPTION
5173   Checks if IL client has released all the buffers.
5174
5175 PARAMETERS
5176   None.
5177
5178 RETURN VALUE
5179   true/false
5180
5181 ========================================================================== */
5182 bool omx_vdec::release_input_done(void)
5183 {
5184   bool bRet = false;
5185   unsigned i=0,j=0;
5186
5187   DEBUG_PRINT_LOW("\n Value of m_inp_mem_ptr %p",m_inp_mem_ptr);
5188   if(m_inp_mem_ptr)
5189   {
5190       for(;j<m_inp_buf_count;j++)
5191       {
5192         if( BITMASK_PRESENT(&m_inp_bm_count,j))
5193         {
5194           break;
5195         }
5196       }
5197     if(j==m_inp_buf_count)
5198     {
5199       bRet = true;
5200     }
5201   }
5202   else
5203   {
5204     bRet = true;
5205   }
5206   return bRet;
5207 }
5208
5209 /* ======================================================================
5210 FUNCTION
5211   omx_vdec::omx_vdec_check_port_settings
5212
5213 DESCRIPTION
5214   Parse meta data to check the height and width param
5215   Check the level and profile
5216
5217 PARAMETERS
5218   None.
5219
5220 RETURN VALUE
5221   OMX_ErrorNone, if profile and level are supported
5222   OMX_ErrorUnsupportedSetting, if profile and level are not supported
5223 ========================================================================== */
5224 OMX_ERRORTYPE omx_vdec::omx_vdec_check_port_settings(bool *port_setting_changed)
5225 {
5226     struct vdec_ioctl_msg ioctl_msg;
5227     unsigned int alignment = 0,buffer_size = 0;
5228     OMX_ERRORTYPE eRet = OMX_ErrorNone;
5229
5230     *port_setting_changed = false;
5231     ioctl_msg.inputparam = NULL;
5232     ioctl_msg.outputparam = &driver_context.video_resoultion;
5233     if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_GET_PICRES,&ioctl_msg))
5234     {
5235       DEBUG_PRINT_ERROR("\n Error in VDEC_IOCTL_GET_PICRES in port_setting");
5236       return OMX_ErrorHardware;
5237     }
5238
5239     ioctl_msg.inputparam = NULL;
5240     ioctl_msg.outputparam = &driver_context.output_buffer;
5241     if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_GET_BUFFER_REQ,
5242                &ioctl_msg))
5243     {
5244       DEBUG_PRINT_ERROR("\n Error in VDEC_IOCTL_GET_BUFFER_REQ in port_setting");
5245       return OMX_ErrorHardware;
5246     }
5247     DEBUG_PRINT_HIGH("\n Queried Dimensions H=%d W=%d Act H=%d W=%d",
5248                        driver_context.video_resoultion.frame_height,
5249                        driver_context.video_resoultion.frame_width,
5250                        m_height,m_width);
5251     DEBUG_PRINT_HIGH("\n Queried Buffer ACnt=%d BSiz=%d Act Acnt=%d Bsiz=%d",
5252                        driver_context.output_buffer.actualcount,
5253                        driver_context.output_buffer.buffer_size,
5254                        m_out_buf_count,m_out_buf_size);
5255
5256     DEBUG_PRINT_HIGH("\n Queried stride cuur Str=%d cur scan=%d Act str=%d act scan =%d",
5257                        driver_context.video_resoultion.stride,driver_context.video_resoultion.scan_lines,
5258                        stride,scan_lines);
5259
5260
5261     if(driver_context.video_resoultion.frame_height != m_height ||
5262        driver_context.video_resoultion.frame_width != m_width ||
5263        driver_context.video_resoultion.scan_lines != scan_lines ||
5264        driver_context.video_resoultion.stride != stride ||
5265        driver_context.output_buffer.actualcount != m_out_buf_count ||
5266        driver_context.output_buffer.buffer_size > m_out_buf_size)
5267     {
5268       *port_setting_changed = true;
5269       ioctl_msg.inputparam = &driver_context.output_buffer;
5270       ioctl_msg.outputparam = NULL;
5271
5272       if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_BUFFER_REQ,
5273                  &ioctl_msg))
5274       {
5275          DEBUG_PRINT_ERROR("\n Error in VDEC_IOCTL_GET_BUFFER_REQ in port_setting");
5276          return OMX_ErrorHardware;
5277       }
5278       m_out_buf_size_recon = driver_context.output_buffer.buffer_size;
5279       m_out_buf_count_recon = driver_context.output_buffer.actualcount;
5280       m_out_buf_count_min_recon = driver_context.output_buffer.mincount;
5281
5282       alignment = driver_context.output_buffer.alignment;
5283       buffer_size = driver_context.output_buffer.buffer_size;
5284       m_out_buf_size_recon =
5285         ((buffer_size + alignment - 1) & (~(alignment - 1)));
5286       m_crop_dy = m_height      = driver_context.video_resoultion.frame_height;
5287       m_crop_dx = m_width       = driver_context.video_resoultion.frame_width;
5288       scan_lines = driver_context.video_resoultion.scan_lines;
5289       stride = driver_context.video_resoultion.stride;
5290       m_port_height             = m_height;
5291       m_port_width              = m_width;
5292     }
5293
5294     return eRet;
5295 }
5296
5297
5298 /* ======================================================================
5299 FUNCTION
5300   omx_vdec::omx_vdec_validate_port_param
5301
5302 DESCRIPTION
5303   Get the PMEM area from video decoder
5304
5305 PARAMETERS
5306   None.
5307
5308 RETURN VALUE
5309   None
5310 ========================================================================== */
5311 OMX_ERRORTYPE omx_vdec::omx_vdec_validate_port_param(int height, int width)
5312 {
5313     OMX_ERRORTYPE ret = OMX_ErrorNone;
5314     long hxw = height*width;
5315     long lmt_hxw = 0;
5316
5317     return ret;
5318 }
5319
5320 static FILE * outputBufferFile = NULL;
5321
5322 OMX_ERRORTYPE omx_vdec::fill_buffer_done(OMX_HANDLETYPE hComp,
5323                                OMX_BUFFERHEADERTYPE * buffer)
5324 {
5325   OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO *pPMEMInfo = NULL;
5326
5327   if (buffer == NULL || ((buffer - m_out_mem_ptr) > m_out_buf_count))
5328   {
5329      return OMX_ErrorBadParameter;
5330   }
5331
5332   DEBUG_PRINT_LOW("\n fill_buffer_done: bufhdr = %p, bufhdr->pBuffer = %p",
5333       buffer, buffer->pBuffer);
5334   pending_output_buffers --;
5335
5336   if (buffer->nFlags & 0x01)
5337   {
5338     DEBUG_PRINT_LOW("\n Output EOS has been reached");
5339
5340     m_outeos_reached = 0;
5341     m_ineos_reached = 0;
5342     h264_scratch.nFilledLen = 0;
5343     nal_count = 0;
5344     look_ahead_nal = false;
5345     frame_count = 0;
5346
5347     if (m_frame_parser.mutils)
5348     {
5349       m_frame_parser.mutils->initialize_frame_checking_environment();
5350     }
5351     if (psource_frame)
5352     {
5353       m_cb.EmptyBufferDone(&m_cmp ,m_app_data,psource_frame);
5354       psource_frame = NULL;
5355     }
5356
5357     if (pdest_frame)
5358     {
5359       pdest_frame->nFilledLen = 0;
5360       m_input_free_q.insert_entry((unsigned) pdest_frame,NULL,NULL);
5361       pdest_frame = NULL;
5362     }
5363     m_frame_parser.flush();
5364   }
5365
5366   DEBUG_PRINT_LOW("\n In fill Buffer done call address %p ",buffer);
5367
5368   if (outputBufferFile == NULL)
5369   {
5370     outputBufferFile = fopen ("/data/output.yuv","wb");
5371   }
5372   if (outputBufferFile)
5373   {
5374     /*fwrite (buffer->pBuffer,1,buffer->nFilledLen,
5375                   outputBufferFile); */
5376   }
5377   /* For use buffer we need to copy the data */
5378   if (m_cb.FillBufferDone)
5379   {
5380     pPMEMInfo  = (OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO *)
5381                    ((OMX_QCOM_PLATFORM_PRIVATE_LIST *)
5382                       buffer->pPlatformPrivate)->entryList->entry;
5383     DEBUG_PRINT_LOW("\n Before FBD callback Accessed Pmeminfo %d",pPMEMInfo->pmem_fd);
5384     m_cb.FillBufferDone (hComp,m_app_data,buffer);
5385     DEBUG_PRINT_LOW("\n After Fill Buffer Done callback %d",pPMEMInfo->pmem_fd);
5386   }
5387   else
5388   {
5389     return OMX_ErrorBadParameter;
5390   }
5391
5392   return OMX_ErrorNone;
5393 }
5394
5395 OMX_ERRORTYPE omx_vdec::empty_buffer_done(OMX_HANDLETYPE         hComp,
5396                                           OMX_BUFFERHEADERTYPE* buffer)
5397 {
5398
5399     if (buffer == NULL || ((buffer - m_inp_mem_ptr) > m_inp_buf_count))
5400     {
5401        return OMX_ErrorBadParameter;
5402     }
5403
5404     DEBUG_PRINT_LOW("\n empty_buffer_done: bufhdr = %p, bufhdr->pBuffer = %p",
5405         buffer, buffer->pBuffer);
5406     pending_input_buffers--;
5407
5408     if (arbitrary_bytes)
5409     {
5410       if (pdest_frame == NULL && input_flush_progress == false)
5411       {
5412         DEBUG_PRINT_LOW("\n Push input from buffer done address of Buffer %p",buffer);
5413         pdest_frame = buffer;
5414         buffer->nFilledLen = 0;
5415         push_input_buffer (hComp);
5416       }
5417       else
5418       {
5419         DEBUG_PRINT_LOW("\n Push buffer into freeq address of Buffer %p",buffer);
5420         buffer->nFilledLen = 0;
5421         if (!m_input_free_q.insert_entry((unsigned)buffer,NULL,NULL))
5422         {
5423           DEBUG_PRINT_ERROR("\nERROR:i/p free Queue is FULL Error");
5424         }
5425       }
5426     }
5427     else if(m_cb.EmptyBufferDone)
5428     {
5429         buffer->nFilledLen = 0;
5430         m_cb.EmptyBufferDone(hComp ,m_app_data, buffer);
5431     }
5432     return OMX_ErrorNone;
5433 }
5434
5435
5436 int omx_vdec::async_message_process (void *context, void* message)
5437 {
5438   omx_vdec* omx = NULL;
5439   struct vdec_msginfo *vdec_msg = NULL;
5440   OMX_BUFFERHEADERTYPE* omxhdr = NULL;
5441   struct vdec_output_frameinfo *output_respbuf = NULL;
5442
5443   if (context == NULL || message == NULL)
5444   {
5445     DEBUG_PRINT_ERROR("\n FATAL ERROR in omx_vdec::async_message_process NULL Check");
5446     return -1;
5447   }
5448   vdec_msg = (struct vdec_msginfo *)message;
5449
5450   omx = reinterpret_cast<omx_vdec*>(context);
5451   switch (vdec_msg->msgcode)
5452   {
5453
5454   case VDEC_MSG_EVT_HW_ERROR:
5455     omx->post_event (NULL,vdec_msg->status_code,\
5456                      OMX_COMPONENT_GENERATE_HARDWARE_ERROR);
5457   break;
5458
5459   case VDEC_MSG_RESP_START_DONE:
5460     omx->post_event (NULL,vdec_msg->status_code,\
5461                      OMX_COMPONENT_GENERATE_START_DONE);
5462   break;
5463
5464   case VDEC_MSG_RESP_STOP_DONE:
5465     omx->post_event (NULL,vdec_msg->status_code,\
5466                      OMX_COMPONENT_GENERATE_STOP_DONE);
5467   break;
5468
5469   case VDEC_MSG_RESP_RESUME_DONE:
5470     omx->post_event (NULL,vdec_msg->status_code,\
5471                      OMX_COMPONENT_GENERATE_RESUME_DONE);
5472   break;
5473
5474   case VDEC_MSG_RESP_PAUSE_DONE:
5475     omx->post_event (NULL,vdec_msg->status_code,\
5476                      OMX_COMPONENT_GENERATE_PAUSE_DONE);
5477   break;
5478
5479   case VDEC_MSG_RESP_FLUSH_INPUT_DONE:
5480     omx->post_event (NULL,vdec_msg->status_code,\
5481                      OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH);
5482     break;
5483   case VDEC_MSG_RESP_FLUSH_OUTPUT_DONE:
5484     omx->post_event (NULL,vdec_msg->status_code,\
5485                      OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH);
5486     break;
5487   case VDEC_MSG_RESP_INPUT_FLUSHED:
5488   case VDEC_MSG_RESP_INPUT_BUFFER_DONE:
5489
5490     omxhdr = (OMX_BUFFERHEADERTYPE* )\
5491               vdec_msg->msgdata.input_frame_clientdata;
5492
5493
5494     if (omxhdr == NULL ||
5495        ((omxhdr - omx->m_inp_mem_ptr) > omx->m_inp_buf_count) )
5496     {
5497        omxhdr = NULL;
5498        vdec_msg->status_code = VDEC_S_EFATAL;
5499     }
5500
5501     omx->post_event ((unsigned int)omxhdr,vdec_msg->status_code,
5502                      OMX_COMPONENT_GENERATE_EBD);
5503     break;
5504   case VDEC_MSG_RESP_OUTPUT_FLUSHED:
5505   case VDEC_MSG_RESP_OUTPUT_BUFFER_DONE:
5506     omxhdr = (OMX_BUFFERHEADERTYPE*)vdec_msg->msgdata.output_frame.client_data;
5507     DEBUG_PRINT_LOW("\n Got Buffer back from Driver %p omxhdr time stamp = %d " ,omxhdr,vdec_msg->msgdata.output_frame.time_stamp);
5508
5509     if  ( (omxhdr != NULL) &&
5510          ((omxhdr - omx->m_out_mem_ptr)  < omx->m_out_buf_count) &&
5511          (omxhdr->pOutputPortPrivate != NULL) &&
5512          ( ((struct vdec_output_frameinfo *)omxhdr->pOutputPortPrivate
5513              - omx->driver_context.ptr_respbuffer) < omx->m_out_buf_count)
5514          )
5515     {
5516       if (vdec_msg->msgdata.output_frame.len <=  omxhdr->nAllocLen)
5517       {
5518         omxhdr->nFilledLen = vdec_msg->msgdata.output_frame.len;
5519         omxhdr->nOffset = vdec_msg->msgdata.output_frame.offset;
5520         omxhdr->nTimeStamp = vdec_msg->msgdata.output_frame.time_stamp;
5521         omxhdr->nFlags = (vdec_msg->msgdata.output_frame.flags & 0x01);
5522
5523         output_respbuf = (struct vdec_output_frameinfo *)\
5524                           omxhdr->pOutputPortPrivate;
5525         output_respbuf->framesize.bottom = \
5526           vdec_msg->msgdata.output_frame.framesize.bottom;
5527         output_respbuf->framesize.left = \
5528           vdec_msg->msgdata.output_frame.framesize.left;
5529         output_respbuf->framesize.right = \
5530           vdec_msg->msgdata.output_frame.framesize.right;
5531         output_respbuf->framesize.top = \
5532           vdec_msg->msgdata.output_frame.framesize.top;
5533         output_respbuf->len = vdec_msg->msgdata.output_frame.len;
5534         output_respbuf->offset = vdec_msg->msgdata.output_frame.offset;
5535         output_respbuf->time_stamp = vdec_msg->msgdata.output_frame.time_stamp;
5536         output_respbuf->flags = vdec_msg->msgdata.output_frame.flags;
5537
5538         /*Use buffer case*/
5539         if (omx->output_use_buffer)
5540         {
5541           if (vdec_msg->msgdata.output_frame.len <= omxhdr->nAllocLen)
5542           {
5543             memcpy ( omxhdr->pBuffer,
5544                      (vdec_msg->msgdata.output_frame.bufferaddr +
5545                       vdec_msg->msgdata.output_frame.offset),
5546                       vdec_msg->msgdata.output_frame.len );
5547           }
5548           else
5549           {
5550             omxhdr->nFilledLen = 0;
5551           }
5552         }
5553       }
5554       else
5555       {
5556         omxhdr->nFilledLen = 0;
5557       }
5558
5559     }
5560     else
5561     {
5562        omxhdr = NULL;
5563        vdec_msg->status_code = VDEC_S_EFATAL;
5564     }
5565
5566     DEBUG_PRINT_LOW("\n Driver returned a output Buffer status %d",
5567                        vdec_msg->status_code);
5568     omx->post_event ((unsigned int)omxhdr,vdec_msg->status_code,
5569                      OMX_COMPONENT_GENERATE_FBD);
5570     break;
5571   default:
5572     break;
5573   }
5574   return 1;
5575 }
5576
5577 OMX_ERRORTYPE omx_vdec::empty_this_buffer_proxy_arbitrary (
5578                                                    OMX_HANDLETYPE hComp,
5579                                                    OMX_BUFFERHEADERTYPE *buffer
5580                                                            )
5581 {
5582   unsigned address,p2,id;
5583   DEBUG_PRINT_LOW("\n Empty this arbitrary");
5584
5585   if (buffer == NULL)
5586   {
5587     return OMX_ErrorBadParameter;
5588   }
5589   DEBUG_PRINT_LOW("\n ETBProxyArb: bufhdr = %p, bufhdr->pBuffer = %p", buffer, buffer->pBuffer);
5590   DEBUG_PRINT_LOW("\n ETBProxyArb: nFilledLen %u, flags %d, timestamp %u",
5591         buffer->nFilledLen, buffer->nFlags, (unsigned)buffer->nTimeStamp);
5592
5593   if( input_flush_progress == true || m_ineos_reached == 1)
5594   {
5595     DEBUG_PRINT_LOW("\n Flush in progress return buffer ");
5596     m_cb.EmptyBufferDone (hComp,m_app_data,buffer);
5597     return OMX_ErrorNone;
5598   }
5599
5600   if (psource_frame == NULL)
5601   {
5602     DEBUG_PRINT_LOW("\n Set Buffer as source Buffer %p time stamp %d",buffer,buffer->nTimeStamp);
5603     psource_frame = buffer;
5604     DEBUG_PRINT_LOW("\n Try to Push One Input Buffer ");
5605     push_input_buffer (hComp);
5606   }
5607   else
5608   {
5609     DEBUG_PRINT_LOW("\n Push the source buffer into pendingq %p",buffer);
5610     if (!m_input_pending_q.insert_entry((unsigned)buffer,NULL,NULL))
5611     {
5612       return OMX_ErrorBadParameter;
5613     }
5614   }
5615
5616
5617   return OMX_ErrorNone;
5618 }
5619
5620 OMX_ERRORTYPE omx_vdec::push_input_buffer (OMX_HANDLETYPE hComp)
5621 {
5622   unsigned address,p2,id;
5623   OMX_ERRORTYPE ret = OMX_ErrorNone;
5624
5625   if (pdest_frame == NULL || psource_frame == NULL)
5626   {
5627     /*Check if we have a destination buffer*/
5628     if (pdest_frame == NULL)
5629     {
5630       DEBUG_PRINT_LOW("\n Get a Destination buffer from the queue");
5631       if (m_input_free_q.m_size && !gate_input_buffers)
5632       {
5633         m_input_free_q.pop_entry(&address,&p2,&id);
5634         pdest_frame = (OMX_BUFFERHEADERTYPE *)address;
5635         pdest_frame->nFilledLen = 0;
5636         DEBUG_PRINT_LOW("\n Address of Pmem Buffer %p",pdest_frame);
5637       }
5638     }
5639
5640     /*Check if we have a destination buffer*/
5641     if (psource_frame == NULL)
5642     {
5643       DEBUG_PRINT_LOW("\n Get a source buffer from the queue");
5644       if (m_input_pending_q.m_size && !gate_input_buffers)
5645       {
5646         m_input_pending_q.pop_entry(&address,&p2,&id);
5647         psource_frame = (OMX_BUFFERHEADERTYPE *)address;
5648         DEBUG_PRINT_LOW("\n Next source Buffer %p time stamp %d",psource_frame,
5649                 psource_frame->nTimeStamp);
5650         DEBUG_PRINT_LOW("\n Next source Buffer flag %d length %d",
5651         psource_frame->nFlags,psource_frame->nFilledLen);
5652
5653       }
5654     }
5655
5656   }
5657
5658   while ((pdest_frame != NULL) && (psource_frame != NULL)&& !gate_input_buffers)
5659   {
5660     switch (codec_type_parse)
5661     {
5662       case CODEC_TYPE_MPEG4:
5663       case CODEC_TYPE_H263:
5664         ret =  push_input_sc_codec(hComp);
5665       break;
5666       case CODEC_TYPE_H264:
5667         ret = push_input_h264(hComp);
5668       break;
5669       case CODEC_TYPE_VC1:
5670         ret = push_input_vc1(hComp);
5671       break;
5672     }
5673     if (ret != OMX_ErrorNone)
5674     {
5675       DEBUG_PRINT_ERROR("\n Pushing input Buffer Failed");
5676       omx_report_error ();
5677       break;
5678     }
5679   }
5680
5681   return ret;
5682 }
5683
5684 OMX_ERRORTYPE omx_vdec::push_input_sc_codec(OMX_HANDLETYPE hComp)
5685 {
5686   OMX_U32 partial_frame = 1;
5687   OMX_BOOL genarte_edb = OMX_TRUE,generate_eos = OMX_TRUE;
5688   unsigned address,p2,id;
5689
5690   DEBUG_PRINT_LOW("\n Start Parsing the bit stream address %p TimeStamp %d",
5691         psource_frame,psource_frame->nTimeStamp);
5692   if (m_frame_parser.parse_mpeg4_frame(psource_frame,
5693                                        pdest_frame,&partial_frame) == -1)
5694   {
5695     DEBUG_PRINT_ERROR("\n Error In Parsing Return Error");
5696     return OMX_ErrorBadParameter;
5697   }
5698
5699   if (partial_frame == 0)
5700   {
5701     DEBUG_PRINT_LOW("\n Frame size %d source %p frame count %d",
5702           pdest_frame->nFilledLen,psource_frame,frame_count);
5703
5704
5705     DEBUG_PRINT_LOW("\n TimeStamp updated %d",pdest_frame->nTimeStamp);
5706     /*First Parsed buffer will have only header Hence skip*/
5707     if (frame_count == 0)
5708     {
5709       DEBUG_PRINT_LOW("\n H263/MPEG4 Codec First Frame ");
5710       mp4h263_flags = psource_frame->nFlags;
5711       mp4h263_timestamp = psource_frame->nTimeStamp;
5712       frame_count++;
5713     }
5714     else
5715     {
5716       pdest_frame->nTimeStamp = mp4h263_timestamp;
5717       mp4h263_timestamp = psource_frame->nTimeStamp;
5718       pdest_frame->nFlags = mp4h263_flags;
5719       mp4h263_flags  = psource_frame->nFlags;
5720
5721       if(psource_frame->nFilledLen == 0)
5722       {
5723         pdest_frame->nFlags = mp4h263_flags;
5724         generate_eos = OMX_FALSE;
5725       }
5726
5727
5728       /*Push the frame to the Decoder*/
5729       if (empty_this_buffer_proxy(hComp,pdest_frame) != OMX_ErrorNone)
5730       {
5731         return OMX_ErrorBadParameter;
5732       }
5733       if(m_event_port_settings_sent)
5734       {
5735         gate_input_buffers = true;
5736         return OMX_ErrorNone;
5737       }
5738       frame_count++;
5739       pdest_frame = NULL;
5740
5741       if (m_input_free_q.m_size && !gate_input_buffers)
5742       {
5743         m_input_free_q.pop_entry(&address,&p2,&id);
5744         pdest_frame = (OMX_BUFFERHEADERTYPE *) address;
5745         pdest_frame->nFilledLen = 0;
5746       }
5747     }
5748   }
5749   else
5750   {
5751     DEBUG_PRINT_LOW("\n Not a Complete Frame %d",pdest_frame->nFilledLen);
5752     /*Check if Destination Buffer is full*/
5753     if (pdest_frame->nAllocLen ==
5754         pdest_frame->nFilledLen + pdest_frame->nOffset)
5755     {
5756       DEBUG_PRINT_ERROR("\nERROR:Frame Not found though Destination Filled");
5757       return OMX_ErrorStreamCorrupt;
5758     }
5759   }
5760
5761   if (psource_frame->nFilledLen == 0)
5762   {
5763     if ((psource_frame->nFlags & 0x01) && generate_eos)
5764     {
5765       if (pdest_frame)
5766       {
5767         pdest_frame->nTimeStamp = psource_frame->nTimeStamp;
5768         pdest_frame->nFlags = psource_frame->nFlags;
5769         DEBUG_PRINT_LOW("\n Frame Found start Decoding Size =%d TimeStamp = %x",
5770                      pdest_frame->nFilledLen,pdest_frame->nTimeStamp);
5771         DEBUG_PRINT_LOW("\n Found a frame size = %d number = %d",
5772                      pdest_frame->nFilledLen,frame_count++);
5773         /*Push the frame to the Decoder*/
5774         if (empty_this_buffer_proxy(hComp,pdest_frame) != OMX_ErrorNone)
5775         {
5776           return OMX_ErrorBadParameter;
5777         }
5778         frame_count++;
5779         pdest_frame = NULL;
5780       }
5781       else
5782       {
5783         DEBUG_PRINT_LOW("\n Last frame in else dest addr") ;
5784         genarte_edb = OMX_FALSE;
5785       }
5786    }
5787     if(genarte_edb)
5788     {
5789       DEBUG_PRINT_LOW("\n Buffer Consumed return back to client %p",psource_frame);
5790       m_cb.EmptyBufferDone (hComp,m_app_data,psource_frame);
5791       psource_frame = NULL;
5792
5793       if (m_input_pending_q.m_size)
5794       {
5795         DEBUG_PRINT_LOW("\n Pull Next source Buffer %p",psource_frame);
5796         m_input_pending_q.pop_entry(&address,&p2,&id);
5797         psource_frame = (OMX_BUFFERHEADERTYPE *) address;
5798         DEBUG_PRINT_LOW("\n Next source Buffer %p time stamp %d",psource_frame,
5799                 psource_frame->nTimeStamp);
5800         DEBUG_PRINT_LOW("\n Next source Buffer flag %d length %d",
5801         psource_frame->nFlags,psource_frame->nFilledLen);
5802       }
5803     }
5804    }
5805   return OMX_ErrorNone;
5806 }
5807
5808 OMX_ERRORTYPE omx_vdec::push_input_h264 (OMX_HANDLETYPE hComp)
5809 {
5810   OMX_U32 partial_frame = 1;
5811   unsigned address,p2,id;
5812   OMX_BOOL isNewFrame = OMX_FALSE;
5813   OMX_BOOL genarte_edb = OMX_TRUE;
5814   OMX_BOOL skip_parsing = OMX_FALSE;
5815
5816   if (h264_scratch.pBuffer == NULL)
5817   {
5818     DEBUG_PRINT_ERROR("\nERROR:H.264 Scratch Buffer not allocated");
5819     return OMX_ErrorBadParameter;
5820   }
5821   DEBUG_PRINT_LOW("\n Values of h264_scratch.nFilledLen %d look_ahead_nal %d",
5822                     h264_scratch.nFilledLen,look_ahead_nal);
5823   DEBUG_PRINT_LOW("\n pdest_frame->nFilledLen %d",pdest_frame->nFilledLen);
5824   if (h264_scratch.nFilledLen && look_ahead_nal)
5825   {
5826     look_ahead_nal = false;
5827     DEBUG_PRINT_LOW("\n Copy the previous NAL into Buffer %d ",
5828                        h264_scratch.nFilledLen);
5829     if ((pdest_frame->nAllocLen - pdest_frame->nFilledLen) >=
5830          h264_scratch.nFilledLen)
5831     {
5832       memcpy ((pdest_frame->pBuffer + pdest_frame->nFilledLen),
5833               h264_scratch.pBuffer,h264_scratch.nFilledLen);
5834       pdest_frame->nFilledLen += h264_scratch.nFilledLen;
5835       DEBUG_PRINT_LOW("\n Total filled length %d",pdest_frame->nFilledLen);
5836       h264_scratch.nFilledLen = 0;
5837     }
5838     else
5839     {
5840       DEBUG_PRINT_ERROR("\nERROR:Destination buffer overflow for H264");
5841       return OMX_ErrorBadParameter;
5842     }
5843   }
5844
5845   if(psource_frame->nFlags & 0x01)
5846   {
5847     DEBUG_PRINT_LOW("\n EOS has been reached no parsing required");
5848     skip_parsing = OMX_TRUE;
5849     if ((pdest_frame->nAllocLen - pdest_frame->nFilledLen) >=
5850          psource_frame->nFilledLen)
5851     {
5852       memcpy ((pdest_frame->pBuffer + pdest_frame->nFilledLen),
5853               (psource_frame->pBuffer+psource_frame->nOffset),
5854               psource_frame->nFilledLen);
5855       pdest_frame->nFilledLen += psource_frame->nFilledLen;
5856       DEBUG_PRINT_LOW("\n Total filled length %d",pdest_frame->nFilledLen);
5857       psource_frame->nFilledLen = 0;
5858     }
5859     else
5860     {
5861       DEBUG_PRINT_ERROR("\nERROR:Destination buffer overflow for H264");
5862       return OMX_ErrorBadParameter;
5863     }
5864   }
5865
5866   if(!skip_parsing)
5867   {
5868     if (nal_length == 0)
5869     {
5870       DEBUG_PRINT_LOW("\n NAL length Zero hence parse using start code");
5871       if (m_frame_parser.parse_mpeg4_frame(psource_frame,
5872           &h264_scratch,&partial_frame) == -1)
5873       {
5874         DEBUG_PRINT_ERROR("\n Error In Parsing Return Error");
5875         return OMX_ErrorBadParameter;
5876       }
5877     }
5878     else
5879     {
5880       DEBUG_PRINT_LOW("\n NAL length %d hence parse with NAL length %d",nal_length);
5881       if (m_frame_parser.parse_h264_nallength(psource_frame,
5882           &h264_scratch,&partial_frame) == -1)
5883       {
5884         DEBUG_PRINT_ERROR("\n Error In Parsing NAL Return Error");
5885         return OMX_ErrorBadParameter;
5886       }
5887     }
5888
5889     if (partial_frame == 0)
5890     {
5891
5892       if (nal_count == 0 && h264_scratch.nFilledLen == 0)
5893       {
5894         DEBUG_PRINT_LOW("\n First NAL with Zero Length Hence Skip");
5895         nal_count++;
5896         h264_scratch.nTimeStamp = psource_frame->nTimeStamp;
5897         h264_scratch.nFlags = psource_frame->nFlags;
5898       }
5899       else
5900       {
5901         DEBUG_PRINT_LOW("\n Length of New NAL is %d",h264_scratch.nFilledLen);
5902
5903         m_frame_parser.mutils->isNewFrame(h264_scratch.pBuffer,
5904             h264_scratch.nFilledLen,0,isNewFrame);
5905         nal_count++;
5906
5907         if (!isNewFrame)
5908         {
5909           if ( (pdest_frame->nAllocLen - pdest_frame->nFilledLen) >=
5910               h264_scratch.nFilledLen)
5911           {
5912             DEBUG_PRINT_LOW("\n Not a NewFrame Copy into Dest len %d",
5913                 h264_scratch.nFilledLen);
5914             memcpy ((pdest_frame->pBuffer + pdest_frame->nFilledLen),
5915                 h264_scratch.pBuffer,h264_scratch.nFilledLen);
5916             pdest_frame->nFilledLen += h264_scratch.nFilledLen;
5917             h264_scratch.nFilledLen = 0;
5918           }
5919           else
5920           {
5921             DEBUG_PRINT_LOW("\n Destination buffer overflow for H264");
5922             return OMX_ErrorBadParameter;
5923           }
5924         }
5925         else
5926         {
5927           look_ahead_nal = true;
5928           pdest_frame->nTimeStamp = h264_scratch.nTimeStamp;
5929           pdest_frame->nFlags = h264_scratch.nFlags;
5930           h264_scratch.nTimeStamp = psource_frame->nTimeStamp;
5931           h264_scratch.nFlags = psource_frame->nFlags;
5932
5933           DEBUG_PRINT_LOW("\n Frame Found start Decoding Size =%d TimeStamp = %x",
5934                        pdest_frame->nFilledLen,pdest_frame->nTimeStamp);
5935           DEBUG_PRINT_LOW("\n Found a frame size = %d number = %d",
5936                        pdest_frame->nFilledLen,frame_count++);
5937
5938           if (pdest_frame->nFilledLen == 0)
5939           {
5940             DEBUG_PRINT_LOW("\n Copy the Current Frame since and push it");
5941             look_ahead_nal = false;
5942             if ( (pdest_frame->nAllocLen - pdest_frame->nFilledLen) >=
5943                  h264_scratch.nFilledLen)
5944             {
5945               memcpy ((pdest_frame->pBuffer + pdest_frame->nFilledLen),
5946                       h264_scratch.pBuffer,h264_scratch.nFilledLen);
5947               pdest_frame->nFilledLen += h264_scratch.nFilledLen;
5948               h264_scratch.nFilledLen = 0;
5949             }
5950             else
5951             {
5952               DEBUG_PRINT_ERROR("\nERROR:Destination buffer overflow for H264");
5953               return OMX_ErrorBadParameter;
5954             }
5955           }
5956           else
5957           {
5958             /*Push the frame to the Decoder*/
5959             if (empty_this_buffer_proxy(hComp,pdest_frame) != OMX_ErrorNone)
5960             {
5961               return OMX_ErrorBadParameter;
5962             }
5963             if(m_event_port_settings_sent)
5964             {
5965               gate_input_buffers = true;
5966               return OMX_ErrorNone;
5967             }
5968             //frame_count++;
5969             pdest_frame = NULL;
5970             if (m_input_free_q.m_size && !gate_input_buffers)
5971             {
5972               m_input_free_q.pop_entry(&address,&p2,&id);
5973               pdest_frame = (OMX_BUFFERHEADERTYPE *) address;
5974               DEBUG_PRINT_LOW("\n Pop the next pdest_buffer %p",pdest_frame);
5975               pdest_frame->nFilledLen = 0;
5976             }
5977           }
5978         }
5979       }
5980     }
5981     else
5982     {
5983       DEBUG_PRINT_LOW("\n Not a Complete Frame %d",pdest_frame->nFilledLen);
5984       /*Check if Destination Buffer is full*/
5985       if (h264_scratch.nAllocLen ==
5986           h264_scratch.nFilledLen + h264_scratch.nOffset)
5987       {
5988         DEBUG_PRINT_ERROR("\nERROR: Frame Not found though Destination Filled");
5989         return OMX_ErrorStreamCorrupt;
5990       }
5991     }
5992   }
5993
5994   if (psource_frame->nFilledLen == 0)
5995   {
5996     DEBUG_PRINT_LOW("\n Buffer Consumed return back to client %p",psource_frame);
5997
5998     if (psource_frame->nFlags & 0x01)
5999     {
6000       if (pdest_frame)
6001       {
6002         DEBUG_PRINT_LOW("\n EOS Reached Pass Last Buffer");
6003         if ( (pdest_frame->nAllocLen - pdest_frame->nFilledLen) >=
6004              h264_scratch.nFilledLen)
6005         {
6006           memcpy ((pdest_frame->pBuffer + pdest_frame->nFilledLen),
6007                   h264_scratch.pBuffer,h264_scratch.nFilledLen);
6008           pdest_frame->nFilledLen += h264_scratch.nFilledLen;
6009           h264_scratch.nFilledLen = 0;
6010         }
6011         else
6012         {
6013           DEBUG_PRINT_ERROR("\nERROR:Destination buffer overflow for H264");
6014           return OMX_ErrorBadParameter;
6015         }
6016         pdest_frame->nTimeStamp = psource_frame->nTimeStamp;
6017         pdest_frame->nFlags = psource_frame->nFlags;
6018
6019         DEBUG_PRINT_LOW("\n Frame Found start Decoding Size =%d TimeStamp = %x",
6020                      pdest_frame->nFilledLen,pdest_frame->nTimeStamp);
6021         DEBUG_PRINT_LOW("\n Found a frame size = %d number = %d",
6022                      pdest_frame->nFilledLen,frame_count++);
6023         /*Push the frame to the Decoder*/
6024         if (empty_this_buffer_proxy(hComp,pdest_frame) != OMX_ErrorNone)
6025         {
6026           return OMX_ErrorBadParameter;
6027         }
6028           if(m_event_port_settings_sent)
6029           {
6030             gate_input_buffers = true;
6031             return OMX_ErrorNone;
6032           }
6033         frame_count++;
6034         pdest_frame = NULL;
6035       }
6036       else
6037       {
6038         DEBUG_PRINT_LOW("\n Last frame in else dest addr %p size %d",
6039                      pdest_frame,h264_scratch.nFilledLen);
6040         genarte_edb = OMX_FALSE;
6041       }
6042     }
6043     if(genarte_edb)
6044     {
6045                 m_cb.EmptyBufferDone (hComp,m_app_data,psource_frame);
6046                 psource_frame = NULL;
6047                 if (m_input_pending_q.m_size && !gate_input_buffers)
6048                 {
6049                         DEBUG_PRINT_LOW("\n Pull Next source Buffer %p",psource_frame);
6050                   m_input_pending_q.pop_entry(&address,&p2,&id);
6051                   psource_frame = (OMX_BUFFERHEADERTYPE *) address;
6052                   DEBUG_PRINT_LOW("\nNext source Buffer flag %d length %d",
6053                   psource_frame->nFlags,psource_frame->nFilledLen);
6054                 }
6055         }
6056   }
6057   return OMX_ErrorNone;
6058 }
6059
6060 OMX_ERRORTYPE omx_vdec::push_input_vc1 (OMX_HANDLETYPE hComp)
6061 {
6062     OMX_U8 *buf, *pdest;
6063     OMX_U32 partial_frame = 1;
6064     OMX_U32 buf_len, dest_len;
6065
6066     if(frame_count == 0)
6067     {
6068         DEBUG_PRINT_LOW("\nFirst i/p buffer for VC1 arbitrary bytes\n");
6069         if(!m_vendor_config.pData)
6070         {
6071             DEBUG_PRINT_LOW("\nCheck profile type in 1st source buffer\n");
6072             buf = psource_frame->pBuffer;
6073             buf_len = psource_frame->nFilledLen;
6074
6075             if ((*((OMX_U32 *) buf) & VC1_SP_MP_START_CODE_MASK) ==
6076                 VC1_SP_MP_START_CODE)
6077             {
6078                 m_vc1_profile = VC1_SP_MP_RCV;
6079             }
6080             else if(*((OMX_U32 *) buf) & VC1_AP_SEQ_START_CODE)
6081             {
6082                 m_vc1_profile = VC1_AP;
6083             }
6084             else
6085             {
6086                 DEBUG_PRINT_ERROR("\nInvalid sequence layer in first buffer\n");
6087                 return OMX_ErrorStreamCorrupt;
6088             }
6089         }
6090         else
6091         {
6092             pdest = pdest_frame->pBuffer + pdest_frame->nFilledLen +
6093                 pdest_frame->nOffset;
6094             dest_len = pdest_frame->nAllocLen - (pdest_frame->nFilledLen +
6095                 pdest_frame->nOffset);
6096
6097             if(dest_len < m_vendor_config.nDataSize)
6098             {
6099                 DEBUG_PRINT_ERROR("\nDestination buffer full\n");
6100                 return OMX_ErrorBadParameter;
6101             }
6102             else
6103             {
6104                 memcpy(pdest, m_vendor_config.pData, m_vendor_config.nDataSize);
6105                 pdest_frame->nFilledLen += m_vendor_config.nDataSize;
6106             }
6107         }
6108     }
6109
6110     switch(m_vc1_profile)
6111     {
6112         case VC1_AP:
6113             DEBUG_PRINT_LOW("\n VC1 AP, hence parse using frame start code");
6114             if (push_input_sc_codec(hComp) != OMX_ErrorNone)
6115             {
6116                 DEBUG_PRINT_ERROR("\n Error In Parsing VC1 AP start code");
6117                 return OMX_ErrorBadParameter;
6118             }
6119         break;
6120
6121         case VC1_SP_MP_RCV:
6122         default:
6123             DEBUG_PRINT_ERROR("\n Unsupported VC1 profile in ArbitraryBytes Mode\n");
6124             return OMX_ErrorBadParameter;
6125     }
6126     return OMX_ErrorNone;
6127 }
6128
6129 bool omx_vdec::register_output_buffers()
6130 {
6131   struct vdec_ioctl_msg ioctl_msg;
6132   struct vdec_setbuffer_cmd setbuffers;
6133   int i = 0;
6134   unsigned p1 =0,p2 = 0,ident = 0;
6135
6136   for(i=0;i<m_out_buf_count;i++)
6137   {
6138     setbuffers.buffer_type = VDEC_BUFFER_TYPE_OUTPUT;
6139     memcpy (&setbuffers.buffer,&driver_context.ptr_outputbuffer [i],
6140             sizeof (vdec_bufferpayload));
6141     ioctl_msg.inputparam  = &setbuffers;
6142     ioctl_msg.outputparam = NULL;
6143
6144     DEBUG_PRINT_LOW("\n Set the Output Buffer");
6145     if (ioctl (driver_context.video_driver_fd,VDEC_IOCTL_SET_BUFFER,
6146          &ioctl_msg) < 0)
6147     {
6148       DEBUG_PRINT_ERROR("\n Set output buffer failed");
6149       return false;
6150     }
6151   }
6152   if(gate_output_buffers)
6153   {
6154     /*Generate FBD for all Buffers in the FTBq*/
6155     pthread_mutex_lock(&m_lock);
6156     DEBUG_PRINT_LOW("\n Initiate Pushing Output Buffers");
6157     while (m_ftb_q.m_size)
6158     {
6159       m_ftb_q.pop_entry(&p1,&p2,&ident);
6160       if(ident == OMX_COMPONENT_GENERATE_FTB )
6161       {
6162         if (fill_this_buffer_proxy ((OMX_HANDLETYPE)p1,
6163                                     (OMX_BUFFERHEADERTYPE *)p2) != OMX_ErrorNone)
6164           {
6165              DEBUG_PRINT_ERROR("\n fill_this_buffer_proxy failure");
6166              omx_report_error ();
6167              return false;
6168           }
6169       }
6170       else if (ident == OMX_COMPONENT_GENERATE_FBD)
6171       {
6172         fill_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p1);
6173       }
6174     }
6175     gate_output_buffers = false;
6176     pthread_mutex_unlock(&m_lock);
6177   }
6178   return true;
6179 }
6180
6181 bool omx_vdec::align_pmem_buffers(int pmem_fd, OMX_U32 buffer_size,
6182                                   OMX_U32 alignment)
6183 {
6184 //TODO: figure out if this is really necessary (PMEM_ALLOCATE_ALIGNED is a
6185 // QCOM extension to pmem
6186   return true;
6187 #if 0
6188   struct pmem_allocation allocation;
6189   allocation.size = buffer_size;
6190   allocation.align = clip2(alignment);
6191   if (allocation.align < 4096)
6192   {
6193     allocation.align = 4096;
6194   }
6195   if (ioctl(pmem_fd, PMEM_ALLOCATE_ALIGNED, &allocation) < 0)
6196   {
6197     DEBUG_PRINT_ERROR("\n Aligment failed with pmem driver");
6198     return false;
6199   }
6200   return true;
6201 #endif
6202 }
6203