1 /*-------------------------------------------------------------------------- 2 Copyright (c) 2010 - 2016, The Linux Foundation. All rights reserved. 3 4 Redistribution and use in source and binary forms, with or without 5 modification, are permitted provided that the following conditions 6 are met: 7 8 * Redistributions of source code must retain the above copyright 9 notice, this list of conditions and the following disclaimer. 10 * Redistributions in binary form must reproduce the above 11 copyright notice, this list of conditions and the following 12 disclaimer in the documentation and/or other materials provided 13 with the distribution. 14 * Neither the name of The Linux Foundation nor the names of its 15 contributors may be used to endorse or promote products derived 16 from this software without specific prior written permission. 17 18 THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 19 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 21 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 22 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 25 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 26 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 27 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 28 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 --------------------------------------------------------------------------*/ 30 #ifndef __OMX_VDEC_H__ 31 #define __OMX_VDEC_H__ 32 /*============================================================================ 33 O p e n M A X Component 34 Video Decoder 35 36 *//** @file comx_vdec.h 37 This module contains the class definition for openMAX decoder component. 38 39 *//*========================================================================*/ 40 41 ////////////////////////////////////////////////////////////////////////////// 42 // Include Files 43 ////////////////////////////////////////////////////////////////////////////// 44 45 #include <stdlib.h> 46 #include <stdio.h> 47 #include <string.h> 48 #include <inttypes.h> 49 #include <cstddef> 50 #include <cutils/atomic.h> 51 #include <qdMetaData.h> 52 53 static ptrdiff_t x; 54 55 #ifdef _ANDROID_ 56 #ifdef MAX_RES_720P 57 #define LOG_TAG "OMX-VDEC-720P" 58 #elif MAX_RES_1080P 59 #define LOG_TAG "OMX-VDEC-1080P" 60 #else 61 #define LOG_TAG "OMX-VDEC" 62 #endif 63 64 #ifdef USE_ION 65 #include <linux/msm_ion.h> 66 //#include <binder/MemoryHeapIon.h> 67 //#else 68 #endif 69 #include <binder/MemoryHeapBase.h> 70 #include <ui/ANativeObjectBase.h> 71 extern "C" { 72 #include <utils/Log.h> 73 } 74 #include <linux/videodev2.h> 75 #include <poll.h> 76 #include "hevc_utils.h" 77 #define TIMEOUT 5000 78 #endif // _ANDROID_ 79 80 #if defined (_ANDROID_HONEYCOMB_) || defined (_ANDROID_ICS_) 81 #include <media/hardware/HardwareAPI.h> 82 #endif 83 84 #include <unistd.h> 85 86 #if defined (_ANDROID_ICS_) 87 #include <gralloc_priv.h> 88 #endif 89 90 #include <pthread.h> 91 #ifndef PC_DEBUG 92 #include <semaphore.h> 93 #endif 94 #include "OMX_Core.h" 95 #include "OMX_QCOMExtns.h" 96 #include "OMX_Skype_VideoExtensions.h" 97 #include "OMX_VideoExt.h" 98 #include "OMX_IndexExt.h" 99 #include "qc_omx_component.h" 100 #include <linux/msm_vidc_dec.h> 101 #include <media/msm_vidc.h> 102 #include "frameparser.h" 103 #ifdef MAX_RES_1080P 104 #include "mp4_utils.h" 105 #endif 106 #include "extra_data_handler.h" 107 #include "ts_parser.h" 108 #include "vidc_color_converter.h" 109 #include "vidc_debug.h" 110 #ifdef _ANDROID_ 111 #include <cutils/properties.h> 112 #else 113 #define PROPERTY_VALUE_MAX 92 114 #endif 115 extern "C" { 116 OMX_API void * get_omx_component_factory_fn(void); 117 } 118 119 #ifdef _ANDROID_ 120 using namespace android; 121 #ifdef USE_ION 122 class VideoHeap : public MemoryHeapBase 123 { 124 public: 125 VideoHeap(int devicefd, size_t size, void* base,ion_user_handle_t handle,int mapfd); ~VideoHeap()126 virtual ~VideoHeap() {} 127 private: 128 int m_ion_device_fd; 129 ion_user_handle_t m_ion_handle; 130 }; 131 #else 132 // local pmem heap object 133 class VideoHeap : public MemoryHeapBase 134 { 135 public: 136 VideoHeap(int fd, size_t size, void* base); ~VideoHeap()137 virtual ~VideoHeap() {} 138 }; 139 #endif 140 #endif // _ANDROID_ 141 ////////////////////////////////////////////////////////////////////////////// 142 // Module specific globals 143 ////////////////////////////////////////////////////////////////////////////// 144 #define OMX_SPEC_VERSION 0x00000101 145 146 147 ////////////////////////////////////////////////////////////////////////////// 148 // Macros 149 ////////////////////////////////////////////////////////////////////////////// 150 #define PrintFrameHdr(bufHdr) DEBUG_PRINT("bufHdr %x buf %x size %d TS %d\n",\ 151 (unsigned) bufHdr,\ 152 (unsigned)((OMX_BUFFERHEADERTYPE *)bufHdr)->pBuffer,\ 153 (unsigned)((OMX_BUFFERHEADERTYPE *)bufHdr)->nFilledLen,\ 154 (unsigned)((OMX_BUFFERHEADERTYPE *)bufHdr)->nTimeStamp) 155 156 // BitMask Management logic 157 #define BITS_PER_INDEX 64 158 #define BITMASK_SIZE(mIndex) (((mIndex) + BITS_PER_INDEX - 1)/BITS_PER_INDEX) 159 #define BITMASK_OFFSET(mIndex) ((mIndex)/BITS_PER_INDEX) 160 #define BITMASK_FLAG(mIndex) ((uint64_t)1 << ((mIndex) % BITS_PER_INDEX)) 161 #define BITMASK_CLEAR(mArray,mIndex) (mArray)[BITMASK_OFFSET(mIndex)] \ 162 &= ~(BITMASK_FLAG(mIndex)) 163 #define BITMASK_SET(mArray,mIndex) (mArray)[BITMASK_OFFSET(mIndex)] \ 164 |= BITMASK_FLAG(mIndex) 165 #define BITMASK_PRESENT(mArray,mIndex) ((mArray)[BITMASK_OFFSET(mIndex)] \ 166 & BITMASK_FLAG(mIndex)) 167 #define BITMASK_ABSENT(mArray,mIndex) (((mArray)[BITMASK_OFFSET(mIndex)] \ 168 & BITMASK_FLAG(mIndex)) == 0x0) 169 #define BITMASK_PRESENT(mArray,mIndex) ((mArray)[BITMASK_OFFSET(mIndex)] \ 170 & BITMASK_FLAG(mIndex)) 171 #define BITMASK_ABSENT(mArray,mIndex) (((mArray)[BITMASK_OFFSET(mIndex)] \ 172 & BITMASK_FLAG(mIndex)) == 0x0) 173 174 #define OMX_CORE_CONTROL_CMDQ_SIZE 100 175 #define OMX_CORE_QCIF_HEIGHT 144 176 #define OMX_CORE_QCIF_WIDTH 176 177 #define OMX_CORE_VGA_HEIGHT 480 178 #define OMX_CORE_VGA_WIDTH 640 179 #define OMX_CORE_WVGA_HEIGHT 480 180 #define OMX_CORE_WVGA_WIDTH 800 181 182 #define DESC_BUFFER_SIZE (8192 * 16) 183 184 #ifdef _ANDROID_ 185 #define MAX_NUM_INPUT_OUTPUT_BUFFERS 64 186 #endif 187 188 #define OMX_FRAMEINFO_EXTRADATA 0x00010000 189 #define OMX_INTERLACE_EXTRADATA 0x00020000 190 #define OMX_TIMEINFO_EXTRADATA 0x00040000 191 #define OMX_PORTDEF_EXTRADATA 0x00080000 192 #define OMX_EXTNUSER_EXTRADATA 0x00100000 193 #define OMX_FRAMEDIMENSION_EXTRADATA 0x00200000 194 #define OMX_FRAMEPACK_EXTRADATA 0x00400000 195 #define OMX_QP_EXTRADATA 0x00800000 196 #define OMX_BITSINFO_EXTRADATA 0x01000000 197 #define OMX_VQZIPSEI_EXTRADATA 0x02000000 198 199 #define OMX_VUI_DISPLAY_INFO_EXTRADATA 0x08000000 200 #define OMX_MPEG2_SEQDISP_INFO_EXTRADATA 0x10000000 201 #define OMX_VPX_COLORSPACE_INFO_EXTRADATA 0x20000000 202 #define OMX_VC1_SEQDISP_INFO_EXTRADATA 0x40000000 203 #define OMX_DISPLAY_INFO_EXTRADATA 0x80000000 204 #define DRIVER_EXTRADATA_MASK 0x0000FFFF 205 206 #define OMX_INTERLACE_EXTRADATA_SIZE ((sizeof(OMX_OTHER_EXTRADATATYPE) +\ 207 sizeof(OMX_STREAMINTERLACEFORMAT) + 3)&(~3)) 208 #define OMX_FRAMEINFO_EXTRADATA_SIZE ((sizeof(OMX_OTHER_EXTRADATATYPE) +\ 209 sizeof(OMX_QCOM_EXTRADATA_FRAMEINFO) + 3)&(~3)) 210 #define OMX_PORTDEF_EXTRADATA_SIZE ((sizeof(OMX_OTHER_EXTRADATATYPE) +\ 211 sizeof(OMX_PARAM_PORTDEFINITIONTYPE) + 3)&(~3)) 212 #define OMX_FRAMEDIMENSION_EXTRADATA_SIZE (sizeof(OMX_OTHER_EXTRADATATYPE) +\ 213 sizeof(OMX_QCOM_EXTRADATA_FRAMEDIMENSION) + 3)&(~3) 214 #define OMX_FRAMEPACK_EXTRADATA_SIZE ((sizeof(OMX_OTHER_EXTRADATATYPE) +\ 215 sizeof(OMX_QCOM_FRAME_PACK_ARRANGEMENT) + 3)&(~3)) 216 #define OMX_QP_EXTRADATA_SIZE ((sizeof(OMX_OTHER_EXTRADATATYPE) +\ 217 sizeof(OMX_QCOM_EXTRADATA_QP) + 3)&(~3)) 218 #define OMX_BITSINFO_EXTRADATA_SIZE ((sizeof(OMX_OTHER_EXTRADATATYPE) +\ 219 sizeof(OMX_QCOM_EXTRADATA_BITS_INFO) + 3)&(~3)) 220 #define OMX_VQZIPSEI_EXTRADATA_SIZE ((sizeof(OMX_OTHER_EXTRADATATYPE) +\ 221 sizeof(OMX_QCOM_EXTRADATA_VQZIPSEI) + 3)&(~3)) 222 #define OMX_USERDATA_EXTRADATA_SIZE ((sizeof(OMX_OTHER_EXTRADATATYPE) +\ 223 + 3)&(~3)) 224 225 // Define next macro with required values to enable default extradata, 226 // VDEC_EXTRADATA_MB_ERROR_MAP 227 // OMX_INTERLACE_EXTRADATA 228 // OMX_FRAMEINFO_EXTRADATA 229 // OMX_TIMEINFO_EXTRADATA 230 231 //#define DEFAULT_EXTRADATA (OMX_FRAMEINFO_EXTRADATA|OMX_INTERLACE_EXTRADATA) 232 233 enum port_indexes { 234 OMX_CORE_INPUT_PORT_INDEX =0, 235 OMX_CORE_OUTPUT_PORT_INDEX =1 236 }; 237 enum vidc_perf_level { 238 VIDC_SVS = 0, 239 VIDC_NOMINAL = 1, 240 VIDC_TURBO = 2 241 }; 242 #ifdef USE_ION 243 struct vdec_ion { 244 int ion_device_fd; 245 struct ion_fd_data fd_ion_data; 246 struct ion_allocation_data ion_alloc_data; 247 }; 248 #endif 249 250 #ifdef _MSM8974_ 251 struct extradata_buffer_info { 252 unsigned long buffer_size; 253 char* uaddr; 254 int count; 255 int size; 256 #ifdef USE_ION 257 struct vdec_ion ion; 258 #endif 259 }; 260 #endif 261 262 struct video_driver_context { 263 int video_driver_fd; 264 enum vdec_codec decoder_format; 265 enum vdec_output_fromat output_format; 266 enum vdec_interlaced_format interlace; 267 enum vdec_output_order picture_order; 268 struct vdec_framesize frame_size; 269 struct vdec_picsize video_resolution; 270 struct vdec_allocatorproperty ip_buf; 271 struct vdec_allocatorproperty op_buf; 272 struct vdec_bufferpayload *ptr_inputbuffer; 273 struct vdec_bufferpayload *ptr_outputbuffer; 274 struct vdec_output_frameinfo *ptr_respbuffer; 275 #ifdef USE_ION 276 struct vdec_ion *ip_buf_ion_info; 277 struct vdec_ion *op_buf_ion_info; 278 struct vdec_ion h264_mv; 279 struct vdec_ion meta_buffer; 280 struct vdec_ion meta_buffer_iommu; 281 #endif 282 struct vdec_framerate frame_rate; 283 unsigned extradata; 284 bool timestamp_adjust; 285 char kind[128]; 286 bool idr_only_decoding; 287 unsigned disable_dmx; 288 #ifdef _MSM8974_ 289 struct extradata_buffer_info extradata_info; 290 int num_planes; 291 #endif 292 }; 293 294 struct video_decoder_capability { 295 unsigned int min_width; 296 unsigned int max_width; 297 unsigned int min_height; 298 unsigned int max_height; 299 }; 300 301 struct debug_cap { 302 bool in_buffer_log; 303 bool out_buffer_log; 304 bool out_meta_buffer_log; 305 char infile_name[PROPERTY_VALUE_MAX + 36]; 306 char outfile_name[PROPERTY_VALUE_MAX + 36]; 307 char out_ymetafile_name[PROPERTY_VALUE_MAX + 36]; 308 char out_uvmetafile_name[PROPERTY_VALUE_MAX + 36]; 309 char log_loc[PROPERTY_VALUE_MAX]; 310 FILE *infile; 311 FILE *outfile; 312 FILE *out_ymeta_file; 313 FILE *out_uvmeta_file; 314 }; 315 316 struct dynamic_buf_list { 317 long fd; 318 long dup_fd; 319 OMX_U32 offset; 320 OMX_U32 ref_count; 321 void *buffaddr; 322 long mapped_size; 323 }; 324 325 // OMX video decoder class 326 class omx_vdec: public qc_omx_component 327 { 328 329 public: 330 omx_vdec(); // constructor 331 virtual ~omx_vdec(); // destructor 332 333 static int async_message_process (void *context, void* message); 334 static void process_event_cb(void *ctxt,unsigned char id); 335 336 OMX_ERRORTYPE allocate_buffer( 337 OMX_HANDLETYPE hComp, 338 OMX_BUFFERHEADERTYPE **bufferHdr, 339 OMX_U32 port, 340 OMX_PTR appData, 341 OMX_U32 bytes 342 ); 343 344 345 OMX_ERRORTYPE component_deinit(OMX_HANDLETYPE hComp); 346 347 OMX_ERRORTYPE component_init(OMX_STRING role); 348 349 OMX_ERRORTYPE component_role_enum( 350 OMX_HANDLETYPE hComp, 351 OMX_U8 *role, 352 OMX_U32 index 353 ); 354 355 OMX_ERRORTYPE component_tunnel_request( 356 OMX_HANDLETYPE hComp, 357 OMX_U32 port, 358 OMX_HANDLETYPE peerComponent, 359 OMX_U32 peerPort, 360 OMX_TUNNELSETUPTYPE *tunnelSetup 361 ); 362 363 OMX_ERRORTYPE empty_this_buffer( 364 OMX_HANDLETYPE hComp, 365 OMX_BUFFERHEADERTYPE *buffer 366 ); 367 368 369 370 OMX_ERRORTYPE fill_this_buffer( 371 OMX_HANDLETYPE hComp, 372 OMX_BUFFERHEADERTYPE *buffer 373 ); 374 375 376 OMX_ERRORTYPE free_buffer( 377 OMX_HANDLETYPE hComp, 378 OMX_U32 port, 379 OMX_BUFFERHEADERTYPE *buffer 380 ); 381 382 OMX_ERRORTYPE get_component_version( 383 OMX_HANDLETYPE hComp, 384 OMX_STRING componentName, 385 OMX_VERSIONTYPE *componentVersion, 386 OMX_VERSIONTYPE *specVersion, 387 OMX_UUIDTYPE *componentUUID 388 ); 389 390 OMX_ERRORTYPE get_config( 391 OMX_HANDLETYPE hComp, 392 OMX_INDEXTYPE configIndex, 393 OMX_PTR configData 394 ); 395 396 OMX_ERRORTYPE get_extension_index( 397 OMX_HANDLETYPE hComp, 398 OMX_STRING paramName, 399 OMX_INDEXTYPE *indexType 400 ); 401 402 OMX_ERRORTYPE get_parameter(OMX_HANDLETYPE hComp, 403 OMX_INDEXTYPE paramIndex, 404 OMX_PTR paramData); 405 406 OMX_ERRORTYPE get_state(OMX_HANDLETYPE hComp, 407 OMX_STATETYPE *state); 408 409 410 411 OMX_ERRORTYPE send_command(OMX_HANDLETYPE hComp, 412 OMX_COMMANDTYPE cmd, 413 OMX_U32 param1, 414 OMX_PTR cmdData); 415 416 417 OMX_ERRORTYPE set_callbacks(OMX_HANDLETYPE hComp, 418 OMX_CALLBACKTYPE *callbacks, 419 OMX_PTR appData); 420 421 OMX_ERRORTYPE set_config(OMX_HANDLETYPE hComp, 422 OMX_INDEXTYPE configIndex, 423 OMX_PTR configData); 424 425 OMX_ERRORTYPE set_parameter(OMX_HANDLETYPE hComp, 426 OMX_INDEXTYPE paramIndex, 427 OMX_PTR paramData); 428 429 OMX_ERRORTYPE use_buffer(OMX_HANDLETYPE hComp, 430 OMX_BUFFERHEADERTYPE **bufferHdr, 431 OMX_U32 port, 432 OMX_PTR appData, 433 OMX_U32 bytes, 434 OMX_U8 *buffer); 435 436 OMX_ERRORTYPE use_input_heap_buffers( 437 OMX_HANDLETYPE hComp, 438 OMX_BUFFERHEADERTYPE** bufferHdr, 439 OMX_U32 port, 440 OMX_PTR appData, 441 OMX_U32 bytes, 442 OMX_U8* buffer); 443 444 OMX_ERRORTYPE use_EGL_image(OMX_HANDLETYPE hComp, 445 OMX_BUFFERHEADERTYPE **bufferHdr, 446 OMX_U32 port, 447 OMX_PTR appData, 448 void * eglImage); 449 void complete_pending_buffer_done_cbs(); 450 struct video_driver_context drv_ctx; 451 int m_poll_efd; 452 #ifdef _MSM8974_ 453 OMX_ERRORTYPE allocate_extradata(); 454 void free_extradata(); 455 int update_resolution(int width, int height, int stride, int scan_lines); 456 OMX_ERRORTYPE is_video_session_supported(); 457 #endif 458 int m_pipe_in; 459 int m_pipe_out; 460 pthread_t msg_thread_id; 461 pthread_t async_thread_id; 462 bool is_component_secure(); 463 void buf_ref_add(int nPortIndex); 464 void buf_ref_remove(); 465 OMX_ERRORTYPE set_dpb(bool is_split_mode, int dpb_color_format); 466 OMX_ERRORTYPE decide_dpb_buffer_mode(bool force_split_mode); 467 void request_perf_level(enum vidc_perf_level perf_level); 468 int dpb_bit_depth; 469 bool async_thread_force_stop; 470 volatile bool message_thread_stop; 471 472 private: 473 // Bit Positions 474 enum flags_bit_positions { 475 // Defer transition to IDLE 476 OMX_COMPONENT_IDLE_PENDING =0x1, 477 // Defer transition to LOADING 478 OMX_COMPONENT_LOADING_PENDING =0x2, 479 // First Buffer Pending 480 OMX_COMPONENT_FIRST_BUFFER_PENDING =0x3, 481 // Second Buffer Pending 482 OMX_COMPONENT_SECOND_BUFFER_PENDING =0x4, 483 // Defer transition to Enable 484 OMX_COMPONENT_INPUT_ENABLE_PENDING =0x5, 485 // Defer transition to Enable 486 OMX_COMPONENT_OUTPUT_ENABLE_PENDING =0x6, 487 // Defer transition to Disable 488 OMX_COMPONENT_INPUT_DISABLE_PENDING =0x7, 489 // Defer transition to Disable 490 OMX_COMPONENT_OUTPUT_DISABLE_PENDING =0x8, 491 //defer flush notification 492 OMX_COMPONENT_OUTPUT_FLUSH_PENDING =0x9, 493 OMX_COMPONENT_INPUT_FLUSH_PENDING =0xA, 494 OMX_COMPONENT_PAUSE_PENDING =0xB, 495 OMX_COMPONENT_EXECUTE_PENDING =0xC, 496 OMX_COMPONENT_OUTPUT_FLUSH_IN_DISABLE_PENDING =0xD, 497 OMX_COMPONENT_DISABLE_OUTPUT_DEFERRED=0xE, 498 OMX_COMPONENT_FLUSH_DEFERRED = 0xF 499 }; 500 501 // Deferred callback identifiers 502 enum { 503 //Event Callbacks from the vdec component thread context 504 OMX_COMPONENT_GENERATE_EVENT = 0x1, 505 //Buffer Done callbacks from the vdec component thread context 506 OMX_COMPONENT_GENERATE_BUFFER_DONE = 0x2, 507 //Frame Done callbacks from the vdec component thread context 508 OMX_COMPONENT_GENERATE_FRAME_DONE = 0x3, 509 //Buffer Done callbacks from the vdec component thread context 510 OMX_COMPONENT_GENERATE_FTB = 0x4, 511 //Frame Done callbacks from the vdec component thread context 512 OMX_COMPONENT_GENERATE_ETB = 0x5, 513 //Command 514 OMX_COMPONENT_GENERATE_COMMAND = 0x6, 515 //Push-Pending Buffers 516 OMX_COMPONENT_PUSH_PENDING_BUFS = 0x7, 517 // Empty Buffer Done callbacks 518 OMX_COMPONENT_GENERATE_EBD = 0x8, 519 //Flush Event Callbacks from the vdec component thread context 520 OMX_COMPONENT_GENERATE_EVENT_FLUSH = 0x9, 521 OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH = 0x0A, 522 OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH = 0x0B, 523 OMX_COMPONENT_GENERATE_FBD = 0xc, 524 OMX_COMPONENT_GENERATE_START_DONE = 0xD, 525 OMX_COMPONENT_GENERATE_PAUSE_DONE = 0xE, 526 OMX_COMPONENT_GENERATE_RESUME_DONE = 0xF, 527 OMX_COMPONENT_GENERATE_STOP_DONE = 0x10, 528 OMX_COMPONENT_GENERATE_HARDWARE_ERROR = 0x11, 529 OMX_COMPONENT_GENERATE_ETB_ARBITRARY = 0x12, 530 OMX_COMPONENT_GENERATE_PORT_RECONFIG = 0x13, 531 OMX_COMPONENT_GENERATE_EOS_DONE = 0x14, 532 OMX_COMPONENT_GENERATE_INFO_PORT_RECONFIG = 0x15, 533 OMX_COMPONENT_GENERATE_INFO_FIELD_DROPPED = 0x16, 534 OMX_COMPONENT_GENERATE_UNSUPPORTED_SETTING = 0x17, 535 OMX_COMPONENT_GENERATE_HARDWARE_OVERLOAD = 0x18, 536 OMX_COMPONENT_CLOSE_MSG = 0x19 537 }; 538 539 enum vc1_profile_type { 540 VC1_SP_MP_RCV = 1, 541 VC1_AP = 2 542 }; 543 544 #ifdef _MSM8974_ 545 enum v4l2_ports { 546 CAPTURE_PORT, 547 OUTPUT_PORT, 548 MAX_PORT 549 }; 550 #endif 551 552 struct omx_event { 553 unsigned long param1; 554 unsigned long param2; 555 unsigned long id; 556 }; 557 558 struct omx_cmd_queue { 559 omx_event m_q[OMX_CORE_CONTROL_CMDQ_SIZE]; 560 unsigned long m_read; 561 unsigned long m_write; 562 unsigned long m_size; 563 564 omx_cmd_queue(); 565 ~omx_cmd_queue(); 566 bool insert_entry(unsigned long p1, unsigned long p2, unsigned long id); 567 bool pop_entry(unsigned long *p1,unsigned long *p2, unsigned long *id); 568 // get msgtype of the first ele from the queue 569 unsigned get_q_msg_type(); 570 571 }; 572 struct v4l2_capability cap; 573 #ifdef _ANDROID_ 574 struct ts_entry { 575 OMX_TICKS timestamp; 576 bool valid; 577 }; 578 579 struct ts_arr_list { 580 ts_entry m_ts_arr_list[MAX_NUM_INPUT_OUTPUT_BUFFERS]; 581 582 ts_arr_list(); 583 ~ts_arr_list(); 584 585 bool insert_ts(OMX_TICKS ts); 586 bool pop_min_ts(OMX_TICKS &ts); 587 bool reset_ts_list(); 588 }; 589 #endif 590 591 struct desc_buffer_hdr { 592 OMX_U8 *buf_addr; 593 OMX_U32 desc_data_size; 594 }; 595 bool allocate_done(void); 596 bool allocate_input_done(void); 597 bool allocate_output_done(void); 598 599 OMX_ERRORTYPE free_input_buffer(OMX_BUFFERHEADERTYPE *bufferHdr); 600 OMX_ERRORTYPE free_input_buffer(unsigned int bufferindex, 601 OMX_BUFFERHEADERTYPE *pmem_bufferHdr); 602 OMX_ERRORTYPE free_output_buffer(OMX_BUFFERHEADERTYPE *bufferHdr); 603 void free_output_buffer_header(); 604 void free_input_buffer_header(); 605 606 OMX_ERRORTYPE allocate_input_heap_buffer(OMX_HANDLETYPE hComp, 607 OMX_BUFFERHEADERTYPE **bufferHdr, 608 OMX_U32 port, 609 OMX_PTR appData, 610 OMX_U32 bytes); 611 612 613 OMX_ERRORTYPE allocate_input_buffer(OMX_HANDLETYPE hComp, 614 OMX_BUFFERHEADERTYPE **bufferHdr, 615 OMX_U32 port, 616 OMX_PTR appData, 617 OMX_U32 bytes); 618 619 OMX_ERRORTYPE allocate_output_buffer(OMX_HANDLETYPE hComp, 620 OMX_BUFFERHEADERTYPE **bufferHdr, 621 OMX_U32 port,OMX_PTR appData, 622 OMX_U32 bytes); 623 OMX_ERRORTYPE use_output_buffer(OMX_HANDLETYPE hComp, 624 OMX_BUFFERHEADERTYPE **bufferHdr, 625 OMX_U32 port, 626 OMX_PTR appData, 627 OMX_U32 bytes, 628 OMX_U8 *buffer); 629 OMX_ERRORTYPE get_supported_profile_level(OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevelType); 630 631 OMX_ERRORTYPE allocate_desc_buffer(OMX_U32 index); 632 OMX_ERRORTYPE allocate_output_headers(); 633 bool execute_omx_flush(OMX_U32); 634 bool execute_output_flush(); 635 bool execute_input_flush(); 636 OMX_ERRORTYPE empty_buffer_done(OMX_HANDLETYPE hComp, 637 OMX_BUFFERHEADERTYPE * buffer); 638 639 OMX_ERRORTYPE fill_buffer_done(OMX_HANDLETYPE hComp, 640 OMX_BUFFERHEADERTYPE * buffer); 641 OMX_ERRORTYPE empty_this_buffer_proxy(OMX_HANDLETYPE hComp, 642 OMX_BUFFERHEADERTYPE *buffer); 643 644 OMX_ERRORTYPE empty_this_buffer_proxy_arbitrary(OMX_HANDLETYPE hComp, 645 OMX_BUFFERHEADERTYPE *buffer 646 ); 647 648 OMX_ERRORTYPE push_input_buffer (OMX_HANDLETYPE hComp); 649 OMX_ERRORTYPE push_input_sc_codec (OMX_HANDLETYPE hComp); 650 OMX_ERRORTYPE push_input_h264 (OMX_HANDLETYPE hComp); 651 OMX_ERRORTYPE push_input_hevc (OMX_HANDLETYPE hComp); 652 OMX_ERRORTYPE push_input_vc1 (OMX_HANDLETYPE hComp); 653 654 OMX_ERRORTYPE fill_this_buffer_proxy(OMX_HANDLETYPE hComp, 655 OMX_BUFFERHEADERTYPE *buffer); 656 bool release_done(); 657 658 bool release_output_done(); 659 bool release_input_done(); 660 OMX_ERRORTYPE get_buffer_req(vdec_allocatorproperty *buffer_prop); 661 OMX_ERRORTYPE set_buffer_req(vdec_allocatorproperty *buffer_prop); 662 OMX_ERRORTYPE start_port_reconfig(); 663 OMX_ERRORTYPE update_picture_resolution(); 664 int stream_off(OMX_U32 port); 665 void adjust_timestamp(OMX_S64 &act_timestamp); 666 void set_frame_rate(OMX_S64 act_timestamp); 667 void handle_extradata_secure(OMX_BUFFERHEADERTYPE *p_buf_hdr); 668 void handle_extradata(OMX_BUFFERHEADERTYPE *p_buf_hdr); 669 void convert_color_space_info(OMX_U32 primaries, OMX_U32 range, 670 OMX_U32 transfer, OMX_U32 matrix, ColorSpace_t *color_space, 671 ColorAspects *aspects); 672 void handle_color_space_info(void *data, unsigned int buf_index); 673 void set_colorspace_in_handle(ColorSpace_t color, unsigned int buf_index); 674 void print_debug_color_aspects(ColorAspects *aspects, const char *prefix); 675 void print_debug_extradata(OMX_OTHER_EXTRADATATYPE *extra); 676 #ifdef _MSM8974_ 677 void append_interlace_extradata(OMX_OTHER_EXTRADATATYPE *extra, 678 OMX_U32 interlaced_format_type, bool is_mbaff); 679 OMX_ERRORTYPE enable_extradata(OMX_U32 requested_extradata, bool is_internal, 680 bool enable = true); 681 void append_frame_info_extradata(OMX_OTHER_EXTRADATATYPE *extra, 682 OMX_U32 num_conceal_mb, 683 OMX_U32 picture_type, 684 OMX_U32 frame_rate, 685 OMX_TICKS time_stamp, 686 struct msm_vidc_panscan_window_payload *panscan_payload, 687 struct vdec_aspectratioinfo *aspect_ratio_info); 688 #else 689 void append_interlace_extradata(OMX_OTHER_EXTRADATATYPE *extra, 690 OMX_U32 interlaced_format_type, OMX_U32 buf_index); 691 OMX_ERRORTYPE enable_extradata(OMX_U32 requested_extradata, bool enable = true); 692 #endif 693 void append_frame_info_extradata(OMX_OTHER_EXTRADATATYPE *extra, 694 OMX_U32 num_conceal_mb, 695 OMX_U32 picture_type, 696 OMX_S64 timestamp, 697 OMX_U32 frame_rate, 698 struct vdec_aspectratioinfo *aspect_ratio_info); 699 void fill_aspect_ratio_info(struct vdec_aspectratioinfo *aspect_ratio_info, 700 OMX_QCOM_EXTRADATA_FRAMEINFO *frame_info); 701 void append_terminator_extradata(OMX_OTHER_EXTRADATATYPE *extra); 702 OMX_ERRORTYPE update_portdef(OMX_PARAM_PORTDEFINITIONTYPE *portDefn); 703 void append_portdef_extradata(OMX_OTHER_EXTRADATATYPE *extra); 704 void append_frame_dimension_extradata(OMX_OTHER_EXTRADATATYPE *extra); 705 void append_extn_extradata(OMX_OTHER_EXTRADATATYPE *extra, OMX_OTHER_EXTRADATATYPE *p_extn); 706 void append_user_extradata(OMX_OTHER_EXTRADATATYPE *extra, OMX_OTHER_EXTRADATATYPE *p_user); 707 void append_concealmb_extradata(OMX_OTHER_EXTRADATATYPE *extra, 708 OMX_OTHER_EXTRADATATYPE *p_concealmb, OMX_U8 *conceal_mb_data); 709 void append_framepack_extradata(OMX_OTHER_EXTRADATATYPE *extra, 710 struct msm_vidc_s3d_frame_packing_payload *s3d_frame_packing_payload); 711 void append_qp_extradata(OMX_OTHER_EXTRADATATYPE *extra, 712 struct msm_vidc_frame_qp_payload *qp_payload); 713 void append_bitsinfo_extradata(OMX_OTHER_EXTRADATATYPE *extra, 714 struct msm_vidc_frame_bits_info_payload *bits_payload); 715 void append_vqzip_extradata(OMX_OTHER_EXTRADATATYPE *extra, 716 struct msm_vidc_vqzip_sei_payload *vqzip_payload); 717 void insert_demux_addr_offset(OMX_U32 address_offset); 718 void extract_demux_addr_offsets(OMX_BUFFERHEADERTYPE *buf_hdr); 719 OMX_ERRORTYPE handle_demux_data(OMX_BUFFERHEADERTYPE *buf_hdr); 720 OMX_U32 count_MB_in_extradata(OMX_OTHER_EXTRADATATYPE *extra); 721 722 bool align_pmem_buffers(int pmem_fd, OMX_U32 buffer_size, 723 OMX_U32 alignment); 724 #ifdef USE_ION 725 int alloc_map_ion_memory(OMX_U32 buffer_size, 726 OMX_U32 alignment, struct ion_allocation_data *alloc_data, 727 struct ion_fd_data *fd_data,int flag); 728 void free_ion_memory(struct vdec_ion *buf_ion_info); 729 #endif 730 731 732 OMX_ERRORTYPE send_command_proxy(OMX_HANDLETYPE hComp, 733 OMX_COMMANDTYPE cmd, 734 OMX_U32 param1, 735 OMX_PTR cmdData); 736 bool post_event( unsigned long p1, 737 unsigned long p2, 738 unsigned long id 739 ); clip2(int x)740 inline int clip2(int x) { 741 x = x -1; 742 x = x | x >> 1; 743 x = x | x >> 2; 744 x = x | x >> 4; 745 x = x | x >> 16; 746 x = x + 1; 747 return x; 748 } 749 750 #ifdef MAX_RES_1080P 751 OMX_ERRORTYPE vdec_alloc_h264_mv(); 752 void vdec_dealloc_h264_mv(); 753 OMX_ERRORTYPE vdec_alloc_meta_buffers(); 754 void vdec_dealloc_meta_buffers(); 755 #endif 756 omx_report_error()757 inline void omx_report_error () { 758 if (m_cb.EventHandler && !m_error_propogated && m_state != OMX_StateLoaded) { 759 DEBUG_PRINT_ERROR("ERROR: Sending OMX_ErrorHardware to Client"); 760 m_error_propogated = true; 761 m_cb.EventHandler(&m_cmp,m_app_data, 762 OMX_EventError,OMX_ErrorHardware,0,NULL); 763 } 764 } 765 omx_report_unsupported_setting()766 inline void omx_report_unsupported_setting () { 767 if (m_cb.EventHandler && !m_error_propogated && m_state != OMX_StateLoaded) { 768 DEBUG_PRINT_ERROR( 769 "ERROR: Sending OMX_ErrorUnsupportedSetting to Client"); 770 m_error_propogated = true; 771 m_cb.EventHandler(&m_cmp, m_app_data, 772 OMX_EventError, OMX_ErrorUnsupportedSetting, 0, NULL); 773 } 774 } omx_report_hw_overload()775 inline void omx_report_hw_overload () { 776 if (m_cb.EventHandler && !m_error_propogated && m_state != OMX_StateLoaded) { 777 DEBUG_PRINT_ERROR( 778 "ERROR: Sending OMX_ErrorInsufficientResources to Client"); 779 m_error_propogated = true; 780 m_cb.EventHandler(&m_cmp, m_app_data, 781 OMX_EventError, OMX_ErrorInsufficientResources, 0, NULL); 782 } 783 } 784 785 #if defined (_ANDROID_HONEYCOMB_) || defined (_ANDROID_ICS_) 786 OMX_ERRORTYPE use_android_native_buffer(OMX_IN OMX_HANDLETYPE hComp, OMX_PTR data); 787 #endif 788 #if defined (_ANDROID_ICS_) 789 struct nativebuffer { 790 native_handle_t *nativehandle; 791 private_handle_t *privatehandle; 792 int inuse; 793 }; 794 nativebuffer native_buffer[MAX_NUM_INPUT_OUTPUT_BUFFERS]; 795 #endif 796 797 //************************************************************* 798 //*******************MEMBER VARIABLES ************************* 799 //************************************************************* 800 pthread_mutex_t m_lock; 801 pthread_mutex_t c_lock; 802 pthread_mutex_t buf_lock; 803 //sem to handle the minimum procesing of commands 804 sem_t m_cmd_lock; 805 sem_t m_safe_flush; 806 bool m_error_propogated; 807 // compression format 808 OMX_VIDEO_CODINGTYPE eCompressionFormat; 809 // OMX State 810 OMX_STATETYPE m_state; 811 // Application data 812 OMX_PTR m_app_data; 813 // Application callbacks 814 OMX_CALLBACKTYPE m_cb; 815 OMX_PRIORITYMGMTTYPE m_priority_mgm ; 816 OMX_PARAM_BUFFERSUPPLIERTYPE m_buffer_supplier; 817 // fill this buffer queue 818 omx_cmd_queue m_ftb_q; 819 // Command Q for rest of the events 820 omx_cmd_queue m_cmd_q; 821 omx_cmd_queue m_etb_q; 822 // Input memory pointer 823 OMX_BUFFERHEADERTYPE *m_inp_mem_ptr; 824 // Output memory pointer 825 OMX_BUFFERHEADERTYPE *m_out_mem_ptr; 826 // number of input bitstream error frame count 827 unsigned int m_inp_err_count; 828 #ifdef _ANDROID_ 829 // Timestamp list 830 ts_arr_list m_timestamp_list; 831 #endif 832 833 bool input_flush_progress; 834 bool output_flush_progress; 835 bool input_use_buffer; 836 bool output_use_buffer; 837 bool ouput_egl_buffers; 838 OMX_BOOL m_use_output_pmem; 839 OMX_BOOL m_out_mem_region_smi; 840 OMX_BOOL m_out_pvt_entry_pmem; 841 842 int pending_input_buffers; 843 int pending_output_buffers; 844 // bitmask array size for output side 845 uint64_t m_out_bm_count; 846 // bitmask array size for input side 847 uint64_t m_inp_bm_count; 848 //Input port Populated 849 OMX_BOOL m_inp_bPopulated; 850 //Output port Populated 851 OMX_BOOL m_out_bPopulated; 852 // encapsulate the waiting states. 853 uint64_t m_flags; 854 855 #ifdef _ANDROID_ 856 // Heap pointer to frame buffers 857 struct vidc_heap { 858 sp<MemoryHeapBase> video_heap_ptr; 859 }; 860 struct vidc_heap *m_heap_ptr; 861 unsigned int m_heap_count; 862 #endif //_ANDROID_ 863 // store I/P PORT state 864 OMX_BOOL m_inp_bEnabled; 865 // store O/P PORT state 866 OMX_BOOL m_out_bEnabled; 867 OMX_U32 m_in_alloc_cnt; 868 OMX_U8 m_cRole[OMX_MAX_STRINGNAME_SIZE]; 869 // Platform specific details 870 OMX_QCOM_PLATFORM_PRIVATE_LIST *m_platform_list; 871 OMX_QCOM_PLATFORM_PRIVATE_ENTRY *m_platform_entry; 872 OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO *m_pmem_info; 873 // SPS+PPS sent as part of set_config 874 OMX_VENDOR_EXTRADATATYPE m_vendor_config; 875 876 /*Variables for arbitrary Byte parsing support*/ 877 frame_parse m_frame_parser; 878 h264_stream_parser *h264_parser; 879 MP4_Utils mp4_headerparser; 880 HEVC_Utils m_hevc_utils; 881 882 omx_cmd_queue m_input_pending_q; 883 omx_cmd_queue m_input_free_q; 884 bool arbitrary_bytes; 885 OMX_BUFFERHEADERTYPE h264_scratch; 886 OMX_BUFFERHEADERTYPE *psource_frame; 887 OMX_BUFFERHEADERTYPE *pdest_frame; 888 OMX_BUFFERHEADERTYPE *m_inp_heap_ptr; 889 OMX_BUFFERHEADERTYPE **m_phdr_pmem_ptr; 890 unsigned int m_heap_inp_bm_count; 891 codec_type codec_type_parse; 892 bool first_frame_meta; 893 unsigned frame_count; 894 unsigned nal_count; 895 unsigned nal_length; 896 bool look_ahead_nal; 897 int first_frame; 898 unsigned char *first_buffer; 899 int first_frame_size; 900 unsigned char m_hwdevice_name[80]; 901 FILE *m_device_file_ptr; 902 enum vc1_profile_type m_vc1_profile; 903 OMX_S64 h264_last_au_ts; 904 OMX_U32 h264_last_au_flags; 905 OMX_U32 m_demux_offsets[8192]; 906 OMX_U32 m_demux_entries; 907 OMX_U32 m_disp_hor_size; 908 OMX_U32 m_disp_vert_size; 909 OMX_S64 prev_ts; 910 OMX_S64 prev_ts_actual; 911 bool rst_prev_ts; 912 OMX_U32 frm_int; 913 914 struct vdec_allocatorproperty op_buf_rcnfg; 915 bool in_reconfig; 916 OMX_NATIVE_WINDOWTYPE m_display_id; 917 OMX_U32 client_extradata; 918 #ifdef _ANDROID_ 919 bool m_debug_timestamp; 920 bool perf_flag; 921 OMX_U32 proc_frms, latency; 922 perf_metrics fps_metrics; 923 perf_metrics dec_time; 924 bool m_reject_avc_1080p_mp; 925 bool m_enable_android_native_buffers; 926 bool m_use_android_native_buffers; 927 bool m_debug_extradata; 928 bool m_debug_concealedmb; 929 bool m_disable_dynamic_buf_mode; 930 OMX_U32 m_conceal_color; 931 #endif 932 933 934 struct h264_mv_buffer { 935 unsigned char* buffer; 936 int size; 937 int count; 938 int pmem_fd; 939 int offset; 940 }; 941 h264_mv_buffer h264_mv_buff; 942 943 struct meta_buffer { 944 unsigned char* buffer; 945 int size; 946 int count; 947 int pmem_fd; 948 int pmem_fd_iommu; 949 int offset; 950 }; 951 meta_buffer meta_buff; 952 extra_data_handler extra_data_handle; 953 OMX_PARAM_PORTDEFINITIONTYPE m_port_def; 954 OMX_QCOM_FRAME_PACK_ARRANGEMENT m_frame_pack_arrangement; 955 omx_time_stamp_reorder time_stamp_dts; 956 desc_buffer_hdr *m_desc_buffer_ptr; 957 bool secure_mode; 958 bool allocate_native_handle; 959 bool external_meta_buffer; 960 bool external_meta_buffer_iommu; 961 OMX_QCOM_EXTRADATA_FRAMEINFO *m_extradata; 962 OMX_OTHER_EXTRADATATYPE *m_other_extradata; 963 bool codec_config_flag; 964 #ifdef _MSM8974_ 965 int capture_capability; 966 int output_capability; 967 bool streaming[MAX_PORT]; 968 OMX_FRAMESIZETYPE framesize; 969 OMX_CONFIG_RECTTYPE rectangle; 970 OMX_U32 prev_n_filled_len; 971 bool is_down_scalar_enabled; 972 bool m_force_down_scalar; 973 #endif 974 struct custom_buffersize { 975 OMX_U32 input_buffersize; 976 } m_custom_buffersize; 977 bool m_power_hinted; 978 bool is_q6_platform; 979 OMX_ERRORTYPE power_module_register(); 980 OMX_ERRORTYPE power_module_deregister(); 981 bool msg_thread_created; 982 bool async_thread_created; 983 984 OMX_VIDEO_PARAM_PROFILELEVELTYPE m_profile_lvl; 985 OMX_U32 m_profile; 986 987 //variables to handle dynamic buffer mode 988 bool dynamic_buf_mode; 989 struct dynamic_buf_list *out_dynamic_list; 990 OMX_U32 m_reconfig_width; 991 OMX_U32 m_reconfig_height; 992 bool m_smoothstreaming_mode; 993 994 bool m_input_pass_buffer_fd; 995 DescribeColorAspectsParams m_client_color_space; 996 DescribeColorAspectsParams m_internal_color_space; 997 998 OMX_U32 m_smoothstreaming_width; 999 OMX_U32 m_smoothstreaming_height; 1000 OMX_ERRORTYPE enable_smoothstreaming(); 1001 OMX_ERRORTYPE enable_adaptive_playback(unsigned long width, unsigned long height); 1002 bool is_thulium_v1; 1003 bool m_disable_ubwc_mode; 1004 OMX_U32 m_downscalar_width; 1005 OMX_U32 m_downscalar_height; 1006 int decide_downscalar(); 1007 int enable_downscalar(); 1008 int disable_downscalar(); 1009 1010 unsigned int m_fill_output_msg; 1011 bool client_set_fps; 1012 class allocate_color_convert_buf 1013 { 1014 public: 1015 allocate_color_convert_buf(); 1016 ~allocate_color_convert_buf(); 1017 void set_vdec_client(void *); 1018 void update_client(); 1019 bool set_color_format(OMX_COLOR_FORMATTYPE dest_color_format); 1020 bool get_color_format(OMX_COLOR_FORMATTYPE &dest_color_format); 1021 bool update_buffer_req(); 1022 bool get_buffer_req(unsigned int &buffer_size); 1023 OMX_BUFFERHEADERTYPE* get_il_buf_hdr(); 1024 OMX_BUFFERHEADERTYPE* get_il_buf_hdr(OMX_BUFFERHEADERTYPE *input_hdr); 1025 OMX_BUFFERHEADERTYPE* get_dr_buf_hdr(OMX_BUFFERHEADERTYPE *input_hdr); 1026 OMX_BUFFERHEADERTYPE* convert(OMX_BUFFERHEADERTYPE *header); 1027 OMX_BUFFERHEADERTYPE* queue_buffer(OMX_BUFFERHEADERTYPE *header); 1028 OMX_ERRORTYPE allocate_buffers_color_convert(OMX_HANDLETYPE hComp, 1029 OMX_BUFFERHEADERTYPE **bufferHdr,OMX_U32 port,OMX_PTR appData, 1030 OMX_U32 bytes); 1031 OMX_ERRORTYPE free_output_buffer(OMX_BUFFERHEADERTYPE *bufferHdr); is_color_conversion_enabled()1032 bool is_color_conversion_enabled() {return enabled;} 1033 private: 1034 #define MAX_COUNT MAX_NUM_INPUT_OUTPUT_BUFFERS 1035 omx_vdec *omx; 1036 bool enabled; 1037 OMX_COLOR_FORMATTYPE ColorFormat; 1038 void init_members(); 1039 bool color_convert_mode; 1040 ColorConvertFormat dest_format; 1041 class omx_c2d_conv c2d; 1042 unsigned int allocated_count; 1043 unsigned int buffer_size_req; 1044 unsigned int buffer_alignment_req; 1045 OMX_QCOM_PLATFORM_PRIVATE_LIST m_platform_list_client[MAX_COUNT]; 1046 OMX_QCOM_PLATFORM_PRIVATE_ENTRY m_platform_entry_client[MAX_COUNT]; 1047 OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO m_pmem_info_client[MAX_COUNT]; 1048 OMX_BUFFERHEADERTYPE m_out_mem_ptr_client[MAX_COUNT]; 1049 #ifdef USE_ION 1050 struct vdec_ion op_buf_ion_info[MAX_COUNT]; 1051 #endif 1052 unsigned char *pmem_baseaddress[MAX_COUNT]; 1053 int pmem_fd[MAX_COUNT]; 1054 struct vidc_heap { 1055 sp<MemoryHeapBase> video_heap_ptr; 1056 }; 1057 struct vidc_heap m_heap_ptr[MAX_COUNT]; 1058 1059 OMX_ERRORTYPE cache_ops(unsigned int index, unsigned int cmd); cache_clean_buffer(unsigned int index)1060 inline OMX_ERRORTYPE cache_clean_buffer(unsigned int index) { 1061 return cache_ops(index, ION_IOC_CLEAN_CACHES); 1062 } cache_clean_invalidate_buffer(unsigned int index)1063 OMX_ERRORTYPE cache_clean_invalidate_buffer(unsigned int index) { 1064 return cache_ops(index, ION_IOC_CLEAN_INV_CACHES); 1065 } 1066 }; 1067 #if defined (_MSM8960_) || defined (_MSM8974_) 1068 allocate_color_convert_buf client_buffers; 1069 #endif 1070 struct video_decoder_capability m_decoder_capability; 1071 struct debug_cap m_debug; 1072 int log_input_buffers(const char *, int); 1073 int log_output_buffers(OMX_BUFFERHEADERTYPE *); 1074 #ifdef _MSM8974_ 1075 void send_codec_config(); 1076 #endif 1077 OMX_TICKS m_last_rendered_TS; 1078 volatile int32_t m_queued_codec_config_count; 1079 OMX_U32 current_perf_level; 1080 bool secure_scaling_to_non_secure_opb; 1081 bool m_force_compressed_for_dpb; 1082 class perf_lock { 1083 private: 1084 pthread_mutex_t mlock; 1085 1086 public: perf_lock()1087 perf_lock() { 1088 pthread_mutex_init(&mlock, NULL); 1089 } 1090 ~perf_lock()1091 ~perf_lock() { 1092 pthread_mutex_destroy(&mlock); 1093 } 1094 lock()1095 void lock() { 1096 pthread_mutex_lock(&mlock); 1097 } 1098 unlock()1099 void unlock() { 1100 pthread_mutex_unlock(&mlock); 1101 } 1102 }; 1103 1104 class perf_control { 1105 // 2 cores will be requested if framerate is beyond 45 fps 1106 static const int MIN_FRAME_DURATION_FOR_PERF_REQUEST_US = (1e6 / 45); 1107 typedef int (*perf_lock_acquire_t)(int, int, int*, int); 1108 typedef int (*perf_lock_release_t)(int); 1109 1110 private: 1111 void *m_perf_lib; 1112 int m_perf_handle; 1113 perf_lock_acquire_t m_perf_lock_acquire; 1114 perf_lock_release_t m_perf_lock_release; 1115 bool load_lib(); 1116 struct mpctl_stats { 1117 int vid_inst_count; 1118 bool vid_acquired; 1119 int vid_disp_handle; 1120 }; 1121 static struct mpctl_stats mpctl_obj; 1122 static perf_lock m_perf_lock; 1123 1124 public: 1125 perf_control(); 1126 ~perf_control(); 1127 void request_cores(int frame_duration_us); 1128 void send_hint_to_mpctl(bool state); 1129 }; 1130 perf_control m_perf_control; 1131 getPreferredColorFormatNonSurfaceMode(OMX_U32 index)1132 static OMX_COLOR_FORMATTYPE getPreferredColorFormatNonSurfaceMode(OMX_U32 index) { 1133 //On Android, we default to standard YUV formats for non-surface use-cases 1134 //where apps prefer known color formats. 1135 OMX_COLOR_FORMATTYPE formatsNonSurfaceMode[] = { 1136 [0] = OMX_COLOR_FormatYUV420SemiPlanar, 1137 [1] = OMX_COLOR_FormatYUV420Planar, 1138 [2] = (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m, 1139 [3] = (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mMultiView, 1140 [4] = (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed, 1141 }; 1142 return (index < sizeof(formatsNonSurfaceMode) / sizeof(OMX_COLOR_FORMATTYPE)) ? 1143 formatsNonSurfaceMode[index] : OMX_COLOR_FormatMax; 1144 } 1145 getPreferredColorFormatDefaultMode(OMX_U32 index)1146 OMX_COLOR_FORMATTYPE getPreferredColorFormatDefaultMode(OMX_U32 index) { 1147 //for surface mode (normal playback), advertise native/accelerated formats first 1148 OMX_COLOR_FORMATTYPE format = (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m; 1149 1150 if (!m_disable_ubwc_mode) { 1151 OMX_COLOR_FORMATTYPE formatsDefault[] = { 1152 [0] = (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed, 1153 [1] = (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m, 1154 [2] = OMX_COLOR_FormatYUV420SemiPlanar, 1155 [3] = OMX_COLOR_FormatYUV420Planar, 1156 [4] = (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mMultiView, 1157 }; 1158 format = (index < sizeof(formatsDefault) / sizeof(OMX_COLOR_FORMATTYPE)) ? 1159 formatsDefault[index] : OMX_COLOR_FormatMax; 1160 } else { 1161 OMX_COLOR_FORMATTYPE formatsDefault[] = { 1162 [0] = (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m, 1163 [1] = OMX_COLOR_FormatYUV420SemiPlanar, 1164 [2] = OMX_COLOR_FormatYUV420Planar, 1165 [3] = (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mMultiView, 1166 }; 1167 format = (index < sizeof(formatsDefault) / sizeof(OMX_COLOR_FORMATTYPE)) ? 1168 formatsDefault[index] : OMX_COLOR_FormatMax; 1169 } 1170 return format; 1171 } 1172 1173 static OMX_ERRORTYPE describeColorFormat(OMX_PTR params); 1174 void prefetchNewBuffers(); 1175 1176 }; 1177 1178 #ifdef _MSM8974_ 1179 enum instance_state { 1180 MSM_VIDC_CORE_UNINIT_DONE = 0x0001, 1181 MSM_VIDC_CORE_INIT, 1182 MSM_VIDC_CORE_INIT_DONE, 1183 MSM_VIDC_OPEN, 1184 MSM_VIDC_OPEN_DONE, 1185 MSM_VIDC_LOAD_RESOURCES, 1186 MSM_VIDC_LOAD_RESOURCES_DONE, 1187 MSM_VIDC_START, 1188 MSM_VIDC_START_DONE, 1189 MSM_VIDC_STOP, 1190 MSM_VIDC_STOP_DONE, 1191 MSM_VIDC_RELEASE_RESOURCES, 1192 MSM_VIDC_RELEASE_RESOURCES_DONE, 1193 MSM_VIDC_CLOSE, 1194 MSM_VIDC_CLOSE_DONE, 1195 MSM_VIDC_CORE_UNINIT, 1196 }; 1197 1198 enum vidc_resposes_id { 1199 MSM_VIDC_DECODER_FLUSH_DONE = 0x11, 1200 MSM_VIDC_DECODER_EVENT_CHANGE, 1201 }; 1202 1203 #endif // _MSM8974_ 1204 1205 #endif // __OMX_VDEC_H__ 1206