+++ /dev/null
-From 28ce6b9bf98afd40d242520c43d8c48e149c5d25 Mon Sep 17 00:00:00 2001
-From: adi766 <adityakumarteli7846@gmail.com>
-Date: Sat, 23 Sep 2017 16:10:43 +0000
-Subject: [PATCH] Add MediaTek color format support
-
-Signed-off-by: teja98 <tejachaitu96@gmail.com>
----
- include/media/stagefright/ACodec.h | 3 +
- include/media/stagefright/ColorConverter.h | 4 +
- .../media/stagefright/dpframework/DpBlitStream.h | 243 ++
- include/media/stagefright/dpframework/DpDataType.h | 450 ++
- media/libstagefright/Android.mk | 11 +
- media/libstagefright/CameraSource.cpp | 8 +
- media/libstagefright/OMXCodec.cpp | 4549 ++++++++++++++++++++
- media/libstagefright/colorconversion/Android.mk | 7 +
- .../colorconversion/ColorConverter.cpp | 101 +
- 9 files changed, 5376 insertions(+)
- create mode 100644 include/media/stagefright/dpframework/DpBlitStream.h
- create mode 100644 include/media/stagefright/dpframework/DpDataType.h
- create mode 100644 media/libstagefright/OMXCodec.cpp
-
-diff --git a/include/media/stagefright/ACodec.h b/include/media/stagefright/ACodec.h
-index d68263272..10a3905ef 100644
---- a/include/media/stagefright/ACodec.h
-+++ b/include/media/stagefright/ACodec.h
-@@ -351,6 +351,9 @@ protected:
- #ifdef USE_SAMSUNG_COLORFORMAT
- void setNativeWindowColorFormat(OMX_COLOR_FORMATTYPE &eNativeColorFormat);
- #endif
-+#ifdef MTK_HARDWARE
-+ void setHalWindowColorFormat(OMX_COLOR_FORMATTYPE &eHalColorFormat);
-+#endif
- status_t cancelBufferToNativeWindow(BufferInfo *info);
- status_t freeOutputBuffersNotOwnedByComponent();
- BufferInfo *dequeueBufferFromNativeWindow();
-diff --git a/include/media/stagefright/ColorConverter.h b/include/media/stagefright/ColorConverter.h
-index 270c80966..cf0cda5af 100644
---- a/include/media/stagefright/ColorConverter.h
-+++ b/include/media/stagefright/ColorConverter.h
-@@ -82,6 +82,10 @@ private:
- status_t convertTIYUV420PackedSemiPlanar(
- const BitmapParams &src, const BitmapParams &dst);
-
-+#ifdef MTK_HARDWARE
-+ status_t convertYUVToRGBHW(const BitmapParams &src, const BitmapParams &dst);
-+#endif
-+
- ColorConverter(const ColorConverter &);
- ColorConverter &operator=(const ColorConverter &);
- };
-diff --git a/include/media/stagefright/dpframework/DpBlitStream.h b/include/media/stagefright/dpframework/DpBlitStream.h
-new file mode 100644
-index 000000000..57fd482d6
---- /dev/null
-+++ b/include/media/stagefright/dpframework/DpBlitStream.h
-@@ -0,0 +1,243 @@
-+#ifndef __DP_BLIT_STREAM_H__
-+#define __DP_BLIT_STREAM_H__
-+
-+#include "DpDataType.h"
-+
-+enum
-+{
-+ DP_BLIT_GENERAL_USER = 0,
-+ DP_BLIT_HWC0 = 0,
-+ DP_BLIT_GPU = 1,
-+ DP_BLIT_HWC1 = 1,
-+ DP_BLIT_HWC2 = 2,
-+ DP_BLIT_HWC3 = 3
-+};
-+
-+
-+class DpBlitStream
-+{
-+public:
-+ static bool queryHWSupport(uint32_t srcWidth,
-+ uint32_t srcHeight,
-+ uint32_t dstWidth,
-+ uint32_t dstHeight,
-+ int32_t Orientation = 0);
-+
-+ DpBlitStream();
-+
-+ ~DpBlitStream();
-+
-+ enum DpOrientation
-+ {
-+ ROT_0 = 0x00000000,
-+ FLIP_H = 0x00000001,
-+ FLIP_V = 0x00000002,
-+ ROT_90 = 0x00000004,
-+ ROT_180 = FLIP_H|FLIP_V,
-+ ROT_270 = ROT_180|ROT_90,
-+ ROT_INVALID = 0x80
-+ };
-+
-+ DP_STATUS_ENUM setSrcBuffer(void *pVABase,
-+ uint32_t size);
-+
-+ DP_STATUS_ENUM setSrcBuffer(void **pVAList,
-+ uint32_t *pSizeList,
-+ uint32_t planeNumber);
-+
-+ // VA + MVA address interface
-+ DP_STATUS_ENUM setSrcBuffer(void** pVAddrList,
-+ void** pMVAddrList,
-+ uint32_t *pSizeList,
-+ uint32_t planeNumber);
-+
-+ // for ION file descriptor
-+ DP_STATUS_ENUM setSrcBuffer(int32_t fileDesc,
-+ uint32_t *sizeList,
-+ uint32_t planeNumber);
-+
-+ DP_STATUS_ENUM setSrcConfig(int32_t width,
-+ int32_t height,
-+ DpColorFormat format,
-+ DpInterlaceFormat field = eInterlace_None,
-+ DpRect *pROI = 0);
-+
-+ DP_STATUS_ENUM setSrcConfig(int32_t width,
-+ int32_t height,
-+ int32_t yPitch,
-+ int32_t uvPitch,
-+ DpColorFormat format,
-+ DP_PROFILE_ENUM profile = DP_PROFILE_BT601,
-+ DpInterlaceFormat field = eInterlace_None,
-+ DpRect *pROI = 0,
-+ DpSecure secure = DP_SECURE_NONE,
-+ bool doFlush = true);
-+
-+ DP_STATUS_ENUM setDstBuffer(void *pVABase,
-+ uint32_t size);
-+
-+ DP_STATUS_ENUM setDstBuffer(void **pVABaseList,
-+ uint32_t *pSizeList,
-+ uint32_t planeNumber);
-+
-+ // VA + MVA address interface
-+ DP_STATUS_ENUM setDstBuffer(void** pVABaseList,
-+ void** pMVABaseList,
-+ uint32_t *pSizeList,
-+ uint32_t planeNumber);
-+
-+ // for ION file descriptor
-+ DP_STATUS_ENUM setDstBuffer(int32_t fileDesc,
-+ uint32_t *pSizeList,
-+ uint32_t planeNumber);
-+
-+ DP_STATUS_ENUM setDstConfig(int32_t width,
-+ int32_t height,
-+ DpColorFormat format,
-+ DpInterlaceFormat field = eInterlace_None,
-+ DpRect *pROI = 0);
-+
-+ DP_STATUS_ENUM setDstConfig(int32_t width,
-+ int32_t height,
-+ int32_t yPitch,
-+ int32_t uvPitch,
-+ DpColorFormat format,
-+ DP_PROFILE_ENUM profile = DP_PROFILE_BT601,
-+ DpInterlaceFormat field = eInterlace_None,
-+ DpRect *pROI = 0,
-+ DpSecure secure = DP_SECURE_NONE,
-+ bool doFlush = true);
-+
-+ DP_STATUS_ENUM setRotate(int32_t rotation)
-+ {
-+ if ((m_rotation != rotation) ||
-+ (mRotate != rotation))
-+ {
-+ m_rotation = rotation;
-+ mRotate = rotation;
-+ m_frameChange = true;
-+ }
-+
-+ return DP_STATUS_RETURN_SUCCESS;
-+ }
-+
-+ //Compatible to 89
-+ DP_STATUS_ENUM setFlip(int flip)
-+ {
-+ if (mFlip != flip)
-+ {
-+ mFlip = flip;
-+ m_flipStatus = ((flip!= 0)? true: false);
-+ m_frameChange = true;
-+ }
-+
-+ return DP_STATUS_RETURN_SUCCESS;
-+ }
-+
-+ DP_STATUS_ENUM setOrientation(uint32_t transform);
-+
-+ DP_STATUS_ENUM setTdshp(int gain)
-+ {
-+ if (mTdshp != gain)
-+ {
-+ mTdshp = gain;
-+ m_frameChange = true;
-+ }
-+
-+ return DP_STATUS_RETURN_SUCCESS;
-+ }
-+
-+ uint32_t getPqID();
-+
-+ DP_STATUS_ENUM setPQParameter(const DpPqParam &pParam);
-+
-+ DP_STATUS_ENUM setDither(bool enDither)
-+ {
-+ if (m_ditherStatus != enDither)
-+ {
-+ m_ditherStatus = enDither;
-+ m_frameChange = true;
-+ }
-+
-+ return DP_STATUS_RETURN_SUCCESS;
-+ }
-+
-+ DP_STATUS_ENUM setAdaptiveLuma(bool enADL)
-+ {
-+ m_adaptiveLuma = enADL;
-+
-+ return DP_STATUS_RETURN_SUCCESS;
-+ }
-+
-+ DP_STATUS_ENUM setUser(uint32_t eID = 0);
-+
-+
-+ DP_STATUS_ENUM invalidate();
-+
-+ DP_STATUS_ENUM pq_process();
-+
-+ // for dump register
-+ void enableDumpReg(unsigned int flags){mDumpRegFlags = flags;}
-+
-+private:
-+ DpStream *m_pStream;
-+ DpChannel *m_pChannel;
-+ int32_t m_channelID;
-+ DpBasicBufferPool *m_pSrcPool;
-+ DpBasicBufferPool *m_pDstPool;
-+ int32_t m_srcBuffer;
-+ int32_t m_srcWidth;
-+ int32_t m_srcHeight;
-+ int32_t m_srcYPitch;
-+ int32_t m_srcUVPitch;
-+ DpColorFormat m_srcFormat;
-+ DP_PROFILE_ENUM m_srcProfile;
-+ DpSecure m_srcSecure;
-+ bool m_srcFlush;
-+ int32_t m_dstBuffer;
-+ int32_t m_dstWidth;
-+ int32_t m_dstHeight;
-+ int32_t m_dstYPitch;
-+ int32_t m_dstUVPitch;
-+ DpColorFormat m_dstFormat;
-+ DP_PROFILE_ENUM m_dstProfile;
-+ DpSecure m_dstSecure;
-+ bool m_dstFlush;
-+ DpStream *m_pPqStream;
-+ DpChannel *m_pPqChannel;
-+ DpAutoBufferPool *m_pPqPool;
-+ int32_t m_pqBuffer;
-+ int32_t m_cropXStart;
-+ int32_t m_cropYStart;
-+ int32_t m_cropWidth;
-+ int32_t m_cropHeight;
-+ int32_t m_cropSubPixelX;
-+ int32_t m_cropSubPixelY;
-+ int32_t m_targetXStart;
-+ int32_t m_targetYStart;
-+ int32_t m_rotation;
-+ bool m_frameChange;
-+ bool m_flipStatus;
-+ bool m_ditherStatus;
-+ bool m_adaptiveLuma;
-+ uint32_t m_userID;
-+ DpPqConfig m_PqConfig;
-+ uint32_t m_PqID;
-+ uint32_t m_engFlag;
-+ //Compatible to 89
-+ int mRotate;
-+ int mFlip;
-+ int mTdshp;
-+
-+ DpStream *mStream;
-+ DpChannel *mChannel;
-+ DpBufferPool *mSrcPool;
-+ DpBufferPool *mDstPool;
-+ DpPortOption *mSrcPort;
-+ DpPortOption *mDstPort;
-+ int mSrcBufferId;
-+ int mDstBufferId;
-+ unsigned int mDumpRegFlags;
-+};
-+
-+#endif // __DP_BLIT_STREAM_H__
-diff --git a/include/media/stagefright/dpframework/DpDataType.h b/include/media/stagefright/dpframework/DpDataType.h
-new file mode 100644
-index 000000000..d858e9727
---- /dev/null
-+++ b/include/media/stagefright/dpframework/DpDataType.h
-@@ -0,0 +1,450 @@
-+#ifndef __DP_DATA_TYPE_H__
-+#define __DP_DATA_TYPE_H__
-+
-+#ifndef __KERNEL__
-+#include <stdio.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <string.h>
-+#include <math.h>
-+#endif
-+
-+#ifndef MAX
-+ #define MAX(x, y) ((x) >= (y))? (x): (y)
-+#endif // MAX
-+
-+#ifndef MIN
-+ #define MIN(x, y) ((x) <= (y))? (x): (y)
-+#endif // MIN
-+
-+#ifndef __KERNEL__
-+class DpStream;
-+class DpChannel;
-+
-+class DpBasicBufferPool;
-+class DpAutoBufferPool;
-+class DpCommand;
-+class DpBufferPool;
-+#endif
-+
-+typedef unsigned long long DpJobID;
-+typedef int DpEngineType;
-+
-+typedef enum DP_STATUS_ENUM
-+{
-+ DP_STATUS_ABORTED_BY_USER = 4,
-+ DP_STATUS_ALL_TEST_DONE = 3,
-+ DP_STATUS_ALL_TPIPE_DONE = 2,
-+ DP_STATUS_BUFFER_DONE = 1,
-+ DP_STATUS_RETURN_SUCCESS = 0,
-+ DP_STATUS_INVALID_PARAX = -1,
-+ DP_STATUS_INVALID_PORT = -2,
-+ DP_STATUS_INVALID_PATH = -3,
-+ DP_STATUS_INVALID_FILE = -4,
-+ DP_STATUS_INVALID_CHANNEL = -5,
-+ DP_STATUS_INVALID_BUFFER = -6,
-+ DP_STATUS_INVALID_STATE = -7,
-+ DP_STATUS_INVALID_ENGINE = -8,
-+ DP_STATUS_INVALID_FORMAT = -9,
-+ DP_STATUS_INVALID_X_INPUT = -10,
-+ DP_STATUS_INVALID_Y_INPUT = -11,
-+ DP_STATUS_INVALID_X_OUTPUT = -12,
-+ DP_STATUS_INVALID_Y_OUTPUT = -13,
-+ DP_STATUS_INVALID_X_ALIGN = -14,
-+ DP_STATUS_INVALID_Y_ALIGN = -15,
-+ DP_STATUS_INVALID_WIDTH = -16,
-+ DP_STATUS_INVALID_HEIGHT = -17,
-+ DP_STATUS_INVALID_CROP = -18,
-+ DP_STATUS_INVALID_ANGLE = -19,
-+ DP_STATUS_INVALID_EVENT = -20,
-+ DP_STATUS_INVALID_OPCODE = -21,
-+ DP_STATUS_CAN_NOT_MERGE = -22,
-+ DP_STATUS_OUT_OF_MEMORY = -23,
-+ DP_STATUS_BUFFER_FULL = -24,
-+ DP_STATUS_BUFFER_EMPTY = -25,
-+ DP_STATUS_OPERATION_FAILED = -26,
-+ DP_STATUS_OVER_MAX_BRANCH = -27,
-+ DP_STATUS_OVER_MAX_ENGINE = -28,
-+ DP_STATUS_OVER_MAX_BACKUP = -29,
-+ DP_STATUS_SCHEDULE_ERROR = -30,
-+ DP_STATUS_OVER_MAX_WIDTH = -31,
-+ DP_STATUS_OVER_MAX_HEIGHT = -32,
-+ DP_STATUS_LEFT_EDGE_ERROR = -33,
-+ DP_STATUS_RIGHT_EDGE_ERROR = -34,
-+ DP_STATUS_TOP_EDGE_ERROR = -35,
-+ DP_STATUS_BOTTOM_EDGE_ERROR = -36,
-+ DP_STATUS_X_LESS_THAN_LAST = -37,
-+ DP_STATUS_Y_LESS_THAN_LAST = -38,
-+ DP_STATUS_UNWANTED_X_CAL = -39,
-+ DP_STATUS_LOSS_OVER_WIDTH = -40,
-+ DP_STATUS_LOSS_OVER_HEIGHT = -41,
-+ DP_STATUS_X_ALIGN_ERROR = -42,
-+ DP_STATUS_Y_ALIGN_ERROR = -43,
-+ DP_STATUS_X_OUT_OVERLAP = -44,
-+ DP_STATUS_Y_OUT_OVERLAP = -45,
-+ DP_STATUS_BACK_LE_FORWARD = -46,
-+ DP_STATUS_UNKNOWN_ERROR = -47,
-+} DP_STATUS_ENUM;
-+
-+
-+typedef enum DP_MEMORY_ENUM
-+{
-+ DP_MEMORY_VA,
-+ DP_MEMORY_ION,
-+ DP_MEMORY_PHY,
-+ DP_MEMORY_MVA
-+} DP_MEMORY_ENUM;
-+
-+typedef struct DpJPEGEnc_Config_st // for JPEG port only
-+{
-+ int32_t fileDesc;
-+ uint32_t size;
-+ uint32_t fQuality;
-+ uint32_t soi_en;
-+ void *memSWAddr[3];
-+} DpJPEGEnc_Config;
-+
-+typedef struct DpVEnc_Config // for VENC port only
-+{
-+ /* Venc Modify + */
-+ unsigned long rVencDrvHandle;
-+ /* Venc Modify - */
-+ uint32_t memYUVMVAAddr[3];
-+ uint32_t memYUVMVASize[3];
-+ void *memYUVSWAddr[3];
-+ void *memOutputSWAddr[3];
-+
-+ uint32_t* pNumPABuffer;
-+ uint32_t* pPABuffer;
-+ uint64_t* pConfigFrameCount;
-+ uint64_t* pDequeueFrameCount;
-+ DpCommand* pVEncCommander;
-+} DpVEnc_Config;
-+
-+
-+#ifndef __KERNEL__
-+class DpRect
-+{
-+public:
-+
-+ enum
-+ {
-+ eINVALID_VALUE = -1,
-+ eINITIAL_VALUE = 0 //TBD, why to set as "0"?
-+ };
-+
-+ inline DpRect(void)
-+ : x(eINITIAL_VALUE), sub_x(eINITIAL_VALUE),
-+ y(eINITIAL_VALUE), sub_y(eINITIAL_VALUE),
-+ w(eINITIAL_VALUE), h(eINITIAL_VALUE)
-+ {}
-+
-+ inline DpRect(int32_t in_x, int32_t in_y, int32_t in_w, int32_t in_h,
-+ int32_t in_sub_x = 0, int32_t in_sub_y = 0)
-+ : x(in_x),
-+ sub_x(in_sub_x),
-+ y(in_y),
-+ sub_y(in_sub_y),
-+ w(in_w),
-+ h(in_h)
-+ {}
-+
-+ inline DpRect(const DpRect& rt)
-+ : x(rt.x),
-+ sub_x(rt.sub_x),
-+ y(rt.y),
-+ sub_y(rt.sub_y),
-+ w(rt.w),
-+ h(rt.h)
-+ {}
-+
-+ ~DpRect(void) {}
-+
-+ inline DpRect& operator= (const DpRect rval)
-+ {
-+ x = rval.x;
-+ sub_x = rval.sub_x;
-+ y = rval.y;
-+ sub_y = rval.sub_y;
-+ w = rval.w;
-+ h = rval.h;
-+ return *this;
-+ }
-+
-+ int32_t x;
-+ int32_t sub_x;
-+ int32_t y;
-+ int32_t sub_y;
-+ int32_t w;
-+ int32_t h;
-+};
-+#endif
-+
-+typedef enum DP_PROFILE_ENUM
-+{
-+ DP_PROFILE_BT601, //Limited range
-+ DP_PROFILE_BT709,
-+ DP_PROFILE_JPEG,
-+ DP_PROFILE_FULL_BT601 = DP_PROFILE_JPEG
-+} DP_PROFILE_ENUM;
-+
-+
-+typedef enum DP_STREAM_ID_ENUM
-+{
-+ DP_BLITSTREAM = 0x10000000,
-+ DP_FRAGSTREAM = 0x20000000,
-+ DP_ISPSTREAM = 0x30000000,
-+ DP_ASYNCBLITSTREAM = 0x40000000,
-+ DP_UNKNOWN_STREAM = 0xF0000000,
-+} DP_STREAM_ID_ENUM;
-+
-+typedef enum DP_MEDIA_TYPE_ENUM
-+{
-+ MEDIA_UNKNOWN,
-+ MEDIA_VIDEO,
-+ MEDIA_PICTURE,
-+ MEDIA_ISP_PREVIEW
-+} DP_MEDIA_TYPE_ENUM;
-+
-+typedef struct
-+{
-+ uint32_t id;
-+ uint32_t timeStamp;
-+ uint32_t reserved[28]; // padding and reserved
-+} DpVideoParam;
-+
-+typedef struct
-+{
-+ bool withHist;
-+ uint32_t info[20];
-+ uint32_t reserved[9]; // padding and reserved
-+} DpImageParam;
-+
-+struct DpPqParam {
-+ bool enable;
-+ DP_MEDIA_TYPE_ENUM scenario;
-+
-+ union {
-+ DpVideoParam video;
-+ DpImageParam image;
-+ } u;
-+};
-+
-+struct DpPqConfig {
-+ uint32_t enSharp;
-+ uint32_t enDC;
-+ uint32_t enColor;
-+};
-+
-+
-+//FMT GROUP , 0-RGB , 1-YUV , 2-Bayer raw , 3-compressed format
-+#define DP_COLORFMT_PACK(VIDEO, PLANE, COPLANE, HFACTOR, VFACTOR, BITS, GROUP ,SWAP_ENABLE, UNIQUEID) \
-+ ((VIDEO << 27) | \
-+ (PLANE << 24) | \
-+ (COPLANE << 22) | \
-+ (HFACTOR << 20) | \
-+ (VFACTOR << 18) | \
-+ (BITS << 8) | \
-+ (GROUP << 6) | \
-+ (SWAP_ENABLE << 5) | \
-+ (UNIQUEID << 0))
-+
-+#define DP_COLOR_GET_UFP_ENABLE(color) ((0x20000000 & color) >> 29)
-+#define DP_COLOR_GET_INTERLACED_MODE(color) ((0x10000000 & color) >> 28)
-+#define DP_COLOR_GET_BLOCK_MODE(color) ((0x08000000 & color) >> 27)
-+#define DP_COLOR_GET_PLANE_COUNT(color) ((0x07000000 & color) >> 24)
-+#define DP_COLOR_IS_UV_COPLANE(color) ((0x00C00000 & color) >> 22)
-+#define DP_COLOR_GET_H_SUBSAMPLE(color) ((0x00300000 & color) >> 20)
-+#define DP_COLOR_GET_V_SUBSAMPLE(color) ((0x000C0000 & color) >> 18)
-+#define DP_COLOR_BITS_PER_PIXEL(color) ((0x0003FF00 & color) >> 8)
-+#define DP_COLOR_GET_COLOR_GROUP(color) ((0x000000C0 & color) >> 6)
-+#define DP_COLOR_GET_SWAP_ENABLE(color) ((0x00000020 & color) >> 5)
-+#define DP_COLOR_GET_UNIQUE_ID(color) ((0x0000001F & color) >> 0)
-+#define DP_COLOR_GET_HW_FORMAT(color) ((0x0000001F & color) >> 0)
-+
-+typedef enum DP_COLOR_ENUM
-+{
-+ DP_COLOR_UNKNOWN = 0,
-+ DP_COLOR_FULLG8 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 8, 3, 0, 20),
-+ DP_COLOR_FULLG10 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 10, 3, 0, 21),
-+ DP_COLOR_FULLG12 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 12, 3, 0, 22),
-+ DP_COLOR_FULLG14 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 14, 3, 0, 26),
-+ DP_COLOR_UFO10 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 10, 3, 0, 27),
-+
-+ DP_COLOR_BAYER8 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 8, 2, 0, 20),
-+ DP_COLOR_BAYER10 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 10, 2, 0, 21),
-+ DP_COLOR_BAYER12 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 12, 2, 0, 22),
-+
-+ // Unified format
-+ DP_COLOR_GREY = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 8, 1, 0, 7),
-+
-+ DP_COLOR_RGB565 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 16, 0, 0, 0),
-+ DP_COLOR_BGR565 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 16, 0, 1, 0),
-+ DP_COLOR_RGB888 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 24, 0, 1, 1),
-+ DP_COLOR_BGR888 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 24, 0, 0, 1),
-+ DP_COLOR_RGBA8888 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 32, 0, 1, 2),
-+ DP_COLOR_BGRA8888 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 32, 0, 0, 2),
-+ DP_COLOR_ARGB8888 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 32, 0, 1, 3),
-+ DP_COLOR_ABGR8888 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 32, 0, 0, 3),
-+
-+ DP_COLOR_UYVY = DP_COLORFMT_PACK(0, 1, 0, 1, 0, 16, 1, 0, 4),
-+ DP_COLOR_VYUY = DP_COLORFMT_PACK(0, 1, 0, 1, 0, 16, 1, 1, 4),
-+ DP_COLOR_YUYV = DP_COLORFMT_PACK(0, 1, 0, 1, 0, 16, 1, 0, 5),
-+ DP_COLOR_YVYU = DP_COLORFMT_PACK(0, 1, 0, 1, 0, 16, 1, 1, 5),
-+
-+ DP_COLOR_I420 = DP_COLORFMT_PACK(0, 3, 0, 1, 1, 8, 1, 0, 8),
-+ DP_COLOR_YV12 = DP_COLORFMT_PACK(0, 3, 0, 1, 1, 8, 1, 1, 8),
-+ DP_COLOR_I422 = DP_COLORFMT_PACK(0, 3, 0, 1, 0, 8, 1, 0, 9),
-+ DP_COLOR_YV16 = DP_COLORFMT_PACK(0, 3, 0, 1, 0, 8, 1, 1, 9),
-+ DP_COLOR_I444 = DP_COLORFMT_PACK(0, 3, 0, 0, 0, 8, 1, 0, 10),
-+ DP_COLOR_YV24 = DP_COLORFMT_PACK(0, 3, 0, 0, 0, 8, 1, 1, 10),
-+
-+ DP_COLOR_NV12 = DP_COLORFMT_PACK(0, 2, 1, 1, 1, 8, 1, 0, 12),
-+ DP_COLOR_NV21 = DP_COLORFMT_PACK(0, 2, 1, 1, 1, 8, 1, 1, 12),
-+ DP_COLOR_NV16 = DP_COLORFMT_PACK(0, 2, 1, 1, 0, 8, 1, 0, 13),
-+ DP_COLOR_NV61 = DP_COLORFMT_PACK(0, 2, 1, 1, 0, 8, 1, 1, 13),
-+ DP_COLOR_NV24 = DP_COLORFMT_PACK(0, 2, 1, 0, 0, 8, 1, 0, 14),
-+ DP_COLOR_NV42 = DP_COLORFMT_PACK(0, 2, 1, 0, 0, 8, 1, 1, 14),
-+
-+ // Mediatek proprietary format
-+ DP_COLOR_420_BLKP_UFO = DP_COLORFMT_PACK(5, 2, 1, 1, 1, 256, 1, 0, 12),//Frame mode + Block mode
-+ DP_COLOR_420_BLKP = DP_COLORFMT_PACK(1, 2, 1, 1, 1, 256, 1, 0, 12),//Frame mode + Block mode
-+ DP_COLOR_420_BLKI = DP_COLORFMT_PACK(3, 2, 1, 1, 1, 256, 1, 0, 12),//Field mode + Block mode
-+ DP_COLOR_422_BLKP = DP_COLORFMT_PACK(1, 1, 0, 1, 0, 512, 1, 0, 4), //Frame mode
-+
-+ DP_COLOR_PARGB8888 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 32, 0, 0, 26),
-+ DP_COLOR_XARGB8888 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 32, 0, 0, 27),
-+ DP_COLOR_PABGR8888 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 32, 0, 0, 28),
-+ DP_COLOR_XABGR8888 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 32, 0, 0, 29),
-+
-+ DP_COLOR_IYU2 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 24, 1, 0, 25),
-+ DP_COLOR_YUV444 = DP_COLORFMT_PACK(0, 1, 0, 0, 0, 24, 1, 0, 30),
-+// DP_COLOR_YUV422I = DP_COLORFMT_PACK(1, 0, 1, 0, 16, 1, 41),//Dup to DP_COLOR_YUYV
-+// DP_COLOR_Y800 = DP_COLORFMT_PACK(1, 0, 1, 0, 8, 1, 42),//Dup to DP_COLOR_GREY
-+// DP_COLOR_COMPACT_RAW1 = DP_COLORFMT_PACK(1, 0, 1, 0, 10, 2, 43),//Dup to Bayer10
-+// DP_COLOR_420_3P_YVU = DP_COLORFMT_PACK(3, 0, 1, 1, 8, 1, 44),//Dup to DP_COLOR_YV12
-+} DP_COLOR_ENUM;
-+
-+// Legacy for 6589 compatible
-+typedef DP_COLOR_ENUM DpColorFormat;
-+
-+#define eYUV_420_3P DP_COLOR_I420
-+#define eYUV_420_2P_YUYV DP_COLOR_YUYV
-+#define eYUV_420_2P_UYVY DP_COLOR_UYVY
-+#define eYUV_420_2P_YVYU DP_COLOR_YVYU
-+#define eYUV_420_2P_VYUY DP_COLOR_VYUY
-+#define eYUV_420_2P_ISP_BLK DP_COLOR_420_BLKP
-+#define eYUV_420_2P_VDO_BLK DP_COLOR_420_BLKI
-+#define eYUV_422_3P DP_COLOR_I422
-+#define eYUV_422_2P DP_COLOR_NV16
-+#define eYUV_422_I DP_COLOR_YUYV
-+#define eYUV_422_I_BLK DP_COLOR_422_BLKP
-+#define eYUV_444_3P DP_COLOR_I444
-+#define eYUV_444_2P DP_COLOR_NV24
-+#define eYUV_444_1P DP_COLOR_YUV444
-+#define eBAYER8 DP_COLOR_BAYER8
-+#define eBAYER10 DP_COLOR_BAYER10
-+#define eBAYER12 DP_COLOR_BAYER12
-+#define eRGB565 DP_COLOR_RGB565
-+#define eBGR565 DP_COLOR_BGR565
-+#define eRGB888 DP_COLOR_RGB888
-+#define eBGR888 DP_COLOR_BGR888
-+#define eARGB8888 DP_COLOR_ARGB8888
-+#define eABGR8888 DP_COLOR_ABGR8888
-+#define DP_COLOR_XRGB8888 DP_COLOR_ARGB8888
-+#define DP_COLOR_XBGR8888 DP_COLOR_ABGR8888
-+#define eRGBA8888 DP_COLOR_RGBA8888
-+#define eBGRA8888 DP_COLOR_BGRA8888
-+#define eXRGB8888 DP_COLOR_XRGB8888
-+#define eXBGR8888 DP_COLOR_XBGR8888
-+#define DP_COLOR_RGBX8888 DP_COLOR_RGBA8888
-+#define DP_COLOR_BGRX8888 DP_COLOR_BGRA8888
-+#define eRGBX8888 DP_COLOR_RGBX8888
-+#define eBGRX8888 DP_COLOR_BGRX8888
-+#define ePARGB8888 DP_COLOR_PARGB8888
-+#define eXARGB8888 DP_COLOR_XARGB8888
-+#define ePABGR8888 DP_COLOR_PABGR8888
-+#define eXABGR8888 DP_COLOR_XABGR8888
-+#define eGREY DP_COLOR_GREY
-+#define eI420 DP_COLOR_I420
-+#define eYV12 DP_COLOR_YV12
-+#define eIYU2 DP_COLOR_IYU2
-+
-+
-+#define eYV21 DP_COLOR_I420
-+#define eNV12_BLK DP_COLOR_420_BLKP
-+#define eNV12_BLK_FCM DP_COLOR_420_BLKI
-+#define eYUV_420_3P_YVU DP_COLOR_YV12
-+
-+#define eNV12_BP DP_COLOR_420_BLKP
-+#define eNV12_BI DP_COLOR_420_BLKI
-+#define eNV12 DP_COLOR_NV12
-+#define eNV21 DP_COLOR_NV21
-+#define eI422 DP_COLOR_I422
-+#define eYV16 DP_COLOR_YV16
-+#define eNV16 DP_COLOR_NV16
-+#define eNV61 DP_COLOR_NV61
-+#define eUYVY DP_COLOR_UYVY
-+#define eVYUY DP_COLOR_VYUY
-+#define eYUYV DP_COLOR_YUYV
-+#define eYVYU DP_COLOR_YVYU
-+#define eUYVY_BP DP_COLOR_422_BLKP
-+#define eI444 DP_COLOR_I444
-+#define eNV24 DP_COLOR_NV24
-+#define eNV42 DP_COLOR_NV42
-+#define DP_COLOR_YUY2 DP_COLOR_YUYV
-+#define eYUY2 DP_COLOR_YUY2
-+#define eY800 DP_COLOR_GREY
-+//#define eIYU2
-+#define eMTKYUV DP_COLOR_422_BLKP
-+
-+#define eCompactRaw1 DP_COLOR_BAYER10
-+
-+
-+enum DpInterlaceFormat
-+{
-+ eInterlace_None,
-+ eTop_Field,
-+ eBottom_Field
-+};
-+
-+enum DpSecure
-+{
-+ DP_SECURE_NONE = 0,
-+ DP_SECURE = 1,
-+ DP_SECURE_SHIFT = 8
-+};
-+
-+#define MAX_NUM_READBACK_REGS (20)
-+
-+#define VENC_ENABLE_FLAG (0x08967)
-+
-+#ifndef __KERNEL__
-+struct DpPortOption
-+{
-+ int width;
-+ int height;
-+ DpRect ROI;
-+ DpColorFormat format;
-+ DpInterlaceFormat interlace;
-+
-+ enum DpPort
-+ {
-+ eLCD0_PORT,
-+ eLCD1_PORT,
-+ eHDMI_PORT,
-+ eTVOUT_PORT,
-+ eOVERLAY_PORT,
-+ eVIRTUAL_PORT,
-+ eMEMORY_PORT
-+ };
-+
-+ DpPort port;
-+
-+ int overlayID; // setting if choose port = eOVERLAY
-+ int virtualID; // setting if choose port = eVIRTUAL_PORT
-+ DpBufferPool *buffer; // setting if choose port = eMEMORY
-+};
-+#endif // __KERNEL__
-+
-+#endif // __DP_DATA_TYPE_H__
-diff --git a/media/libstagefright/Android.mk b/media/libstagefright/Android.mk
-index e708f68ae..322253c0d 100644
---- a/media/libstagefright/Android.mk
-+++ b/media/libstagefright/Android.mk
-@@ -202,6 +202,17 @@ LOCAL_C_INCLUDES += \
- $(TOP)/hardware/samsung/exynos4/include
- endif
-
-+# Mediatek
-+ifeq ($(strip $(BOARD_HAS_MTK_HARDWARE)),true)
-+LOCAL_CFLAGS += -DMTK_HARDWARE
-+
-+LOCAL_C_INCLUDES += \
-+ $(TOP)/hardware/mediatek/dpframework/inc
-+
-+LOCAL_SHARED_LIBRARIES += \
-+ libdpframework
-+endif
-+
- LOCAL_MODULE:= libstagefright
-
- LOCAL_MODULE_TAGS := optional
-diff --git a/media/libstagefright/CameraSource.cpp b/media/libstagefright/CameraSource.cpp
-index aa582d2d2..8f542bf60 100644
---- a/media/libstagefright/CameraSource.cpp
-+++ b/media/libstagefright/CameraSource.cpp
-@@ -44,6 +44,10 @@
- #define UNUSED_UNLESS_VERBOSE(x)
- #endif
-
-+#ifdef MTK_HARDWARE
-+#define OMX_MTK_COLOR_FormatYV12 0x7F000200
-+#endif
-+
- namespace android {
-
- static const int64_t CAMERA_SOURCE_TIMEOUT_NS = 3000000000LL;
-@@ -119,7 +123,11 @@ static int32_t getColorFormat(const char* colorFormat) {
- }
-
- if (!strcmp(colorFormat, CameraParameters::PIXEL_FORMAT_YUV420P)) {
-+#ifdef MTK_HARDWARE
-+ return OMX_MTK_COLOR_FormatYV12;
-+#else
- return OMX_COLOR_FormatYUV420Planar;
-+#endif
- }
-
- if (!strcmp(colorFormat, CameraParameters::PIXEL_FORMAT_YUV422SP)) {
-diff --git a/media/libstagefright/OMXCodec.cpp b/media/libstagefright/OMXCodec.cpp
-new file mode 100644
-index 000000000..20c59750e
---- /dev/null
-+++ b/media/libstagefright/OMXCodec.cpp
-@@ -0,0 +1,4549 @@
-+/*
-+ * Copyright (C) 2009 The Android Open Source Project
-+ *
-+ * Licensed under the Apache License, Version 2.0 (the "License");
-+ * you may not use this file except in compliance with the License.
-+ * You may obtain a copy of the License at
-+ *
-+ * http://www.apache.org/licenses/LICENSE-2.0
-+ *
-+ * Unless required by applicable law or agreed to in writing, software
-+ * distributed under the License is distributed on an "AS IS" BASIS,
-+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-+ * See the License for the specific language governing permissions and
-+ * limitations under the License.
-+ */
-+
-+#include <inttypes.h>
-+
-+//#define LOG_NDEBUG 0
-+#define LOG_TAG "OMXCodec"
-+
-+#ifdef __LP64__
-+#define OMX_ANDROID_COMPILE_AS_32BIT_ON_64BIT_PLATFORMS
-+#endif
-+
-+#include <utils/Log.h>
-+
-+#include "include/AACEncoder.h"
-+
-+#include "include/ESDS.h"
-+
-+#include <binder/IServiceManager.h>
-+#include <binder/MemoryDealer.h>
-+#include <binder/ProcessState.h>
-+#include <HardwareAPI.h>
-+#include <media/stagefright/foundation/ADebug.h>
-+#include <media/IMediaPlayerService.h>
-+#include <media/stagefright/ACodec.h>
-+#include <media/stagefright/MediaBuffer.h>
-+#include <media/stagefright/MediaBufferGroup.h>
-+#include <media/stagefright/MediaDefs.h>
-+#include <media/stagefright/MediaCodecList.h>
-+#include <media/stagefright/MediaExtractor.h>
-+#include <media/stagefright/MetaData.h>
-+#include <media/stagefright/OMXCodec.h>
-+#include <media/stagefright/SurfaceUtils.h>
-+#include <media/stagefright/Utils.h>
-+#include <media/stagefright/SkipCutBuffer.h>
-+#include <utils/Vector.h>
-+
-+#include <OMX_AudioExt.h>
-+#include <OMX_Component.h>
-+#include <OMX_IndexExt.h>
-+#include <OMX_VideoExt.h>
-+#include <OMX_AsString.h>
-+
-+#include "include/avc_utils.h"
-+
-+#ifdef USE_S3D_SUPPORT
-+#include "Exynos_OMX_Def.h"
-+#include "ExynosHWCService.h"
-+#endif
-+
-+namespace android {
-+
-+// Treat time out as an error if we have not received any output
-+// buffers after 3 seconds.
-+const static int64_t kBufferFilledEventTimeOutNs = 3000000000LL;
-+
-+// OMX Spec defines less than 50 color formats. If the query for
-+// color format is executed for more than kMaxColorFormatSupported,
-+// the query will fail to avoid looping forever.
-+// 1000 is more than enough for us to tell whether the omx
-+// component in question is buggy or not.
-+const static uint32_t kMaxColorFormatSupported = 1000;
-+
-+#define FACTORY_CREATE_ENCODER(name) \
-+static sp<MediaSource> Make##name(const sp<MediaSource> &source, const sp<MetaData> &meta) { \
-+ return new name(source, meta); \
-+}
-+
-+#define FACTORY_REF(name) { #name, Make##name },
-+
-+FACTORY_CREATE_ENCODER(AACEncoder)
-+
-+static sp<MediaSource> InstantiateSoftwareEncoder(
-+ const char *name, const sp<MediaSource> &source,
-+ const sp<MetaData> &meta) {
-+ struct FactoryInfo {
-+ const char *name;
-+ sp<MediaSource> (*CreateFunc)(const sp<MediaSource> &, const sp<MetaData> &);
-+ };
-+
-+ static const FactoryInfo kFactoryInfo[] = {
-+ FACTORY_REF(AACEncoder)
-+ };
-+ for (size_t i = 0;
-+ i < sizeof(kFactoryInfo) / sizeof(kFactoryInfo[0]); i) {
-+ if (!strcmp(name, kFactoryInfo[i].name)) {
-+ return (*kFactoryInfo[i].CreateFunc)(source, meta);
-+ }
-+ }
-+
-+ return NULL;
-+}
-+
-+#undef FACTORY_CREATE_ENCODER
-+#undef FACTORY_REF
-+
-+#define CODEC_LOGI(x, ...) ALOGI("[%s] " x, mComponentName, ##__VA_ARGS__)
-+#define CODEC_LOGV(x, ...) ALOGV("[%s] " x, mComponentName, ##__VA_ARGS__)
-+#define CODEC_LOGW(x, ...) ALOGW("[%s] " x, mComponentName, ##__VA_ARGS__)
-+#define CODEC_LOGE(x, ...) ALOGE("[%s] " x, mComponentName, ##__VA_ARGS__)
-+
-+struct OMXCodecObserver : public BnOMXObserver {
-+ OMXCodecObserver() {
-+ }
-+
-+ void setCodec(const sp<OMXCodec> &target) {
-+ mTarget = target;
-+ }
-+
-+ // from IOMXObserver
-+ virtual void onMessages(const std::list<omx_message> &messages) {
-+ sp<OMXCodec> codec = mTarget.promote();
-+
-+ if (codec.get() != NULL) {
-+ Mutex::Autolock autoLock(codec->mLock);
-+ for (std::list<omx_message>::const_iterator it = messages.cbegin();
-+ it != messages.cend(); it) {
-+ codec->on_message(*it);
-+ }
-+ codec.clear();
-+ }
-+ }
-+
-+protected:
-+ virtual ~OMXCodecObserver() {}
-+
-+private:
-+ wp<OMXCodec> mTarget;
-+
-+ OMXCodecObserver(const OMXCodecObserver &);
-+ OMXCodecObserver &operator=(const OMXCodecObserver &);
-+};
-+
-+template<class T>
-+static void InitOMXParams(T *params) {
-+ COMPILE_TIME_ASSERT_FUNCTION_SCOPE(sizeof(OMX_PTR) == 4); // check OMX_PTR is 4 bytes.
-+ params->nSize = sizeof(T);
-+ params->nVersion.s.nVersionMajor = 1;
-+ params->nVersion.s.nVersionMinor = 0;
-+ params->nVersion.s.nRevision = 0;
-+ params->nVersion.s.nStep = 0;
-+}
-+
-+static bool IsSoftwareCodec(const char *componentName) {
-+ if (!strncmp("OMX.google.", componentName, 11)
-+ || !strncmp("OMX.ffmpeg.", componentName, 11)) {
-+ return true;
-+ }
-+
-+ if (!strncmp("OMX.", componentName, 4)) {
-+ return false;
-+ }
-+
-+ return true;
-+}
-+
-+// A sort order in which OMX software codecs are first, followed
-+// by other (non-OMX) software codecs, followed by everything else.
-+static int CompareSoftwareCodecsFirst(
-+ const OMXCodec::CodecNameAndQuirks *elem1,
-+ const OMXCodec::CodecNameAndQuirks *elem2) {
-+ bool isOMX1 = !strncmp(elem1->mName.string(), "OMX.", 4);
-+ bool isOMX2 = !strncmp(elem2->mName.string(), "OMX.", 4);
-+
-+ bool isSoftwareCodec1 = IsSoftwareCodec(elem1->mName.string());
-+ bool isSoftwareCodec2 = IsSoftwareCodec(elem2->mName.string());
-+
-+ if (isSoftwareCodec1) {
-+ if (!isSoftwareCodec2) { return -1; }
-+
-+ if (isOMX1) {
-+ if (isOMX2) { return 0; }
-+
-+ return -1;
-+ } else {
-+ if (isOMX2) { return 0; }
-+
-+ return 1;
-+ }
-+
-+ return -1;
-+ }
-+
-+ if (isSoftwareCodec2) {
-+ return 1;
-+ }
-+
-+ return 0;
-+}
-+
-+// static
-+void OMXCodec::findMatchingCodecs(
-+ const char *mime,
-+ bool createEncoder, const char *matchComponentName,
-+ uint32_t flags,
-+ Vector<CodecNameAndQuirks> *matchingCodecs) {
-+ matchingCodecs->clear();
-+
-+ const sp<IMediaCodecList> list = MediaCodecList::getInstance();
-+ if (list == NULL) {
-+ return;
-+ }
-+
-+ size_t index = 0;
-+ for (;;) {
-+ ssize_t matchIndex =
-+ list->findCodecByType(mime, createEncoder, index);
-+
-+ if (matchIndex < 0) {
-+ break;
-+ }
-+
-+ index = matchIndex 1;
-+
-+ const sp<MediaCodecInfo> info = list->getCodecInfo(matchIndex);
-+ CHECK(info != NULL);
-+ const char *componentName = info->getCodecName();
-+
-+ // If a specific codec is requested, skip the non-matching ones.
-+ if (matchComponentName && strcmp(componentName, matchComponentName)) {
-+ continue;
-+ }
-+
-+ // When requesting software-only codecs, only push software codecs
-+ // When requesting hardware-only codecs, only push hardware codecs
-+ // When there is request neither for software-only nor for
-+ // hardware-only codecs, push all codecs
-+ if (((flags & kSoftwareCodecsOnly) && IsSoftwareCodec(componentName)) ||
-+ ((flags & kHardwareCodecsOnly) && !IsSoftwareCodec(componentName)) ||
-+ (!(flags & (kSoftwareCodecsOnly | kHardwareCodecsOnly)))) {
-+
-+ ssize_t index = matchingCodecs->add();
-+ CodecNameAndQuirks *entry = &matchingCodecs->editItemAt(index);
-+ entry->mName = String8(componentName);
-+ entry->mQuirks = getComponentQuirks(info);
-+
-+ ALOGV("matching '%s' quirks 0x%08x",
-+ entry->mName.string(), entry->mQuirks);
-+ }
-+ }
-+
-+ if (flags & kPreferSoftwareCodecs) {
-+ matchingCodecs->sort(CompareSoftwareCodecsFirst);
-+ }
-+}
-+
-+// static
-+uint32_t OMXCodec::getComponentQuirks(
-+ const sp<MediaCodecInfo> &info) {
-+ uint32_t quirks = 0;
-+ if (info->hasQuirk("requires-allocate-on-input-ports")) {
-+ quirks |= kRequiresAllocateBufferOnInputPorts;
-+ }
-+ if (info->hasQuirk("requires-allocate-on-output-ports")) {
-+ quirks |= kRequiresAllocateBufferOnOutputPorts;
-+ }
-+ if (info->hasQuirk("output-buffers-are-unreadable")) {
-+ quirks |= kOutputBuffersAreUnreadable;
-+ }
-+
-+ return quirks;
-+}
-+
-+// static
-+bool OMXCodec::findCodecQuirks(const char *componentName, uint32_t *quirks) {
-+ const sp<IMediaCodecList> list = MediaCodecList::getInstance();
-+ if (list == NULL) {
-+ return false;
-+ }
-+
-+ ssize_t index = list->findCodecByName(componentName);
-+
-+ if (index < 0) {
-+ return false;
-+ }
-+
-+ const sp<MediaCodecInfo> info = list->getCodecInfo(index);
-+ CHECK(info != NULL);
-+ *quirks = getComponentQuirks(info);
-+
-+ return true;
-+}
-+
-+// static
-+sp<MediaSource> OMXCodec::Create(
-+ const sp<IOMX> &omx,
-+ const sp<MetaData> &meta, bool createEncoder,
-+ const sp<MediaSource> &source,
-+ const char *matchComponentName,
-+ uint32_t flags,
-+ const sp<ANativeWindow> &nativeWindow) {
-+ int32_t requiresSecureBuffers;
-+ if (source->getFormat()->findInt32(
-+ kKeyRequiresSecureBuffers,
-+ &requiresSecureBuffers)
-+ && requiresSecureBuffers) {
-+ flags |= kIgnoreCodecSpecificData;
-+ flags |= kUseSecureInputBuffers;
-+ }
-+
-+ const char *mime;
-+ bool success = meta->findCString(kKeyMIMEType, &mime);
-+ CHECK(success);
-+
-+ Vector<CodecNameAndQuirks> matchingCodecs;
-+ findMatchingCodecs(
-+ mime, createEncoder, matchComponentName, flags, &matchingCodecs);
-+
-+ if (matchingCodecs.isEmpty()) {
-+ ALOGV("No matching codecs! (mime: %s, createEncoder: %s, "
-+ "matchComponentName: %s, flags: 0x%x)",
-+ mime, createEncoder ? "true" : "false", matchComponentName, flags);
-+ return NULL;
-+ }
-+
-+ sp<OMXCodecObserver> observer = new OMXCodecObserver;
-+ IOMX::node_id node = 0;
-+
-+ for (size_t i = 0; i < matchingCodecs.size(); i) {
-+ const char *componentNameBase = matchingCodecs[i].mName.string();
-+ uint32_t quirks = matchingCodecs[i].mQuirks;
-+ const char *componentName = componentNameBase;
-+
-+ AString tmp;
-+ if (flags & kUseSecureInputBuffers) {
-+ tmp = componentNameBase;
-+ tmp.append(".secure");
-+
-+ componentName = tmp.c_str();
-+ }
-+
-+ if (createEncoder) {
-+ sp<MediaSource> softwareCodec =
-+ InstantiateSoftwareEncoder(componentName, source, meta);
-+
-+ if (softwareCodec != NULL) {
-+ ALOGV("Successfully allocated software codec '%s'", componentName);
-+
-+ return softwareCodec;
-+ }
-+ }
-+
-+ ALOGV("Attempting to allocate OMX node '%s'", componentName);
-+
-+ status_t err = omx->allocateNode(componentName, observer, &node);
-+ if (err == OK) {
-+ ALOGV("Successfully allocated OMX node '%s'", componentName);
-+
-+ sp<OMXCodec> codec = new OMXCodec(
-+ omx, node, quirks, flags,
-+ createEncoder, mime, componentName,
-+ source, nativeWindow);
-+
-+ observer->setCodec(codec);
-+
-+ err = codec->configureCodec(meta);
-+ if (err == OK) {
-+ return codec;
-+ }
-+
-+ ALOGV("Failed to configure codec '%s'", componentName);
-+ }
-+ }
-+
-+ return NULL;
-+}
-+
-+status_t OMXCodec::parseHEVCCodecSpecificData(
-+ const void *data, size_t size,
-+ unsigned *profile, unsigned *level) {
-+ const uint8_t *ptr = (const uint8_t *)data;
-+
-+ // verify minimum size and configurationVersion == 1.
-+ if (size < 23 || ptr[0] != 1) {
-+ return ERROR_MALFORMED;
-+ }
-+
-+ *profile = (ptr[1] & 31);
-+ *level = ptr[12];
-+
-+ ptr = 22;
-+ size -= 22;
-+
-+ size_t numofArrays = (char)ptr[0];
-+ ptr = 1;
-+ size -= 1;
-+ size_t j = 0, i = 0;
-+ for (i = 0; i < numofArrays; i) {
-+ if (size < 3) {
-+ return ERROR_MALFORMED;
-+ }
-+ ptr = 1;
-+ size -= 1;
-+
-+ // Num of nals
-+ size_t numofNals = U16_AT(ptr);
-+ ptr = 2;
-+ size -= 2;
-+
-+ for (j = 0;j < numofNals;j) {
-+ if (size < 2) {
-+ return ERROR_MALFORMED;
-+ }
-+
-+ size_t length = U16_AT(ptr);
-+
-+ ptr = 2;
-+ size -= 2;
-+
-+ if (size < length) {
-+ return ERROR_MALFORMED;
-+ }
-+ addCodecSpecificData(ptr, length);
-+
-+ ptr = length;
-+ size -= length;
-+ }
-+ }
-+ return OK;
-+}
-+
-+status_t OMXCodec::parseAVCCodecSpecificData(
-+ const void *data, size_t size,
-+ unsigned *profile, unsigned *level) {
-+ const uint8_t *ptr = (const uint8_t *)data;
-+
-+ // verify minimum size and configurationVersion == 1.
-+ if (size < 7 || ptr[0] != 1) {
-+ return ERROR_MALFORMED;
-+ }
-+
-+ *profile = ptr[1];
-+ *level = ptr[3];
-+
-+ // There is decodable content out there that fails the following
-+ // assertion, let's be lenient for now...
-+ // CHECK((ptr[4] >> 2) == 0x3f); // reserved
-+
-+ size_t lengthSize __unused = 1 (ptr[4] & 3);
-+
-+ // commented out check below as H264_QVGA_500_NO_AUDIO.3gp
-+ // violates it...
-+ // CHECK((ptr[5] >> 5) == 7); // reserved
-+
-+ size_t numSeqParameterSets = ptr[5] & 31;
-+
-+ ptr = 6;
-+ size -= 6;
-+
-+ for (size_t i = 0; i < numSeqParameterSets; i) {
-+ if (size < 2) {
-+ return ERROR_MALFORMED;
-+ }
-+
-+ size_t length = U16_AT(ptr);
-+
-+ ptr = 2;
-+ size -= 2;
-+
-+ if (size < length) {
-+ return ERROR_MALFORMED;
-+ }
-+
-+ addCodecSpecificData(ptr, length);
-+
-+ ptr = length;
-+ size -= length;
-+ }
-+
-+ if (size < 1) {
-+ return ERROR_MALFORMED;
-+ }
-+
-+ size_t numPictureParameterSets = *ptr;
-+ ptr;
-+ --size;
-+
-+ for (size_t i = 0; i < numPictureParameterSets; i) {
-+ if (size < 2) {
-+ return ERROR_MALFORMED;
-+ }
-+
-+ size_t length = U16_AT(ptr);
-+
-+ ptr = 2;
-+ size -= 2;
-+
-+ if (size < length) {
-+ return ERROR_MALFORMED;
-+ }
-+
-+ addCodecSpecificData(ptr, length);
-+
-+ ptr = length;
-+ size -= length;
-+ }
-+
-+ return OK;
-+}
-+
-+status_t OMXCodec::configureCodec(const sp<MetaData> &meta) {
-+ ALOGV("configureCodec protected=%d",
-+ (mFlags & kEnableGrallocUsageProtected) ? 1 : 0);
-+
-+ if (!(mFlags & kIgnoreCodecSpecificData)) {
-+ uint32_t type;
-+ const void *data;
-+ size_t size;
-+ if (meta->findData(kKeyESDS, &type, &data, &size)) {
-+ ESDS esds((const char *)data, size);
-+ CHECK_EQ(esds.InitCheck(), (status_t)OK);
-+
-+ const void *codec_specific_data;
-+ size_t codec_specific_data_size;
-+ esds.getCodecSpecificInfo(
-+ &codec_specific_data, &codec_specific_data_size);
-+
-+ addCodecSpecificData(
-+ codec_specific_data, codec_specific_data_size);
-+ } else if (meta->findData(kKeyAVCC, &type, &data, &size)) {
-+ // Parse the AVCDecoderConfigurationRecord
-+
-+ unsigned profile, level;
-+ status_t err;
-+ if ((err = parseAVCCodecSpecificData(
-+ data, size, &profile, &level)) != OK) {
-+ ALOGE("Malformed AVC codec specific data.");
-+ return err;
-+ }
-+
-+ CODEC_LOGI(
-+ "AVC profile = %u (%s), level = %u",
-+ profile, AVCProfileToString(profile), level);
-+ } else if (meta->findData(kKeyHVCC, &type, &data, &size)) {
-+ // Parse the HEVCDecoderConfigurationRecord
-+
-+ unsigned profile, level;
-+ status_t err;
-+ if ((err = parseHEVCCodecSpecificData(
-+ data, size, &profile, &level)) != OK) {
-+ ALOGE("Malformed HEVC codec specific data.");
-+ return err;
-+ }
-+
-+ CODEC_LOGI(
-+ "HEVC profile = %u , level = %u",
-+ profile, level);
-+ } else if (meta->findData(kKeyVorbisInfo, &type, &data, &size)) {
-+ addCodecSpecificData(data, size);
-+
-+ CHECK(meta->findData(kKeyVorbisBooks, &type, &data, &size));
-+ addCodecSpecificData(data, size);
-+ } else if (meta->findData(kKeyOpusHeader, &type, &data, &size)) {
-+ addCodecSpecificData(data, size);
-+
-+ CHECK(meta->findData(kKeyOpusCodecDelay, &type, &data, &size));
-+ addCodecSpecificData(data, size);
-+ CHECK(meta->findData(kKeyOpusSeekPreRoll, &type, &data, &size));
-+ addCodecSpecificData(data, size);
-+ }
-+ }
-+
-+ int32_t bitRate = 0;
-+ if (mIsEncoder) {
-+ CHECK(meta->findInt32(kKeyBitRate, &bitRate));
-+ }
-+ if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AMR_NB, mMIME)) {
-+ setAMRFormat(false /* isWAMR */, bitRate);
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AMR_WB, mMIME)) {
-+ setAMRFormat(true /* isWAMR */, bitRate);
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AAC, mMIME)) {
-+ int32_t numChannels, sampleRate, aacProfile;
-+ CHECK(meta->findInt32(kKeyChannelCount, &numChannels));
-+ CHECK(meta->findInt32(kKeySampleRate, &sampleRate));
-+
-+ if (!meta->findInt32(kKeyAACProfile, &aacProfile)) {
-+ aacProfile = OMX_AUDIO_AACObjectNull;
-+ }
-+
-+ int32_t isADTS;
-+ if (!meta->findInt32(kKeyIsADTS, &isADTS)) {
-+ isADTS = false;
-+ }
-+
-+ status_t err = setAACFormat(numChannels, sampleRate, bitRate, aacProfile, isADTS);
-+ if (err != OK) {
-+ CODEC_LOGE("setAACFormat() failed (err = %d)", err);
-+ return err;
-+ }
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_MPEG, mMIME)) {
-+ int32_t numChannels, sampleRate;
-+ if (meta->findInt32(kKeyChannelCount, &numChannels)
-+ && meta->findInt32(kKeySampleRate, &sampleRate)) {
-+ // Since we did not always check for these, leave them optional
-+ // and have the decoder figure it all out.
-+ setRawAudioFormat(
-+ mIsEncoder ? kPortIndexInput : kPortIndexOutput,
-+ sampleRate,
-+ numChannels);
-+ }
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AC3, mMIME)) {
-+ int32_t numChannels;
-+ int32_t sampleRate;
-+ CHECK(meta->findInt32(kKeyChannelCount, &numChannels));
-+ CHECK(meta->findInt32(kKeySampleRate, &sampleRate));
-+
-+ status_t err = setAC3Format(numChannels, sampleRate);
-+ if (err != OK) {
-+ CODEC_LOGE("setAC3Format() failed (err = %d)", err);
-+ return err;
-+ }
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_G711_ALAW, mMIME)
-+ || !strcasecmp(MEDIA_MIMETYPE_AUDIO_G711_MLAW, mMIME)) {
-+ // These are PCM-like formats with a fixed sample rate but
-+ // a variable number of channels.
-+
-+ int32_t sampleRate;
-+ int32_t numChannels;
-+ CHECK(meta->findInt32(kKeyChannelCount, &numChannels));
-+ if (!meta->findInt32(kKeySampleRate, &sampleRate)) {
-+ sampleRate = 8000;
-+ }
-+
-+ setG711Format(sampleRate, numChannels);
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_RAW, mMIME)) {
-+ CHECK(!mIsEncoder);
-+
-+ int32_t numChannels, sampleRate;
-+ CHECK(meta->findInt32(kKeyChannelCount, &numChannels));
-+ CHECK(meta->findInt32(kKeySampleRate, &sampleRate));
-+
-+ setRawAudioFormat(kPortIndexInput, sampleRate, numChannels);
-+ }
-+
-+ if (!strncasecmp(mMIME, "video/", 6)) {
-+
-+ if (mIsEncoder) {
-+ setVideoInputFormat(mMIME, meta);
-+ } else {
-+ status_t err = setVideoOutputFormat(
-+ mMIME, meta);
-+
-+ if (err != OK) {
-+ return err;
-+ }
-+ }
-+ }
-+
-+ int32_t maxInputSize;
-+ if (meta->findInt32(kKeyMaxInputSize, &maxInputSize)) {
-+ setMinBufferSize(kPortIndexInput, (OMX_U32)maxInputSize);
-+ }
-+
-+ initOutputFormat(meta);
-+
-+ if (mNativeWindow != NULL
-+ && !mIsEncoder
-+ && !strncasecmp(mMIME, "video/", 6)
-+ && !strncmp(mComponentName, "OMX.", 4)) {
-+ status_t err = initNativeWindow();
-+ if (err != OK) {
-+ return err;
-+ }
-+ }
-+
-+ return OK;
-+}
-+
-+void OMXCodec::setMinBufferSize(OMX_U32 portIndex, OMX_U32 size) {
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = portIndex;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ if ((portIndex == kPortIndexInput && (mQuirks & kInputBufferSizesAreBogus))
-+ || (def.nBufferSize < size)) {
-+ def.nBufferSize = size;
-+ }
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ // Make sure the setting actually stuck.
-+ if (portIndex == kPortIndexInput
-+ && (mQuirks & kInputBufferSizesAreBogus)) {
-+ CHECK_EQ(def.nBufferSize, size);
-+ } else {
-+ CHECK(def.nBufferSize >= size);
-+ }
-+}
-+
-+status_t OMXCodec::setVideoPortFormatType(
-+ OMX_U32 portIndex,
-+ OMX_VIDEO_CODINGTYPE compressionFormat,
-+ OMX_COLOR_FORMATTYPE colorFormat) {
-+ OMX_VIDEO_PARAM_PORTFORMATTYPE format;
-+ InitOMXParams(&format);
-+ format.nPortIndex = portIndex;
-+ format.nIndex = 0;
-+ bool found = false;
-+
-+ OMX_U32 index = 0;
-+ for (;;) {
-+ format.nIndex = index;
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamVideoPortFormat,
-+ &format, sizeof(format));
-+
-+ if (err != OK) {
-+ return err;
-+ }
-+
-+ // The following assertion is violated by TI's video decoder.
-+ // CHECK_EQ(format.nIndex, index);
-+
-+#if 1
-+ CODEC_LOGV("portIndex: %u, index: %u, eCompressionFormat=%d eColorFormat=%d",
-+ portIndex,
-+ index, format.eCompressionFormat, format.eColorFormat);
-+#endif
-+
-+ if (format.eCompressionFormat == compressionFormat
-+ && format.eColorFormat == colorFormat) {
-+ found = true;
-+ break;
-+ }
-+
-+ index;
-+ if (index >= kMaxColorFormatSupported) {
-+ CODEC_LOGE("color format %d or compression format %d is not supported",
-+ colorFormat, compressionFormat);
-+ return UNKNOWN_ERROR;
-+ }
-+ }
-+
-+ if (!found) {
-+ return UNKNOWN_ERROR;
-+ }
-+
-+ CODEC_LOGV("found a match.");
-+ status_t err = mOMX->setParameter(
-+ mNode, OMX_IndexParamVideoPortFormat,
-+ &format, sizeof(format));
-+
-+ return err;
-+}
-+
-+static size_t getFrameSize(
-+ OMX_COLOR_FORMATTYPE colorFormat, int32_t width, int32_t height) {
-+ switch (colorFormat) {
-+ case OMX_COLOR_FormatYCbYCr:
-+ case OMX_COLOR_FormatCbYCrY:
-+ return width * height * 2;
-+
-+ case OMX_COLOR_FormatYUV420Planar:
-+ case OMX_COLOR_FormatYUV420SemiPlanar:
-+ case OMX_TI_COLOR_FormatYUV420PackedSemiPlanar:
-+ /*
-+ * FIXME: For the Opaque color format, the frame size does not
-+ * need to be (w*h*3)/2. It just needs to
-+ * be larger than certain minimum buffer size. However,
-+ * currently, this opaque foramt has been tested only on
-+ * YUV420 formats. If that is changed, then we need to revisit
-+ * this part in the future
-+ */
-+ case OMX_COLOR_FormatAndroidOpaque:
-+ return (width * height * 3) / 2;
-+
-+ default:
-+ CHECK(!"Should not be here. Unsupported color format.");
-+ break;
-+ }
-+ return 0;
-+}
-+
-+status_t OMXCodec::findTargetColorFormat(
-+ const sp<MetaData>& meta, OMX_COLOR_FORMATTYPE *colorFormat) {
-+ ALOGV("findTargetColorFormat");
-+ CHECK(mIsEncoder);
-+
-+ *colorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
-+ int32_t targetColorFormat;
-+ if (meta->findInt32(kKeyColorFormat, &targetColorFormat)) {
-+ *colorFormat = (OMX_COLOR_FORMATTYPE) targetColorFormat;
-+ }
-+
-+ // Check whether the target color format is supported.
-+ return isColorFormatSupported(*colorFormat, kPortIndexInput);
-+}
-+
-+status_t OMXCodec::isColorFormatSupported(
-+ OMX_COLOR_FORMATTYPE colorFormat, int portIndex) {
-+ ALOGV("isColorFormatSupported: %d", static_cast<int>(colorFormat));
-+
-+ // Enumerate all the color formats supported by
-+ // the omx component to see whether the given
-+ // color format is supported.
-+ OMX_VIDEO_PARAM_PORTFORMATTYPE portFormat;
-+ InitOMXParams(&portFormat);
-+ portFormat.nPortIndex = portIndex;
-+ OMX_U32 index = 0;
-+ portFormat.nIndex = index;
-+ while (true) {
-+ if (OMX_ErrorNone != mOMX->getParameter(
-+ mNode, OMX_IndexParamVideoPortFormat,
-+ &portFormat, sizeof(portFormat))) {
-+ break;
-+ }
-+ // Make sure that omx component does not overwrite
-+ // the incremented index (bug 2897413).
-+ CHECK_EQ(index, portFormat.nIndex);
-+ if (portFormat.eColorFormat == colorFormat) {
-+ CODEC_LOGV("Found supported color format: %d", portFormat.eColorFormat);
-+ return OK; // colorFormat is supported!
-+ }
-+ index;
-+ portFormat.nIndex = index;
-+
-+ if (index >= kMaxColorFormatSupported) {
-+ CODEC_LOGE("More than %u color formats are supported???", index);
-+ break;
-+ }
-+ }
-+
-+ CODEC_LOGE("color format %d is not supported", colorFormat);
-+ return UNKNOWN_ERROR;
-+}
-+
-+void OMXCodec::setVideoInputFormat(
-+ const char *mime, const sp<MetaData>& meta) {
-+
-+ int32_t width, height, frameRate, bitRate, stride, sliceHeight;
-+ bool success = meta->findInt32(kKeyWidth, &width);
-+ success = success && meta->findInt32(kKeyHeight, &height);
-+ success = success && meta->findInt32(kKeyFrameRate, &frameRate);
-+ success = success && meta->findInt32(kKeyBitRate, &bitRate);
-+ success = success && meta->findInt32(kKeyStride, &stride);
-+ success = success && meta->findInt32(kKeySliceHeight, &sliceHeight);
-+ CHECK(success);
-+ CHECK(stride != 0);
-+
-+ OMX_VIDEO_CODINGTYPE compressionFormat = OMX_VIDEO_CodingUnused;
-+ if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingAVC;
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_HEVC, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingHEVC;
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG4, mime) ||
-+ !strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG4_DP, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingMPEG4;
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_H263, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingH263;
-+ } else {
-+ ALOGE("Not a supported video mime type: %s", mime);
-+ CHECK(!"Should not be here. Not a supported video mime type.");
-+ }
-+
-+ OMX_COLOR_FORMATTYPE colorFormat;
-+ CHECK_EQ((status_t)OK, findTargetColorFormat(meta, &colorFormat));
-+
-+ status_t err;
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;
-+
-+ //////////////////////// Input port /////////////////////////
-+ CHECK_EQ(setVideoPortFormatType(
-+ kPortIndexInput, OMX_VIDEO_CodingUnused,
-+ colorFormat), (status_t)OK);
-+
-+ InitOMXParams(&def);
-+ def.nPortIndex = kPortIndexInput;
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ def.nBufferSize = getFrameSize(colorFormat,
-+ stride > 0? stride: -stride, sliceHeight);
-+
-+ CHECK_EQ((int)def.eDomain, (int)OMX_PortDomainVideo);
-+
-+ video_def->nFrameWidth = width;
-+ video_def->nFrameHeight = height;
-+ video_def->nStride = stride;
-+ video_def->nSliceHeight = sliceHeight;
-+ video_def->xFramerate = (frameRate << 16); // Q16 format
-+ video_def->eCompressionFormat = OMX_VIDEO_CodingUnused;
-+ video_def->eColorFormat = colorFormat;
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ //////////////////////// Output port /////////////////////////
-+ CHECK_EQ(setVideoPortFormatType(
-+ kPortIndexOutput, compressionFormat, OMX_COLOR_FormatUnused),
-+ (status_t)OK);
-+ InitOMXParams(&def);
-+ def.nPortIndex = kPortIndexOutput;
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+
-+ CHECK_EQ(err, (status_t)OK);
-+ CHECK_EQ((int)def.eDomain, (int)OMX_PortDomainVideo);
-+
-+ video_def->nFrameWidth = width;
-+ video_def->nFrameHeight = height;
-+ video_def->xFramerate = 0; // No need for output port
-+ video_def->nBitrate = bitRate; // Q16 format
-+ video_def->eCompressionFormat = compressionFormat;
-+ video_def->eColorFormat = OMX_COLOR_FormatUnused;
-+ if (mQuirks & kRequiresLargerEncoderOutputBuffer) {
-+ // Increases the output buffer size
-+ def.nBufferSize = ((def.nBufferSize * 3) >> 1);
-+ }
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ /////////////////// Codec-specific ////////////////////////
-+ switch (compressionFormat) {
-+ case OMX_VIDEO_CodingMPEG4:
-+ {
-+ CHECK_EQ(setupMPEG4EncoderParameters(meta), (status_t)OK);
-+ break;
-+ }
-+
-+ case OMX_VIDEO_CodingH263:
-+ CHECK_EQ(setupH263EncoderParameters(meta), (status_t)OK);
-+ break;
-+
-+ case OMX_VIDEO_CodingAVC:
-+ {
-+ CHECK_EQ(setupAVCEncoderParameters(meta), (status_t)OK);
-+ break;
-+ }
-+
-+ default:
-+ CHECK(!"Support for this compressionFormat to be implemented.");
-+ break;
-+ }
-+}
-+
-+static OMX_U32 setPFramesSpacing(int32_t iFramesInterval, int32_t frameRate) {
-+ if (iFramesInterval < 0) {
-+ return 0xFFFFFFFF;
-+ } else if (iFramesInterval == 0) {
-+ return 0;
-+ }
-+ OMX_U32 ret = frameRate * iFramesInterval - 1;
-+ return ret;
-+}
-+
-+status_t OMXCodec::setupErrorCorrectionParameters() {
-+ OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE errorCorrectionType;
-+ InitOMXParams(&errorCorrectionType);
-+ errorCorrectionType.nPortIndex = kPortIndexOutput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamVideoErrorCorrection,
-+ &errorCorrectionType, sizeof(errorCorrectionType));
-+ if (err != OK) {
-+ ALOGW("Error correction param query is not supported");
-+ return OK; // Optional feature. Ignore this failure
-+ }
-+
-+ errorCorrectionType.bEnableHEC = OMX_FALSE;
-+ errorCorrectionType.bEnableResync = OMX_TRUE;
-+ errorCorrectionType.nResynchMarkerSpacing = 256;
-+ errorCorrectionType.bEnableDataPartitioning = OMX_FALSE;
-+ errorCorrectionType.bEnableRVLC = OMX_FALSE;
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamVideoErrorCorrection,
-+ &errorCorrectionType, sizeof(errorCorrectionType));
-+ if (err != OK) {
-+ ALOGW("Error correction param configuration is not supported");
-+ }
-+
-+ // Optional feature. Ignore the failure.
-+ return OK;
-+}
-+
-+status_t OMXCodec::setupBitRate(int32_t bitRate) {
-+ OMX_VIDEO_PARAM_BITRATETYPE bitrateType;
-+ InitOMXParams(&bitrateType);
-+ bitrateType.nPortIndex = kPortIndexOutput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamVideoBitrate,
-+ &bitrateType, sizeof(bitrateType));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ bitrateType.eControlRate = OMX_Video_ControlRateVariable;
-+ bitrateType.nTargetBitrate = bitRate;
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamVideoBitrate,
-+ &bitrateType, sizeof(bitrateType));
-+ CHECK_EQ(err, (status_t)OK);
-+ return OK;
-+}
-+
-+status_t OMXCodec::getVideoProfileLevel(
-+ const sp<MetaData>& meta,
-+ const CodecProfileLevel& defaultProfileLevel,
-+ CodecProfileLevel &profileLevel) {
-+ CODEC_LOGV("Default profile: %u, level #x%x",
-+ defaultProfileLevel.mProfile, defaultProfileLevel.mLevel);
-+
-+ // Are the default profile and level overwriten?
-+ int32_t profile, level;
-+ if (!meta->findInt32(kKeyVideoProfile, &profile)) {
-+ profile = defaultProfileLevel.mProfile;
-+ }
-+ if (!meta->findInt32(kKeyVideoLevel, &level)) {
-+ level = defaultProfileLevel.mLevel;
-+ }
-+ CODEC_LOGV("Target profile: %d, level: %d", profile, level);
-+
-+ // Are the target profile and level supported by the encoder?
-+ OMX_VIDEO_PARAM_PROFILELEVELTYPE param;
-+ InitOMXParams(¶m);
-+ param.nPortIndex = kPortIndexOutput;
-+ for (param.nProfileIndex = 0;; param.nProfileIndex) {
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamVideoProfileLevelQuerySupported,
-+ ¶m, sizeof(param));
-+
-+ if (err != OK) break;
-+
-+ int32_t supportedProfile = static_cast<int32_t>(param.eProfile);
-+ int32_t supportedLevel = static_cast<int32_t>(param.eLevel);
-+ CODEC_LOGV("Supported profile: %d, level %d",
-+ supportedProfile, supportedLevel);
-+
-+ if (profile == supportedProfile &&
-+ level <= supportedLevel) {
-+ // We can further check whether the level is a valid
-+ // value; but we will leave that to the omx encoder component
-+ // via OMX_SetParameter call.
-+ profileLevel.mProfile = profile;
-+ profileLevel.mLevel = level;
-+ return OK;
-+ }
-+ }
-+
-+ CODEC_LOGE("Target profile (%d) and level (%d) is not supported",
-+ profile, level);
-+ return BAD_VALUE;
-+}
-+
-+status_t OMXCodec::setupH263EncoderParameters(const sp<MetaData>& meta) {
-+ int32_t iFramesInterval, frameRate, bitRate;
-+ bool success = meta->findInt32(kKeyBitRate, &bitRate);
-+ success = success && meta->findInt32(kKeyFrameRate, &frameRate);
-+ success = success && meta->findInt32(kKeyIFramesInterval, &iFramesInterval);
-+ CHECK(success);
-+ OMX_VIDEO_PARAM_H263TYPE h263type;
-+ InitOMXParams(&h263type);
-+ h263type.nPortIndex = kPortIndexOutput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamVideoH263, &h263type, sizeof(h263type));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ h263type.nAllowedPictureTypes =
-+ OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
-+
-+ h263type.nPFrames = setPFramesSpacing(iFramesInterval, frameRate);
-+ if (h263type.nPFrames == 0) {
-+ h263type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;
-+ }
-+ h263type.nBFrames = 0;
-+
-+ // Check profile and level parameters
-+ CodecProfileLevel defaultProfileLevel, profileLevel;
-+ defaultProfileLevel.mProfile = h263type.eProfile;
-+ defaultProfileLevel.mLevel = h263type.eLevel;
-+ err = getVideoProfileLevel(meta, defaultProfileLevel, profileLevel);
-+ if (err != OK) return err;
-+ h263type.eProfile = static_cast<OMX_VIDEO_H263PROFILETYPE>(profileLevel.mProfile);
-+ h263type.eLevel = static_cast<OMX_VIDEO_H263LEVELTYPE>(profileLevel.mLevel);
-+
-+ h263type.bPLUSPTYPEAllowed = OMX_FALSE;
-+ h263type.bForceRoundingTypeToZero = OMX_FALSE;
-+ h263type.nPictureHeaderRepetition = 0;
-+ h263type.nGOBHeaderInterval = 0;
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamVideoH263, &h263type, sizeof(h263type));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ CHECK_EQ(setupBitRate(bitRate), (status_t)OK);
-+ CHECK_EQ(setupErrorCorrectionParameters(), (status_t)OK);
-+
-+ return OK;
-+}
-+
-+status_t OMXCodec::setupMPEG4EncoderParameters(const sp<MetaData>& meta) {
-+ int32_t iFramesInterval, frameRate, bitRate;
-+ bool success = meta->findInt32(kKeyBitRate, &bitRate);
-+ success = success && meta->findInt32(kKeyFrameRate, &frameRate);
-+ success = success && meta->findInt32(kKeyIFramesInterval, &iFramesInterval);
-+ CHECK(success);
-+ OMX_VIDEO_PARAM_MPEG4TYPE mpeg4type;
-+ InitOMXParams(&mpeg4type);
-+ mpeg4type.nPortIndex = kPortIndexOutput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamVideoMpeg4, &mpeg4type, sizeof(mpeg4type));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ mpeg4type.nSliceHeaderSpacing = 0;
-+ mpeg4type.bSVH = OMX_FALSE;
-+ mpeg4type.bGov = OMX_FALSE;
-+
-+ mpeg4type.nAllowedPictureTypes =
-+ OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
-+
-+ mpeg4type.nPFrames = setPFramesSpacing(iFramesInterval, frameRate);
-+ if (mpeg4type.nPFrames == 0) {
-+ mpeg4type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;
-+ }
-+ mpeg4type.nBFrames = 0;
-+ mpeg4type.nIDCVLCThreshold = 0;
-+ mpeg4type.bACPred = OMX_TRUE;
-+ mpeg4type.nMaxPacketSize = 256;
-+ mpeg4type.nTimeIncRes = 1000;
-+ mpeg4type.nHeaderExtension = 0;
-+ mpeg4type.bReversibleVLC = OMX_FALSE;
-+
-+ // Check profile and level parameters
-+ CodecProfileLevel defaultProfileLevel, profileLevel;
-+ defaultProfileLevel.mProfile = mpeg4type.eProfile;
-+ defaultProfileLevel.mLevel = mpeg4type.eLevel;
-+ err = getVideoProfileLevel(meta, defaultProfileLevel, profileLevel);
-+ if (err != OK) return err;
-+ mpeg4type.eProfile = static_cast<OMX_VIDEO_MPEG4PROFILETYPE>(profileLevel.mProfile);
-+ mpeg4type.eLevel = static_cast<OMX_VIDEO_MPEG4LEVELTYPE>(profileLevel.mLevel);
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamVideoMpeg4, &mpeg4type, sizeof(mpeg4type));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ CHECK_EQ(setupBitRate(bitRate), (status_t)OK);
-+ CHECK_EQ(setupErrorCorrectionParameters(), (status_t)OK);
-+
-+ return OK;
-+}
-+
-+status_t OMXCodec::setupAVCEncoderParameters(const sp<MetaData>& meta) {
-+ int32_t iFramesInterval, frameRate, bitRate;
-+ bool success = meta->findInt32(kKeyBitRate, &bitRate);
-+ success = success && meta->findInt32(kKeyFrameRate, &frameRate);
-+ success = success && meta->findInt32(kKeyIFramesInterval, &iFramesInterval);
-+ CHECK(success);
-+
-+ OMX_VIDEO_PARAM_AVCTYPE h264type;
-+ InitOMXParams(&h264type);
-+ h264type.nPortIndex = kPortIndexOutput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ h264type.nAllowedPictureTypes =
-+ OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;
-+
-+ // Check profile and level parameters
-+ CodecProfileLevel defaultProfileLevel, profileLevel;
-+ defaultProfileLevel.mProfile = h264type.eProfile;
-+ defaultProfileLevel.mLevel = h264type.eLevel;
-+ err = getVideoProfileLevel(meta, defaultProfileLevel, profileLevel);
-+ if (err != OK) return err;
-+ h264type.eProfile = static_cast<OMX_VIDEO_AVCPROFILETYPE>(profileLevel.mProfile);
-+ h264type.eLevel = static_cast<OMX_VIDEO_AVCLEVELTYPE>(profileLevel.mLevel);
-+
-+ // XXX
-+ if (h264type.eProfile != OMX_VIDEO_AVCProfileBaseline) {
-+ ALOGW("Use baseline profile instead of %d for AVC recording",
-+ h264type.eProfile);
-+ h264type.eProfile = OMX_VIDEO_AVCProfileBaseline;
-+ }
-+
-+ if (h264type.eProfile == OMX_VIDEO_AVCProfileBaseline) {
-+ h264type.nSliceHeaderSpacing = 0;
-+ h264type.bUseHadamard = OMX_TRUE;
-+ h264type.nRefFrames = 1;
-+ h264type.nBFrames = 0;
-+ h264type.nPFrames = setPFramesSpacing(iFramesInterval, frameRate);
-+ if (h264type.nPFrames == 0) {
-+ h264type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;
-+ }
-+ h264type.nRefIdx10ActiveMinus1 = 0;
-+ h264type.nRefIdx11ActiveMinus1 = 0;
-+ h264type.bEntropyCodingCABAC = OMX_FALSE;
-+ h264type.bWeightedPPrediction = OMX_FALSE;
-+ h264type.bconstIpred = OMX_FALSE;
-+ h264type.bDirect8x8Inference = OMX_FALSE;
-+ h264type.bDirectSpatialTemporal = OMX_FALSE;
-+ h264type.nCabacInitIdc = 0;
-+ }
-+
-+ if (h264type.nBFrames != 0) {
-+ h264type.nAllowedPictureTypes |= OMX_VIDEO_PictureTypeB;
-+ }
-+
-+ h264type.bEnableUEP = OMX_FALSE;
-+ h264type.bEnableFMO = OMX_FALSE;
-+ h264type.bEnableASO = OMX_FALSE;
-+ h264type.bEnableRS = OMX_FALSE;
-+ h264type.bFrameMBsOnly = OMX_TRUE;
-+ h264type.bMBAFF = OMX_FALSE;
-+ h264type.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable;
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ CHECK_EQ(setupBitRate(bitRate), (status_t)OK);
-+
-+ return OK;
-+}
-+
-+status_t OMXCodec::setVideoOutputFormat(
-+ const char *mime, const sp<MetaData>& meta) {
-+
-+ int32_t width, height;
-+ bool success = meta->findInt32(kKeyWidth, &width);
-+ success = success && meta->findInt32(kKeyHeight, &height);
-+ CHECK(success);
-+
-+ CODEC_LOGV("setVideoOutputFormat width=%d, height=%d", width, height);
-+
-+ OMX_VIDEO_CODINGTYPE compressionFormat = OMX_VIDEO_CodingUnused;
-+ if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingAVC;
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG4, mime) ||
-+ !strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG4_DP, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingMPEG4;
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_HEVC, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingHEVC;
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_H263, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingH263;
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_VP8, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingVP8;
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_VP9, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingVP9;
-+ } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_MPEG2, mime)) {
-+ compressionFormat = OMX_VIDEO_CodingMPEG2;
-+ } else {
-+ ALOGE("Not a supported video mime type: %s", mime);
-+ CHECK(!"Should not be here. Not a supported video mime type.");
-+ }
-+
-+ status_t err = setVideoPortFormatType(
-+ kPortIndexInput, compressionFormat, OMX_COLOR_FormatUnused);
-+
-+ if (err != OK) {
-+ return err;
-+ }
-+
-+#if 1
-+ {
-+ OMX_VIDEO_PARAM_PORTFORMATTYPE format;
-+ InitOMXParams(&format);
-+ format.nPortIndex = kPortIndexOutput;
-+ format.nIndex = 0;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamVideoPortFormat,
-+ &format, sizeof(format));
-+ CHECK_EQ(err, (status_t)OK);
-+ CHECK_EQ((int)format.eCompressionFormat, (int)OMX_VIDEO_CodingUnused);
-+
-+ int32_t colorFormat;
-+ if (meta->findInt32(kKeyColorFormat, &colorFormat)
-+ && colorFormat != OMX_COLOR_FormatUnused
-+ && colorFormat != format.eColorFormat) {
-+
-+ while (OMX_ErrorNoMore != err) {
-+ format.nIndex;
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamVideoPortFormat,
-+ &format, sizeof(format));
-+ if (format.eColorFormat == colorFormat) {
-+ break;
-+ }
-+ }
-+ if (format.eColorFormat != colorFormat) {
-+ CODEC_LOGE("Color format %d is not supported", colorFormat);
-+ return ERROR_UNSUPPORTED;
-+ }
-+ }
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamVideoPortFormat,
-+ &format, sizeof(format));
-+
-+ if (err != OK) {
-+ return err;
-+ }
-+ }
-+#endif
-+
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = kPortIndexInput;
-+
-+ OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+
-+ CHECK_EQ(err, (status_t)OK);
-+
-+#if 1
-+ // XXX Need a (much) better heuristic to compute input buffer sizes.
-+ const size_t X = 64 * 1024;
-+ if (def.nBufferSize < X) {
-+ def.nBufferSize = X;
-+ }
-+#endif
-+
-+ CHECK_EQ((int)def.eDomain, (int)OMX_PortDomainVideo);
-+
-+ video_def->nFrameWidth = width;
-+ video_def->nFrameHeight = height;
-+
-+ video_def->eCompressionFormat = compressionFormat;
-+ video_def->eColorFormat = OMX_COLOR_FormatUnused;
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+
-+ if (err != OK) {
-+ return err;
-+ }
-+
-+ ////////////////////////////////////////////////////////////////////////////
-+
-+ InitOMXParams(&def);
-+ def.nPortIndex = kPortIndexOutput;
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+ CHECK_EQ((int)def.eDomain, (int)OMX_PortDomainVideo);
-+
-+#if 0
-+ def.nBufferSize =
-+ (((width 15) & -16) * ((height 15) & -16) * 3) / 2; // YUV420
-+#endif
-+
-+ video_def->nFrameWidth = width;
-+ video_def->nFrameHeight = height;
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+
-+ return err;
-+}
-+
-+OMXCodec::OMXCodec(
-+ const sp<IOMX> &omx, IOMX::node_id node,
-+ uint32_t quirks, uint32_t flags,
-+ bool isEncoder,
-+ const char *mime,
-+ const char *componentName,
-+ const sp<MediaSource> &source,
-+ const sp<ANativeWindow> &nativeWindow)
-+ : mOMX(omx),
-+ mOMXLivesLocally(omx->livesLocally(node, getpid())),
-+ mNode(node),
-+ mQuirks(quirks),
-+ mFlags(flags),
-+ mIsEncoder(isEncoder),
-+ mIsVideo(!strncasecmp("video/", mime, 6)),
-+ mMIME(strdup(mime)),
-+ mComponentName(strdup(componentName)),
-+ mSource(source),
-+ mCodecSpecificDataIndex(0),
-+ mState(LOADED),
-+ mInitialBufferSubmit(true),
-+ mSignalledEOS(false),
-+ mNoMoreOutputData(false),
-+ mOutputPortSettingsHaveChanged(false),
-+ mSeekTimeUs(-1),
-+ mSeekMode(ReadOptions::SEEK_CLOSEST_SYNC),
-+ mTargetTimeUs(-1),
-+ mOutputPortSettingsChangedPending(false),
-+ mSkipCutBuffer(NULL),
-+ mLeftOverBuffer(NULL),
-+ mPaused(false),
-+ mNativeWindow(
-+ (!strncmp(componentName, "OMX.google.", 11))
-+ ? NULL : nativeWindow) {
-+ mPortStatus[kPortIndexInput] = ENABLED;
-+ mPortStatus[kPortIndexOutput] = ENABLED;
-+
-+ setComponentRole();
-+}
-+
-+// static
-+void OMXCodec::setComponentRole(
-+ const sp<IOMX> &omx, IOMX::node_id node, bool isEncoder,
-+ const char *mime) {
-+ struct MimeToRole {
-+ const char *mime;
-+ const char *decoderRole;
-+ const char *encoderRole;
-+ };
-+
-+ static const MimeToRole kMimeToRole[] = {
-+ { MEDIA_MIMETYPE_AUDIO_MPEG,
-+ "audio_decoder.mp3", "audio_encoder.mp3" },
-+ { MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I,
-+ "audio_decoder.mp1", "audio_encoder.mp1" },
-+ { MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II,
-+ "audio_decoder.mp2", "audio_encoder.mp2" },
-+ { MEDIA_MIMETYPE_AUDIO_AMR_NB,
-+ "audio_decoder.amrnb", "audio_encoder.amrnb" },
-+ { MEDIA_MIMETYPE_AUDIO_AMR_WB,
-+ "audio_decoder.amrwb", "audio_encoder.amrwb" },
-+ { MEDIA_MIMETYPE_AUDIO_AAC,
-+ "audio_decoder.aac", "audio_encoder.aac" },
-+ { MEDIA_MIMETYPE_AUDIO_VORBIS,
-+ "audio_decoder.vorbis", "audio_encoder.vorbis" },
-+ { MEDIA_MIMETYPE_AUDIO_OPUS,
-+ "audio_decoder.opus", "audio_encoder.opus" },
-+ { MEDIA_MIMETYPE_AUDIO_G711_MLAW,
-+ "audio_decoder.g711mlaw", "audio_encoder.g711mlaw" },
-+ { MEDIA_MIMETYPE_AUDIO_G711_ALAW,
-+ "audio_decoder.g711alaw", "audio_encoder.g711alaw" },
-+ { MEDIA_MIMETYPE_VIDEO_AVC,
-+ "video_decoder.avc", "video_encoder.avc" },
-+ { MEDIA_MIMETYPE_VIDEO_HEVC,
-+ "video_decoder.hevc", "video_encoder.hevc" },
-+ { MEDIA_MIMETYPE_VIDEO_MPEG4,
-+ "video_decoder.mpeg4", "video_encoder.mpeg4" },
-+ { MEDIA_MIMETYPE_VIDEO_MPEG4_DP,
-+ "video_decoder.mpeg4", NULL },
-+ { MEDIA_MIMETYPE_VIDEO_H263,
-+ "video_decoder.h263", "video_encoder.h263" },
-+ { MEDIA_MIMETYPE_VIDEO_VP8,
-+ "video_decoder.vp8", "video_encoder.vp8" },
-+ { MEDIA_MIMETYPE_VIDEO_VP9,
-+ "video_decoder.vp9", "video_encoder.vp9" },
-+ { MEDIA_MIMETYPE_AUDIO_RAW,
-+ "audio_decoder.raw", "audio_encoder.raw" },
-+ { MEDIA_MIMETYPE_AUDIO_FLAC,
-+ "audio_decoder.flac", "audio_encoder.flac" },
-+ { MEDIA_MIMETYPE_AUDIO_MSGSM,
-+ "audio_decoder.gsm", "audio_encoder.gsm" },
-+ { MEDIA_MIMETYPE_VIDEO_MPEG2,
-+ "video_decoder.mpeg2", "video_encoder.mpeg2" },
-+ { MEDIA_MIMETYPE_AUDIO_AC3,
-+ "audio_decoder.ac3", "audio_encoder.ac3" },
-+ };
-+
-+ static const size_t kNumMimeToRole =
-+ sizeof(kMimeToRole) / sizeof(kMimeToRole[0]);
-+
-+ size_t i;
-+ for (i = 0; i < kNumMimeToRole; i) {
-+ if (!strcasecmp(mime, kMimeToRole[i].mime)) {
-+ break;
-+ }
-+ }
-+
-+ if (i == kNumMimeToRole) {
-+ return;
-+ }
-+
-+ const char *role =
-+ isEncoder ? kMimeToRole[i].encoderRole
-+ : kMimeToRole[i].decoderRole;
-+
-+ if (role != NULL) {
-+ OMX_PARAM_COMPONENTROLETYPE roleParams;
-+ InitOMXParams(&roleParams);
-+
-+ strncpy((char *)roleParams.cRole,
-+ role, OMX_MAX_STRINGNAME_SIZE - 1);
-+
-+ roleParams.cRole[OMX_MAX_STRINGNAME_SIZE - 1] = '\0';
-+
-+ status_t err = omx->setParameter(
-+ node, OMX_IndexParamStandardComponentRole,
-+ &roleParams, sizeof(roleParams));
-+
-+ if (err != OK) {
-+ ALOGW("Failed to set standard component role '%s'.", role);
-+ }
-+ }
-+}
-+
-+void OMXCodec::setComponentRole() {
-+ setComponentRole(mOMX, mNode, mIsEncoder, mMIME);
-+}
-+
-+OMXCodec::~OMXCodec() {
-+ mSource.clear();
-+
-+ CHECK(mState == LOADED || mState == ERROR || mState == LOADED_TO_IDLE);
-+
-+ status_t err = mOMX->freeNode(mNode);
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ mNode = 0;
-+ setState(DEAD);
-+
-+ clearCodecSpecificData();
-+
-+ free(mComponentName);
-+ mComponentName = NULL;
-+
-+ free(mMIME);
-+ mMIME = NULL;
-+}
-+
-+status_t OMXCodec::init() {
-+ // mLock is held.
-+
-+ CHECK_EQ((int)mState, (int)LOADED);
-+
-+ status_t err;
-+ if (!(mQuirks & kRequiresLoadedToIdleAfterAllocation)) {
-+ err = mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
-+ CHECK_EQ(err, (status_t)OK);
-+ setState(LOADED_TO_IDLE);
-+ }
-+
-+ err = allocateBuffers();
-+ if (err != (status_t)OK) {
-+ return err;
-+ }
-+
-+ if (mQuirks & kRequiresLoadedToIdleAfterAllocation) {
-+ err = mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ setState(LOADED_TO_IDLE);
-+ }
-+
-+ while (mState != EXECUTING && mState != ERROR) {
-+ mAsyncCompletion.wait(mLock);
-+ }
-+
-+ return mState == ERROR ? UNKNOWN_ERROR : OK;
-+}
-+
-+// static
-+bool OMXCodec::isIntermediateState(State state) {
-+ return state == LOADED_TO_IDLE
-+ || state == IDLE_TO_EXECUTING
-+ || state == EXECUTING_TO_IDLE
-+ || state == PAUSING
-+ || state == FLUSHING
-+ || state == IDLE_TO_LOADED
-+ || state == RECONFIGURING;
-+}
-+
-+status_t OMXCodec::allocateBuffers() {
-+ status_t err = allocateBuffersOnPort(kPortIndexInput);
-+
-+ if (err != OK) {
-+ return err;
-+ }
-+
-+ return allocateBuffersOnPort(kPortIndexOutput);
-+}
-+
-+status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {
-+ if (mNativeWindow != NULL && portIndex == kPortIndexOutput) {
-+ return allocateOutputBuffersFromNativeWindow();
-+ }
-+
-+ if ((mFlags & kEnableGrallocUsageProtected) && portIndex == kPortIndexOutput) {
-+ ALOGE("protected output buffers must be stent to an ANativeWindow");
-+ return PERMISSION_DENIED;
-+ }
-+
-+ status_t err = OK;
-+ if ((mFlags & kStoreMetaDataInVideoBuffers)
-+ && portIndex == kPortIndexInput) {
-+ err = mOMX->storeMetaDataInBuffers(mNode, kPortIndexInput, OMX_TRUE);
-+ if (err != OK) {
-+ ALOGE("Storing meta data in video buffers is not supported");
-+ return err;
-+ }
-+ }
-+
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = portIndex;
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+
-+ if (err != OK) {
-+ return err;
-+ }
-+
-+ CODEC_LOGV("allocating %u buffers of size %u on %s port",
-+ def.nBufferCountActual, def.nBufferSize,
-+ portIndex == kPortIndexInput ? "input" : "output");
-+
-+ if (def.nBufferSize != 0 && def.nBufferCountActual > SIZE_MAX / def.nBufferSize) {
-+ return BAD_VALUE;
-+ }
-+ size_t totalSize = def.nBufferCountActual * def.nBufferSize;
-+ mDealer[portIndex] = new MemoryDealer(totalSize, "OMXCodec");
-+
-+ for (OMX_U32 i = 0; i < def.nBufferCountActual; i) {
-+ sp<IMemory> mem = mDealer[portIndex]->allocate(def.nBufferSize);
-+ if (mem == NULL || mem->pointer() == NULL) {
-+ return NO_MEMORY;
-+ }
-+
-+ BufferInfo info;
-+ info.mData = NULL;
-+ info.mSize = def.nBufferSize;
-+
-+ IOMX::buffer_id buffer;
-+ if (portIndex == kPortIndexInput
-+ && ((mQuirks & kRequiresAllocateBufferOnInputPorts)
-+ || (mFlags & kUseSecureInputBuffers))) {
-+ if (mOMXLivesLocally) {
-+ mem.clear();
-+
-+ err = mOMX->allocateBuffer(
-+ mNode, portIndex, def.nBufferSize, &buffer,
-+ &info.mData);
-+ } else {
-+ err = mOMX->allocateBufferWithBackup(
-+ mNode, portIndex, mem, &buffer, mem->size());
-+ }
-+ } else if (portIndex == kPortIndexOutput
-+ && (mQuirks & kRequiresAllocateBufferOnOutputPorts)) {
-+ if (mOMXLivesLocally) {
-+ mem.clear();
-+
-+ err = mOMX->allocateBuffer(
-+ mNode, portIndex, def.nBufferSize, &buffer,
-+ &info.mData);
-+ } else {
-+ err = mOMX->allocateBufferWithBackup(
-+ mNode, portIndex, mem, &buffer, mem->size());
-+ }
-+ } else {
-+ err = mOMX->useBuffer(mNode, portIndex, mem, &buffer, mem->size());
-+ }
-+
-+ if (err != OK) {
-+ ALOGE("allocate_buffer_with_backup failed");
-+ return err;
-+ }
-+
-+ if (mem != NULL) {
-+ info.mData = mem->pointer();
-+ }
-+
-+ info.mBuffer = buffer;
-+ info.mStatus = OWNED_BY_US;
-+ info.mMem = mem;
-+ info.mMediaBuffer = NULL;
-+
-+ if (portIndex == kPortIndexOutput) {
-+ // Fail deferred MediaBuffer creation until FILL_BUFFER_DONE;
-+ // this legacy mode is no longer supported.
-+ LOG_ALWAYS_FATAL_IF((mOMXLivesLocally
-+ && (mQuirks & kRequiresAllocateBufferOnOutputPorts)
-+ && (mQuirks & kDefersOutputBufferAllocation)),
-+ "allocateBuffersOnPort cannot defer buffer allocation");
-+
-+ info.mMediaBuffer = new MediaBuffer(info.mData, info.mSize);
-+ info.mMediaBuffer->setObserver(this);
-+ }
-+
-+ mPortBuffers[portIndex].push(info);
-+
-+ CODEC_LOGV("allocated buffer %u on %s port", buffer,
-+ portIndex == kPortIndexInput ? "input" : "output");
-+ }
-+
-+ if (portIndex == kPortIndexOutput) {
-+
-+ sp<MetaData> meta = mSource->getFormat();
-+ int32_t delay = 0;
-+ if (!meta->findInt32(kKeyEncoderDelay, &delay)) {
-+ delay = 0;
-+ }
-+ int32_t padding = 0;
-+ if (!meta->findInt32(kKeyEncoderPadding, &padding)) {
-+ padding = 0;
-+ }
-+ int32_t numchannels = 0;
-+ if (delay padding) {
-+ if (mOutputFormat->findInt32(kKeyChannelCount, &numchannels)) {
-+ if (mSkipCutBuffer != NULL) {
-+ size_t prevbuffersize = mSkipCutBuffer->size();
-+ if (prevbuffersize != 0) {
-+ ALOGW("Replacing SkipCutBuffer holding %zu bytes", prevbuffersize);
-+ }
-+ }
-+ mSkipCutBuffer = new SkipCutBuffer(delay, padding, numchannels);
-+ }
-+ }
-+ }
-+
-+ // dumpPortStatus(portIndex);
-+
-+ if (portIndex == kPortIndexInput && (mFlags & kUseSecureInputBuffers)) {
-+ Vector<MediaBuffer *> buffers;
-+ for (size_t i = 0; i < def.nBufferCountActual; i) {
-+ const BufferInfo &info = mPortBuffers[kPortIndexInput].itemAt(i);
-+
-+ MediaBuffer *mbuf = new MediaBuffer(info.mData, info.mSize);
-+ buffers.push(mbuf);
-+ }
-+
-+ status_t err = mSource->setBuffers(buffers);
-+
-+ if (err != OK) {
-+ for (size_t i = 0; i < def.nBufferCountActual; i) {
-+ buffers.editItemAt(i)->release();
-+ }
-+ buffers.clear();
-+
-+ CODEC_LOGE(
-+ "Codec requested to use secure input buffers but "
-+ "upstream source didn't support that.");
-+
-+ return err;
-+ }
-+ }
-+
-+ return OK;
-+}
-+
-+status_t OMXCodec::allocateOutputBuffersFromNativeWindow() {
-+ // Get the number of buffers needed.
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = kPortIndexOutput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ if (err != OK) {
-+ CODEC_LOGE("getParameter failed: %d", err);
-+ return err;
-+ }
-+
-+ sp<MetaData> meta = mSource->getFormat();
-+
-+ int32_t rotationDegrees;
-+ if (!meta->findInt32(kKeyRotation, &rotationDegrees)) {
-+ rotationDegrees = 0;
-+ }
-+
-+ // Set up the native window.
-+ OMX_U32 usage = 0;
-+ err = mOMX->getGraphicBufferUsage(mNode, kPortIndexOutput, &usage);
-+ if (err != 0) {
-+ ALOGW("querying usage flags from OMX IL component failed: %d", err);
-+ // XXX: Currently this error is logged, but not fatal.
-+ usage = 0;
-+ }
-+
-+ if (mFlags & kEnableGrallocUsageProtected) {
-+ usage |= GRALLOC_USAGE_PROTECTED;
-+#ifdef GRALLOC_USAGE_PRIVATE_NONSECURE
-+ if (!(mFlags & kUseSecureInputBuffers))
-+ usage |= GRALLOC_USAGE_PRIVATE_NONSECURE;
-+#endif
-+ }
-+
-+ err = setNativeWindowSizeFormatAndUsage(
-+ mNativeWindow.get(),
-+ def.format.video.nFrameWidth,
-+ def.format.video.nFrameHeight,
-+ def.format.video.eColorFormat,
-+ rotationDegrees,
-+ usage | GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_EXTERNAL_DISP);
-+ if (err != 0) {
-+ return err;
-+ }
-+
-+ int minUndequeuedBufs = 0;
-+ err = mNativeWindow->query(mNativeWindow.get(),
-+ NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minUndequeuedBufs);
-+ if (err != 0) {
-+ ALOGE("NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d)",
-+ strerror(-err), -err);
-+ return err;
-+ }
-+ // FIXME: assume that surface is controlled by app (native window
-+ // returns the number for the case when surface is not controlled by app)
-+ // FIXME2: This means that minUndeqeueudBufs can be 1 larger than reported
-+ // For now, try to allocate 1 more buffer, but don't fail if unsuccessful
-+
-+ // Use conservative allocation while also trying to reduce starvation
-+ //
-+ // 1. allocate at least nBufferCountMin minUndequeuedBuffers - that is the
-+ // minimum needed for the consumer to be able to work
-+ // 2. try to allocate two (2) additional buffers to reduce starvation from
-+ // the consumer
-+ // plus an extra buffer to account for incorrect minUndequeuedBufs
-+ CODEC_LOGI("OMX-buffers: min=%u actual=%u undeq=%d1",
-+ def.nBufferCountMin, def.nBufferCountActual, minUndequeuedBufs);
-+#ifdef BOARD_CANT_REALLOCATE_OMX_BUFFERS
-+ // Some devices don't like to set OMX_IndexParamPortDefinition at this
-+ // point (even with an unmodified def), so skip it if possible.
-+ // This check was present in KitKat.
-+ if (def.nBufferCountActual < def.nBufferCountMin minUndequeuedBufs) {
-+#endif
-+ for (OMX_U32 extraBuffers = 2 1; /* condition inside loop */; extraBuffers--) {
-+ OMX_U32 newBufferCount =
-+ def.nBufferCountMin minUndequeuedBufs extraBuffers;
-+ def.nBufferCountActual = newBufferCount;
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+
-+ if (err == OK) {
-+ minUndequeuedBufs = extraBuffers;
-+ break;
-+ }
-+
-+ CODEC_LOGW("setting nBufferCountActual to %u failed: %d",
-+ newBufferCount, err);
-+ /* exit condition */
-+ if (extraBuffers == 0) {
-+ return err;
-+ }
-+ }
-+ CODEC_LOGI("OMX-buffers: min=%u actual=%u undeq=%d1",
-+ def.nBufferCountMin, def.nBufferCountActual, minUndequeuedBufs);
-+#ifdef BOARD_CANT_REALLOCATE_OMX_BUFFERS
-+ }
-+#endif
-+
-+ err = native_window_set_buffer_count(
-+ mNativeWindow.get(), def.nBufferCountActual);
-+ if (err != 0) {
-+ ALOGE("native_window_set_buffer_count failed: %s (%d)", strerror(-err),
-+ -err);
-+ return err;
-+ }
-+
-+ CODEC_LOGV("allocating %u buffers from a native window of size %u on "
-+ "output port", def.nBufferCountActual, def.nBufferSize);
-+
-+ // Dequeue buffers and send them to OMX
-+ for (OMX_U32 i = 0; i < def.nBufferCountActual; i) {
-+ ANativeWindowBuffer* buf;
-+ err = native_window_dequeue_buffer_and_wait(mNativeWindow.get(), &buf);
-+ if (err != 0) {
-+ ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), -err);
-+ break;
-+ }
-+
-+ sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(buf, false));
-+ BufferInfo info;
-+ info.mData = NULL;
-+ info.mSize = def.nBufferSize;
-+ info.mStatus = OWNED_BY_US;
-+ info.mMem = NULL;
-+ info.mMediaBuffer = new MediaBuffer(graphicBuffer);
-+ info.mMediaBuffer->setObserver(this);
-+ mPortBuffers[kPortIndexOutput].push(info);
-+
-+ IOMX::buffer_id bufferId;
-+ err = mOMX->useGraphicBuffer(mNode, kPortIndexOutput, graphicBuffer,
-+ &bufferId);
-+ if (err != 0) {
-+ CODEC_LOGE("registering GraphicBuffer with OMX IL component "
-+ "failed: %d", err);
-+ break;
-+ }
-+
-+ mPortBuffers[kPortIndexOutput].editItemAt(i).mBuffer = bufferId;
-+
-+ CODEC_LOGV("registered graphic buffer with ID %u (pointer = %p)",
-+ bufferId, graphicBuffer.get());
-+ }
-+
-+ OMX_U32 cancelStart;
-+ OMX_U32 cancelEnd;
-+ if (err != 0) {
-+ // If an error occurred while dequeuing we need to cancel any buffers
-+ // that were dequeued.
-+ cancelStart = 0;
-+ cancelEnd = mPortBuffers[kPortIndexOutput].size();
-+ } else {
-+ // Return the last two buffers to the native window.
-+ cancelStart = def.nBufferCountActual - minUndequeuedBufs;
-+ cancelEnd = def.nBufferCountActual;
-+ }
-+
-+ for (OMX_U32 i = cancelStart; i < cancelEnd; i) {
-+ BufferInfo *info = &mPortBuffers[kPortIndexOutput].editItemAt(i);
-+ cancelBufferToNativeWindow(info);
-+ }
-+
-+ return err;
-+}
-+
-+status_t OMXCodec::cancelBufferToNativeWindow(BufferInfo *info) {
-+ CHECK_EQ((int)info->mStatus, (int)OWNED_BY_US);
-+ CODEC_LOGV("Calling cancelBuffer on buffer %u", info->mBuffer);
-+ int err = mNativeWindow->cancelBuffer(
-+ mNativeWindow.get(), info->mMediaBuffer->graphicBuffer().get(), -1);
-+ if (err != 0) {
-+ CODEC_LOGE("cancelBuffer failed w/ error 0x%08x", err);
-+
-+ setState(ERROR);
-+ return err;
-+ }
-+ info->mStatus = OWNED_BY_NATIVE_WINDOW;
-+ return OK;
-+}
-+
-+OMXCodec::BufferInfo* OMXCodec::dequeueBufferFromNativeWindow() {
-+ // Dequeue the next buffer from the native window.
-+ ANativeWindowBuffer* buf;
-+ int err = native_window_dequeue_buffer_and_wait(mNativeWindow.get(), &buf);
-+ if (err != 0) {
-+ CODEC_LOGE("dequeueBuffer failed w/ error 0x%08x", err);
-+
-+ setState(ERROR);
-+ return 0;
-+ }
-+
-+ // Determine which buffer we just dequeued.
-+ Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];
-+ BufferInfo *bufInfo = 0;
-+ for (size_t i = 0; i < buffers->size(); i) {
-+ sp<GraphicBuffer> graphicBuffer = buffers->itemAt(i).
-+ mMediaBuffer->graphicBuffer();
-+ if (graphicBuffer->handle == buf->handle) {
-+ bufInfo = &buffers->editItemAt(i);
-+ break;
-+ }
-+ }
-+
-+ if (bufInfo == 0) {
-+ CODEC_LOGE("dequeued unrecognized buffer: %p", buf);
-+
-+ setState(ERROR);
-+ return 0;
-+ }
-+
-+ // The native window no longer owns the buffer.
-+ CHECK_EQ((int)bufInfo->mStatus, (int)OWNED_BY_NATIVE_WINDOW);
-+ bufInfo->mStatus = OWNED_BY_US;
-+
-+ return bufInfo;
-+}
-+
-+int64_t OMXCodec::getDecodingTimeUs() {
-+ CHECK(mIsEncoder && mIsVideo);
-+
-+ if (mDecodingTimeList.empty()) {
-+ CHECK(mSignalledEOS || mNoMoreOutputData);
-+ // No corresponding input frame available.
-+ // This could happen when EOS is reached.
-+ return 0;
-+ }
-+
-+ List<int64_t>::iterator it = mDecodingTimeList.begin();
-+ int64_t timeUs = *it;
-+ mDecodingTimeList.erase(it);
-+ return timeUs;
-+}
-+
-+void OMXCodec::on_message(const omx_message &msg) {
-+ if (mState == ERROR) {
-+ /*
-+ * only drop EVENT messages, EBD and FBD are still
-+ * processed for bookkeeping purposes
-+ */
-+ if (msg.type == omx_message::EVENT) {
-+ ALOGW("Dropping OMX EVENT message - we're in ERROR state.");
-+ return;
-+ }
-+ }
-+
-+ switch (msg.type) {
-+ case omx_message::EVENT:
-+ {
-+ onEvent(
-+ msg.u.event_data.event, msg.u.event_data.data1,
-+ msg.u.event_data.data2);
-+
-+ break;
-+ }
-+
-+ case omx_message::EMPTY_BUFFER_DONE:
-+ {
-+ IOMX::buffer_id buffer = msg.u.extended_buffer_data.buffer;
-+
-+ CODEC_LOGV("EMPTY_BUFFER_DONE(buffer: %u)", buffer);
-+
-+ Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexInput];
-+ size_t i = 0;
-+ while (i < buffers->size() && (*buffers)[i].mBuffer != buffer) {
-+ i;
-+ }
-+
-+ CHECK(i < buffers->size());
-+ if ((*buffers)[i].mStatus != OWNED_BY_COMPONENT) {
-+ ALOGW("We already own input buffer %u, yet received "
-+ "an EMPTY_BUFFER_DONE.", buffer);
-+ }
-+
-+ BufferInfo* info = &buffers->editItemAt(i);
-+ info->mStatus = OWNED_BY_US;
-+
-+ // Buffer could not be released until empty buffer done is called.
-+ if (info->mMediaBuffer != NULL) {
-+ info->mMediaBuffer->release();
-+ info->mMediaBuffer = NULL;
-+ }
-+
-+ if (mPortStatus[kPortIndexInput] == DISABLING) {
-+ CODEC_LOGV("Port is disabled, freeing buffer %u", buffer);
-+
-+ status_t err = freeBuffer(kPortIndexInput, i);
-+ CHECK_EQ(err, (status_t)OK);
-+ } else if (mState != ERROR
-+ && mPortStatus[kPortIndexInput] != SHUTTING_DOWN) {
-+ CHECK_EQ((int)mPortStatus[kPortIndexInput], (int)ENABLED);
-+
-+ if (mFlags & kUseSecureInputBuffers) {
-+ drainAnyInputBuffer();
-+ } else {
-+ drainInputBuffer(&buffers->editItemAt(i));
-+ }
-+ }
-+ break;
-+ }
-+
-+ case omx_message::FILL_BUFFER_DONE:
-+ {
-+ IOMX::buffer_id buffer = msg.u.extended_buffer_data.buffer;
-+ OMX_U32 flags = msg.u.extended_buffer_data.flags;
-+
-+ CODEC_LOGV("FILL_BUFFER_DONE(buffer: %u, size: %u, flags: 0x%08x, timestamp: %lld us (%.2f secs))",
-+ buffer,
-+ msg.u.extended_buffer_data.range_length,
-+ flags,
-+ msg.u.extended_buffer_data.timestamp,
-+ msg.u.extended_buffer_data.timestamp / 1E6);
-+
-+ Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];
-+ size_t i = 0;
-+ while (i < buffers->size() && (*buffers)[i].mBuffer != buffer) {
-+ i;
-+ }
-+
-+ CHECK(i < buffers->size());
-+ BufferInfo *info = &buffers->editItemAt(i);
-+
-+ if (info->mStatus != OWNED_BY_COMPONENT) {
-+ ALOGW("We already own output buffer %u, yet received "
-+ "a FILL_BUFFER_DONE.", buffer);
-+ }
-+
-+ info->mStatus = OWNED_BY_US;
-+
-+ if (mPortStatus[kPortIndexOutput] == DISABLING) {
-+ CODEC_LOGV("Port is disabled, freeing buffer %u", buffer);
-+
-+ status_t err = freeBuffer(kPortIndexOutput, i);
-+ CHECK_EQ(err, (status_t)OK);
-+
-+#if 0
-+ } else if (mPortStatus[kPortIndexOutput] == ENABLED
-+ && (flags & OMX_BUFFERFLAG_EOS)) {
-+ CODEC_LOGV("No more output data.");
-+ mNoMoreOutputData = true;
-+ mBufferFilled.signal();
-+#endif
-+ } else if (mPortStatus[kPortIndexOutput] != SHUTTING_DOWN) {
-+ CHECK_EQ((int)mPortStatus[kPortIndexOutput], (int)ENABLED);
-+
-+ MediaBuffer *buffer = info->mMediaBuffer;
-+ bool isGraphicBuffer = buffer->graphicBuffer() != NULL;
-+
-+ if (!isGraphicBuffer
-+ && msg.u.extended_buffer_data.range_offset
-+ msg.u.extended_buffer_data.range_length
-+ > buffer->size()) {
-+ CODEC_LOGE(
-+ "Codec lied about its buffer size requirements, "
-+ "sending a buffer larger than the originally "
-+ "advertised size in FILL_BUFFER_DONE!");
-+ }
-+ buffer->set_range(
-+ msg.u.extended_buffer_data.range_offset,
-+ msg.u.extended_buffer_data.range_length);
-+
-+ buffer->meta_data()->clear();
-+
-+ buffer->meta_data()->setInt64(
-+ kKeyTime, msg.u.extended_buffer_data.timestamp);
-+
-+ if (msg.u.extended_buffer_data.flags & OMX_BUFFERFLAG_SYNCFRAME) {
-+ buffer->meta_data()->setInt32(kKeyIsSyncFrame, true);
-+ }
-+ bool isCodecSpecific = false;
-+ if (msg.u.extended_buffer_data.flags & OMX_BUFFERFLAG_CODECCONFIG) {
-+ buffer->meta_data()->setInt32(kKeyIsCodecConfig, true);
-+ isCodecSpecific = true;
-+ }
-+
-+ if (isGraphicBuffer || mQuirks & kOutputBuffersAreUnreadable) {
-+ buffer->meta_data()->setInt32(kKeyIsUnreadable, true);
-+ }
-+
-+ buffer->meta_data()->setInt32(
-+ kKeyBufferID,
-+ msg.u.extended_buffer_data.buffer);
-+
-+ if (msg.u.extended_buffer_data.flags & OMX_BUFFERFLAG_EOS) {
-+ CODEC_LOGV("No more output data.");
-+ mNoMoreOutputData = true;
-+ }
-+
-+ if (mIsEncoder && mIsVideo) {
-+ int64_t decodingTimeUs = isCodecSpecific? 0: getDecodingTimeUs();
-+ buffer->meta_data()->setInt64(kKeyDecodingTime, decodingTimeUs);
-+ }
-+
-+ if (mTargetTimeUs >= 0) {
-+ CHECK(msg.u.extended_buffer_data.timestamp <= mTargetTimeUs);
-+
-+ if (msg.u.extended_buffer_data.timestamp < mTargetTimeUs) {
-+ CODEC_LOGV(
-+ "skipping output buffer at timestamp %lld us",
-+ msg.u.extended_buffer_data.timestamp);
-+
-+ fillOutputBuffer(info);
-+ break;
-+ }
-+
-+ CODEC_LOGV(
-+ "returning output buffer at target timestamp "
-+ "%lld us",
-+ msg.u.extended_buffer_data.timestamp);
-+
-+ mTargetTimeUs = -1;
-+ }
-+
-+ mFilledBuffers.push_back(i);
-+ mBufferFilled.signal();
-+ if (mIsEncoder) {
-+ sched_yield();
-+ }
-+ }
-+
-+ break;
-+ }
-+
-+ default:
-+ {
-+ CHECK(!"should not be here.");
-+ break;
-+ }
-+ }
-+}
-+
-+// Has the format changed in any way that the client would have to be aware of?
-+static bool formatHasNotablyChanged(
-+ const sp<MetaData> &from, const sp<MetaData> &to) {
-+ if (from.get() == NULL && to.get() == NULL) {
-+ return false;
-+ }
-+
-+ if ((from.get() == NULL && to.get() != NULL)
-+ || (from.get() != NULL && to.get() == NULL)) {
-+ return true;
-+ }
-+
-+ const char *mime_from, *mime_to;
-+ CHECK(from->findCString(kKeyMIMEType, &mime_from));
-+ CHECK(to->findCString(kKeyMIMEType, &mime_to));
-+
-+ if (strcasecmp(mime_from, mime_to)) {
-+ return true;
-+ }
-+
-+ if (!strcasecmp(mime_from, MEDIA_MIMETYPE_VIDEO_RAW)) {
-+ int32_t colorFormat_from, colorFormat_to;
-+ CHECK(from->findInt32(kKeyColorFormat, &colorFormat_from));
-+ CHECK(to->findInt32(kKeyColorFormat, &colorFormat_to));
-+
-+ if (colorFormat_from != colorFormat_to) {
-+ return true;
-+ }
-+
-+ int32_t width_from, width_to;
-+ CHECK(from->findInt32(kKeyWidth, &width_from));
-+ CHECK(to->findInt32(kKeyWidth, &width_to));
-+
-+ if (width_from != width_to) {
-+ return true;
-+ }
-+
-+ int32_t height_from, height_to;
-+ CHECK(from->findInt32(kKeyHeight, &height_from));
-+ CHECK(to->findInt32(kKeyHeight, &height_to));
-+
-+ if (height_from != height_to) {
-+ return true;
-+ }
-+
-+ int32_t left_from, top_from, right_from, bottom_from;
-+ CHECK(from->findRect(
-+ kKeyCropRect,
-+ &left_from, &top_from, &right_from, &bottom_from));
-+
-+ int32_t left_to, top_to, right_to, bottom_to;
-+ CHECK(to->findRect(
-+ kKeyCropRect,
-+ &left_to, &top_to, &right_to, &bottom_to));
-+
-+ if (left_to != left_from || top_to != top_from
-+ || right_to != right_from || bottom_to != bottom_from) {
-+ return true;
-+ }
-+ } else if (!strcasecmp(mime_from, MEDIA_MIMETYPE_AUDIO_RAW)) {
-+ int32_t numChannels_from, numChannels_to;
-+ CHECK(from->findInt32(kKeyChannelCount, &numChannels_from));
-+ CHECK(to->findInt32(kKeyChannelCount, &numChannels_to));
-+
-+ if (numChannels_from != numChannels_to) {
-+ return true;
-+ }
-+
-+ int32_t sampleRate_from, sampleRate_to;
-+ CHECK(from->findInt32(kKeySampleRate, &sampleRate_from));
-+ CHECK(to->findInt32(kKeySampleRate, &sampleRate_to));
-+
-+ if (sampleRate_from != sampleRate_to) {
-+ return true;
-+ }
-+ }
-+
-+ return false;
-+}
-+
-+void OMXCodec::onEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
-+ switch (event) {
-+ case OMX_EventCmdComplete:
-+ {
-+ onCmdComplete((OMX_COMMANDTYPE)data1, data2);
-+ break;
-+ }
-+
-+ case OMX_EventError:
-+ {
-+ CODEC_LOGE("OMX_EventError(0x%08x, %u)", data1, data2);
-+
-+ setState(ERROR);
-+ break;
-+ }
-+
-+ case OMX_EventPortSettingsChanged:
-+ {
-+ CODEC_LOGV("OMX_EventPortSettingsChanged(port=%u, data2=0x%08x)",
-+ data1, data2);
-+
-+ if (data2 == 0 || data2 == OMX_IndexParamPortDefinition) {
-+ onPortSettingsChanged(data1);
-+ } else if (data1 == kPortIndexOutput &&
-+ (data2 == OMX_IndexConfigCommonOutputCrop ||
-+ data2 == OMX_IndexConfigCommonScale)) {
-+
-+ sp<MetaData> oldOutputFormat = mOutputFormat;
-+ initOutputFormat(mSource->getFormat());
-+
-+ if (data2 == OMX_IndexConfigCommonOutputCrop &&
-+ formatHasNotablyChanged(oldOutputFormat, mOutputFormat)) {
-+ mOutputPortSettingsHaveChanged = true;
-+
-+ } else if (data2 == OMX_IndexConfigCommonScale) {
-+ OMX_CONFIG_SCALEFACTORTYPE scale;
-+ InitOMXParams(&scale);
-+ scale.nPortIndex = kPortIndexOutput;
-+
-+ // Change display dimension only when necessary.
-+ if (OK == mOMX->getConfig(
-+ mNode,
-+ OMX_IndexConfigCommonScale,
-+ &scale, sizeof(scale))) {
-+ int32_t left, top, right, bottom;
-+ CHECK(mOutputFormat->findRect(kKeyCropRect,
-+ &left, &top,
-+ &right, &bottom));
-+
-+ // The scale is in 16.16 format.
-+ // scale 1.0 = 0x010000. When there is no
-+ // need to change the display, skip it.
-+ ALOGV("Get OMX_IndexConfigScale: 0x%x/0x%x",
-+ scale.xWidth, scale.xHeight);
-+
-+ if (scale.xWidth != 0x010000) {
-+ mOutputFormat->setInt32(kKeyDisplayWidth,
-+ ((right - left 1) * scale.xWidth) >> 16);
-+ mOutputPortSettingsHaveChanged = true;
-+ }
-+
-+ if (scale.xHeight != 0x010000) {
-+ mOutputFormat->setInt32(kKeyDisplayHeight,
-+ ((bottom - top 1) * scale.xHeight) >> 16);
-+ mOutputPortSettingsHaveChanged = true;
-+ }
-+ }
-+ }
-+ }
-+ break;
-+ }
-+
-+#if 0
-+ case OMX_EventBufferFlag:
-+ {
-+ CODEC_LOGV("EVENT_BUFFER_FLAG(%ld)", data1);
-+
-+ if (data1 == kPortIndexOutput) {
-+ mNoMoreOutputData = true;
-+ }
-+ break;
-+ }
-+#endif
-+#ifdef USE_S3D_SUPPORT
-+ case (OMX_EVENTTYPE)OMX_EventS3DInformation:
-+ {
-+ sp<IServiceManager> sm = defaultServiceManager();
-+ sp<android::IExynosHWCService> hwc = interface_cast<android::IExynosHWCService>(
-+ sm->getService(String16("Exynos.HWCService")));
-+ if (hwc != NULL) {
-+ if (data1 == OMX_TRUE) {
-+ int eS3DMode;
-+ switch (data2) {
-+ case OMX_SEC_FPARGMT_SIDE_BY_SIDE:
-+ eS3DMode = S3D_SBS;
-+ break;
-+ case OMX_SEC_FPARGMT_TOP_BOTTOM:
-+ eS3DMode = S3D_TB;
-+ break;
-+ case OMX_SEC_FPARGMT_CHECKERBRD_INTERL: // unsupport format at HDMI
-+ case OMX_SEC_FPARGMT_COLUMN_INTERL:
-+ case OMX_SEC_FPARGMT_ROW_INTERL:
-+ case OMX_SEC_FPARGMT_TEMPORAL_INTERL:
-+ default:
-+ eS3DMode = S3D_NONE;
-+ }
-+
-+ hwc->setHdmiResolution(0, eS3DMode);
-+ }
-+ } else {
-+ ALOGE("Exynos.HWCService is unavailable");
-+ }
-+ break;
-+ }
-+#endif
-+ default:
-+ {
-+ CODEC_LOGV("EVENT(%d, %u, %u)", event, data1, data2);
-+ break;
-+ }
-+ }
-+}
-+
-+void OMXCodec::onCmdComplete(OMX_COMMANDTYPE cmd, OMX_U32 data) {
-+ switch (cmd) {
-+ case OMX_CommandStateSet:
-+ {
-+ onStateChange((OMX_STATETYPE)data);
-+ break;
-+ }
-+
-+ case OMX_CommandPortDisable:
-+ {
-+ OMX_U32 portIndex = data;
-+ CODEC_LOGV("PORT_DISABLED(%u)", portIndex);
-+
-+ CHECK(mState == EXECUTING || mState == RECONFIGURING);
-+ CHECK_EQ((int)mPortStatus[portIndex], (int)DISABLING);
-+ CHECK_EQ(mPortBuffers[portIndex].size(), 0u);
-+
-+ mPortStatus[portIndex] = DISABLED;
-+
-+ if (mState == RECONFIGURING) {
-+ CHECK_EQ(portIndex, (OMX_U32)kPortIndexOutput);
-+
-+ sp<MetaData> oldOutputFormat = mOutputFormat;
-+ initOutputFormat(mSource->getFormat());
-+
-+ // Don't notify clients if the output port settings change
-+ // wasn't of importance to them, i.e. it may be that just the
-+ // number of buffers has changed and nothing else.
-+ bool formatChanged = formatHasNotablyChanged(oldOutputFormat, mOutputFormat);
-+ if (!mOutputPortSettingsHaveChanged) {
-+ mOutputPortSettingsHaveChanged = formatChanged;
-+ }
-+
-+ status_t err = enablePortAsync(portIndex);
-+ if (err != OK) {
-+ CODEC_LOGE("enablePortAsync(%u) failed (err = %d)", portIndex, err);
-+ setState(ERROR);
-+ } else {
-+ err = allocateBuffersOnPort(portIndex);
-+ if (err != OK) {
-+ CODEC_LOGE("allocateBuffersOnPort (%s) failed "
-+ "(err = %d)",
-+ portIndex == kPortIndexInput
-+ ? "input" : "output",
-+ err);
-+
-+ setState(ERROR);
-+ }
-+ }
-+ }
-+ break;
-+ }
-+
-+ case OMX_CommandPortEnable:
-+ {
-+ OMX_U32 portIndex = data;
-+ CODEC_LOGV("PORT_ENABLED(%u)", portIndex);
-+
-+ CHECK(mState == EXECUTING || mState == RECONFIGURING);
-+ CHECK_EQ((int)mPortStatus[portIndex], (int)ENABLING);
-+
-+ mPortStatus[portIndex] = ENABLED;
-+
-+ if (mState == RECONFIGURING) {
-+ CHECK_EQ(portIndex, (OMX_U32)kPortIndexOutput);
-+
-+ setState(EXECUTING);
-+
-+ fillOutputBuffers();
-+ }
-+ break;
-+ }
-+
-+ case OMX_CommandFlush:
-+ {
-+ OMX_U32 portIndex = data;
-+
-+ CODEC_LOGV("FLUSH_DONE(%u)", portIndex);
-+
-+ CHECK_EQ((int)mPortStatus[portIndex], (int)SHUTTING_DOWN);
-+ mPortStatus[portIndex] = ENABLED;
-+
-+ CHECK_EQ(countBuffersWeOwn(mPortBuffers[portIndex]),
-+ mPortBuffers[portIndex].size());
-+
-+ if (mSkipCutBuffer != NULL && mPortStatus[kPortIndexOutput] == ENABLED) {
-+ mSkipCutBuffer->clear();
-+ }
-+
-+ if (mState == RECONFIGURING) {
-+ CHECK_EQ(portIndex, (OMX_U32)kPortIndexOutput);
-+
-+ disablePortAsync(portIndex);
-+ } else if (mState == EXECUTING_TO_IDLE) {
-+ if (mPortStatus[kPortIndexInput] == ENABLED
-+ && mPortStatus[kPortIndexOutput] == ENABLED) {
-+ CODEC_LOGV("Finished flushing both ports, now completing "
-+ "transition from EXECUTING to IDLE.");
-+
-+ mPortStatus[kPortIndexInput] = SHUTTING_DOWN;
-+ mPortStatus[kPortIndexOutput] = SHUTTING_DOWN;
-+
-+ status_t err =
-+ mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
-+ CHECK_EQ(err, (status_t)OK);
-+ }
-+ } else {
-+ // We're flushing both ports in preparation for seeking.
-+
-+ if (mPortStatus[kPortIndexInput] == ENABLED
-+ && mPortStatus[kPortIndexOutput] == ENABLED) {
-+ CODEC_LOGV("Finished flushing both ports, now continuing from"
-+ " seek-time.");
-+
-+ // We implicitly resume pulling on our upstream source.
-+ mPaused = false;
-+ mNoMoreOutputData = false;
-+
-+ drainInputBuffers();
-+ fillOutputBuffers();
-+ }
-+
-+ if (mOutputPortSettingsChangedPending) {
-+ CODEC_LOGV(
-+ "Honoring deferred output port settings change.");
-+
-+ mOutputPortSettingsChangedPending = false;
-+ onPortSettingsChanged(kPortIndexOutput);
-+ }
-+ }
-+
-+ break;
-+ }
-+
-+ default:
-+ {
-+ CODEC_LOGV("CMD_COMPLETE(%d, %u)", cmd, data);
-+ break;
-+ }
-+ }
-+}
-+
-+void OMXCodec::onStateChange(OMX_STATETYPE newState) {
-+ CODEC_LOGV("onStateChange %d", newState);
-+
-+ switch (newState) {
-+ case OMX_StateIdle:
-+ {
-+ CODEC_LOGV("Now Idle.");
-+ if (mState == LOADED_TO_IDLE) {
-+ status_t err = mOMX->sendCommand(
-+ mNode, OMX_CommandStateSet, OMX_StateExecuting);
-+
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ setState(IDLE_TO_EXECUTING);
-+ } else {
-+ CHECK_EQ((int)mState, (int)EXECUTING_TO_IDLE);
-+
-+ if (countBuffersWeOwn(mPortBuffers[kPortIndexInput]) !=
-+ mPortBuffers[kPortIndexInput].size()) {
-+ ALOGE("Codec did not return all input buffers "
-+ "(received %zu / %zu)",
-+ countBuffersWeOwn(mPortBuffers[kPortIndexInput]),
-+ mPortBuffers[kPortIndexInput].size());
-+ TRESPASS();
-+ }
-+
-+ if (countBuffersWeOwn(mPortBuffers[kPortIndexOutput]) !=
-+ mPortBuffers[kPortIndexOutput].size()) {
-+ ALOGE("Codec did not return all output buffers "
-+ "(received %zu / %zu)",
-+ countBuffersWeOwn(mPortBuffers[kPortIndexOutput]),
-+ mPortBuffers[kPortIndexOutput].size());
-+ TRESPASS();
-+ }
-+
-+ status_t err = mOMX->sendCommand(
-+ mNode, OMX_CommandStateSet, OMX_StateLoaded);
-+
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ err = freeBuffersOnPort(kPortIndexInput);
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ err = freeBuffersOnPort(kPortIndexOutput);
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ mPortStatus[kPortIndexInput] = ENABLED;
-+ mPortStatus[kPortIndexOutput] = ENABLED;
-+
-+ if ((mFlags & kEnableGrallocUsageProtected) &&
-+ mNativeWindow != NULL) {
-+ // We push enough 1x1 blank buffers to ensure that one of
-+ // them has made it to the display. This allows the OMX
-+ // component teardown to zero out any protected buffers
-+ // without the risk of scanning out one of those buffers.
-+ pushBlankBuffersToNativeWindow(mNativeWindow.get());
-+ }
-+
-+ setState(IDLE_TO_LOADED);
-+ }
-+ break;
-+ }
-+
-+ case OMX_StateExecuting:
-+ {
-+ CHECK_EQ((int)mState, (int)IDLE_TO_EXECUTING);
-+
-+ CODEC_LOGV("Now Executing.");
-+
-+ mOutputPortSettingsChangedPending = false;
-+
-+ setState(EXECUTING);
-+
-+ // Buffers will be submitted to the component in the first
-+ // call to OMXCodec::read as mInitialBufferSubmit is true at
-+ // this point. This ensures that this on_message call returns,
-+ // releases the lock and ::init can notice the state change and
-+ // itself return.
-+ break;
-+ }
-+
-+ case OMX_StateLoaded:
-+ {
-+ CHECK_EQ((int)mState, (int)IDLE_TO_LOADED);
-+
-+ CODEC_LOGV("Now Loaded.");
-+
-+ setState(LOADED);
-+ break;
-+ }
-+
-+ case OMX_StatePause:
-+ {
-+ CODEC_LOGV("Now paused.");
-+ CHECK_EQ((int)mState, (int)PAUSING);
-+ setState(PAUSED);
-+ break;
-+ }
-+
-+ case OMX_StateInvalid:
-+ {
-+ setState(ERROR);
-+ break;
-+ }
-+
-+ default:
-+ {
-+ CHECK(!"should not be here.");
-+ break;
-+ }
-+ }
-+}
-+
-+// static
-+size_t OMXCodec::countBuffersWeOwn(const Vector<BufferInfo> &buffers) {
-+ size_t n = 0;
-+ for (size_t i = 0; i < buffers.size(); i) {
-+ if (buffers[i].mStatus != OWNED_BY_COMPONENT) {
-+ n;
-+ }
-+ }
-+
-+ return n;
-+}
-+
-+status_t OMXCodec::freeBuffersOnPort(
-+ OMX_U32 portIndex, bool onlyThoseWeOwn) {
-+ Vector<BufferInfo> *buffers = &mPortBuffers[portIndex];
-+
-+ status_t stickyErr = OK;
-+
-+ for (size_t i = buffers->size(); i > 0;) {
-+ i--;
-+ BufferInfo *info = &buffers->editItemAt(i);
-+
-+ if (onlyThoseWeOwn && info->mStatus == OWNED_BY_COMPONENT) {
-+ continue;
-+ }
-+
-+ CHECK(info->mStatus == OWNED_BY_US
-+ || info->mStatus == OWNED_BY_NATIVE_WINDOW);
-+
-+ CODEC_LOGV("freeing buffer %u on port %u", info->mBuffer, portIndex);
-+
-+ status_t err = freeBuffer(portIndex, i);
-+
-+ if (err != OK) {
-+ stickyErr = err;
-+ }
-+
-+ }
-+
-+ CHECK(onlyThoseWeOwn || buffers->isEmpty());
-+
-+ return stickyErr;
-+}
-+
-+status_t OMXCodec::freeBuffer(OMX_U32 portIndex, size_t bufIndex) {
-+ Vector<BufferInfo> *buffers = &mPortBuffers[portIndex];
-+
-+ BufferInfo *info = &buffers->editItemAt(bufIndex);
-+
-+ status_t err = mOMX->freeBuffer(mNode, portIndex, info->mBuffer);
-+
-+ if (err == OK && info->mMediaBuffer != NULL) {
-+ CHECK_EQ(portIndex, (OMX_U32)kPortIndexOutput);
-+ info->mMediaBuffer->setObserver(NULL);
-+
-+ // Make sure nobody but us owns this buffer at this point.
-+ CHECK_EQ(info->mMediaBuffer->refcount(), 0);
-+
-+ // Cancel the buffer if it belongs to an ANativeWindow.
-+ sp<GraphicBuffer> graphicBuffer = info->mMediaBuffer->graphicBuffer();
-+ if (info->mStatus == OWNED_BY_US && graphicBuffer != 0) {
-+ err = cancelBufferToNativeWindow(info);
-+ }
-+
-+ info->mMediaBuffer->release();
-+ info->mMediaBuffer = NULL;
-+ }
-+
-+ if (err == OK) {
-+ buffers->removeAt(bufIndex);
-+ }
-+
-+ return err;
-+}
-+
-+void OMXCodec::onPortSettingsChanged(OMX_U32 portIndex) {
-+ CODEC_LOGV("PORT_SETTINGS_CHANGED(%u)", portIndex);
-+
-+ CHECK(mState == EXECUTING || mState == EXECUTING_TO_IDLE);
-+ CHECK_EQ(portIndex, (OMX_U32)kPortIndexOutput);
-+ CHECK(!mOutputPortSettingsChangedPending);
-+
-+ if (mPortStatus[kPortIndexOutput] != ENABLED) {
-+ CODEC_LOGV("Deferring output port settings change.");
-+ mOutputPortSettingsChangedPending = true;
-+ return;
-+ }
-+
-+ setState(RECONFIGURING);
-+
-+ if (mQuirks & kNeedsFlushBeforeDisable) {
-+ if (!flushPortAsync(portIndex)) {
-+ onCmdComplete(OMX_CommandFlush, portIndex);
-+ }
-+ } else {
-+ disablePortAsync(portIndex);
-+ }
-+}
-+
-+bool OMXCodec::flushPortAsync(OMX_U32 portIndex) {
-+ CHECK(mState == EXECUTING || mState == RECONFIGURING
-+ || mState == EXECUTING_TO_IDLE || mState == FLUSHING);
-+
-+ CODEC_LOGV("flushPortAsync(%u): we own %zu out of %zu buffers already.",
-+ portIndex, countBuffersWeOwn(mPortBuffers[portIndex]),
-+ mPortBuffers[portIndex].size());
-+
-+ CHECK_EQ((int)mPortStatus[portIndex], (int)ENABLED);
-+ mPortStatus[portIndex] = SHUTTING_DOWN;
-+
-+ if ((mQuirks & kRequiresFlushCompleteEmulation)
-+ && countBuffersWeOwn(mPortBuffers[portIndex])
-+ == mPortBuffers[portIndex].size()) {
-+ // No flush is necessary and this component fails to send a
-+ // flush-complete event in this case.
-+
-+ return false;
-+ }
-+
-+ status_t err =
-+ mOMX->sendCommand(mNode, OMX_CommandFlush, portIndex);
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ return true;
-+}
-+
-+void OMXCodec::disablePortAsync(OMX_U32 portIndex) {
-+ CHECK(mState == EXECUTING || mState == RECONFIGURING);
-+
-+ CHECK_EQ((int)mPortStatus[portIndex], (int)ENABLED);
-+ mPortStatus[portIndex] = DISABLING;
-+
-+ CODEC_LOGV("sending OMX_CommandPortDisable(%u)", portIndex);
-+ status_t err =
-+ mOMX->sendCommand(mNode, OMX_CommandPortDisable, portIndex);
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ freeBuffersOnPort(portIndex, true);
-+}
-+
-+status_t OMXCodec::enablePortAsync(OMX_U32 portIndex) {
-+ CHECK(mState == EXECUTING || mState == RECONFIGURING);
-+
-+ CHECK_EQ((int)mPortStatus[portIndex], (int)DISABLED);
-+ mPortStatus[portIndex] = ENABLING;
-+
-+ CODEC_LOGV("sending OMX_CommandPortEnable(%u)", portIndex);
-+ return mOMX->sendCommand(mNode, OMX_CommandPortEnable, portIndex);
-+}
-+
-+void OMXCodec::fillOutputBuffers() {
-+ CHECK(mState == EXECUTING || mState == FLUSHING);
-+
-+ // This is a workaround for some decoders not properly reporting
-+ // end-of-output-stream. If we own all input buffers and also own
-+ // all output buffers and we already signalled end-of-input-stream,
-+ // the end-of-output-stream is implied.
-+ if (mSignalledEOS
-+ && countBuffersWeOwn(mPortBuffers[kPortIndexInput])
-+ == mPortBuffers[kPortIndexInput].size()
-+ && countBuffersWeOwn(mPortBuffers[kPortIndexOutput])
-+ == mPortBuffers[kPortIndexOutput].size()) {
-+ mNoMoreOutputData = true;
-+ mBufferFilled.signal();
-+
-+ return;
-+ }
-+
-+ Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];
-+ for (size_t i = 0; i < buffers->size(); i) {
-+ BufferInfo *info = &buffers->editItemAt(i);
-+ if (info->mStatus == OWNED_BY_US) {
-+ fillOutputBuffer(&buffers->editItemAt(i));
-+ }
-+ }
-+}
-+
-+void OMXCodec::drainInputBuffers() {
-+ CHECK(mState == EXECUTING || mState == RECONFIGURING || mState == FLUSHING);
-+
-+ if (mFlags & kUseSecureInputBuffers) {
-+ Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexInput];
-+ for (size_t i = 0; i < buffers->size(); i) {
-+ if (!drainAnyInputBuffer()
-+ || (mFlags & kOnlySubmitOneInputBufferAtOneTime)) {
-+ break;
-+ }
-+ }
-+ } else {
-+ Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexInput];
-+ for (size_t i = 0; i < buffers->size(); i) {
-+ BufferInfo *info = &buffers->editItemAt(i);
-+
-+ if (info->mStatus != OWNED_BY_US) {
-+ continue;
-+ }
-+
-+ if (!drainInputBuffer(info)) {
-+ break;
-+ }
-+
-+ if (mFlags & kOnlySubmitOneInputBufferAtOneTime) {
-+ break;
-+ }
-+ }
-+ }
-+}
-+
-+bool OMXCodec::drainAnyInputBuffer() {
-+ return drainInputBuffer((BufferInfo *)NULL);
-+}
-+
-+OMXCodec::BufferInfo *OMXCodec::findInputBufferByDataPointer(void *ptr) {
-+ Vector<BufferInfo> *infos = &mPortBuffers[kPortIndexInput];
-+ for (size_t i = 0; i < infos->size(); i) {
-+ BufferInfo *info = &infos->editItemAt(i);
-+
-+ if (info->mData == ptr) {
-+ CODEC_LOGV(
-+ "input buffer data ptr = %p, buffer_id = %u",
-+ ptr,
-+ info->mBuffer);
-+
-+ return info;
-+ }
-+ }
-+
-+ TRESPASS();
-+}
-+
-+OMXCodec::BufferInfo *OMXCodec::findEmptyInputBuffer() {
-+ Vector<BufferInfo> *infos = &mPortBuffers[kPortIndexInput];
-+ for (size_t i = 0; i < infos->size(); i) {
-+ BufferInfo *info = &infos->editItemAt(i);
-+
-+ if (info->mStatus == OWNED_BY_US) {
-+ return info;
-+ }
-+ }
-+
-+ TRESPASS();
-+}
-+
-+bool OMXCodec::drainInputBuffer(BufferInfo *info) {
-+ if (info != NULL) {
-+ CHECK_EQ((int)info->mStatus, (int)OWNED_BY_US);
-+ }
-+
-+ if (mSignalledEOS) {
-+ return false;
-+ }
-+
-+ if (mCodecSpecificDataIndex < mCodecSpecificData.size()) {
-+ CHECK(!(mFlags & kUseSecureInputBuffers));
-+
-+ const CodecSpecificData *specific =
-+ mCodecSpecificData[mCodecSpecificDataIndex];
-+
-+ size_t size = specific->mSize;
-+
-+ if ((!strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mMIME) ||
-+ !strcasecmp(MEDIA_MIMETYPE_VIDEO_HEVC, mMIME))
-+ && !(mQuirks & kWantsNALFragments)) {
-+ static const uint8_t kNALStartCode[4] =
-+ { 0x00, 0x00, 0x00, 0x01 };
-+
-+ CHECK(info->mSize >= specific->mSize 4);
-+
-+ size = 4;
-+
-+ memcpy(info->mData, kNALStartCode, 4);
-+ memcpy((uint8_t *)info->mData 4,
-+ specific->mData, specific->mSize);
-+ } else {
-+ CHECK(info->mSize >= specific->mSize);
-+ memcpy(info->mData, specific->mData, specific->mSize);
-+ }
-+
-+ mNoMoreOutputData = false;
-+
-+ CODEC_LOGV("calling emptyBuffer with codec specific data");
-+
-+ status_t err = mOMX->emptyBuffer(
-+ mNode, info->mBuffer, 0, size,
-+ OMX_BUFFERFLAG_ENDOFFRAME | OMX_BUFFERFLAG_CODECCONFIG,
-+ 0);
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ info->mStatus = OWNED_BY_COMPONENT;
-+
-+ mCodecSpecificDataIndex;
-+ return true;
-+ }
-+
-+ if (mPaused) {
-+ return false;
-+ }
-+
-+ status_t err;
-+
-+ bool signalEOS = false;
-+ int64_t timestampUs = 0;
-+
-+ size_t offset = 0;
-+ int32_t n = 0;
-+
-+
-+ for (;;) {
-+ MediaBuffer *srcBuffer;
-+ if (mSeekTimeUs >= 0) {
-+ if (mLeftOverBuffer) {
-+ mLeftOverBuffer->release();
-+ mLeftOverBuffer = NULL;
-+ }
-+
-+ MediaSource::ReadOptions options;
-+ options.setSeekTo(mSeekTimeUs, mSeekMode);
-+
-+ mSeekTimeUs = -1;
-+ mSeekMode = ReadOptions::SEEK_CLOSEST_SYNC;
-+ mBufferFilled.signal();
-+
-+ err = mSource->read(&srcBuffer, &options);
-+
-+ if (err == OK) {
-+ int64_t targetTimeUs;
-+ if (srcBuffer->meta_data()->findInt64(
-+ kKeyTargetTime, &targetTimeUs)
-+ && targetTimeUs >= 0) {
-+ CODEC_LOGV("targetTimeUs = %lld us", (long long)targetTimeUs);
-+ mTargetTimeUs = targetTimeUs;
-+ } else {
-+ mTargetTimeUs = -1;
-+ }
-+ }
-+ } else if (mLeftOverBuffer) {
-+ srcBuffer = mLeftOverBuffer;
-+ mLeftOverBuffer = NULL;
-+
-+ err = OK;
-+ } else {
-+ err = mSource->read(&srcBuffer);
-+ }
-+
-+ if (err != OK) {
-+ signalEOS = true;
-+ mFinalStatus = err;
-+ mSignalledEOS = true;
-+ mBufferFilled.signal();
-+ break;
-+ }
-+
-+ if (mFlags & kUseSecureInputBuffers) {
-+ info = findInputBufferByDataPointer(srcBuffer->data());
-+ CHECK(info != NULL);
-+ }
-+
-+ size_t remainingBytes = info->mSize - offset;
-+
-+ if (srcBuffer->range_length() > remainingBytes) {
-+ if (offset == 0) {
-+ CODEC_LOGE(
-+ "Codec's input buffers are too small to accomodate "
-+ "buffer read from source (info->mSize = %zu, srcLength = %zu)",
-+ info->mSize, srcBuffer->range_length());
-+
-+ srcBuffer->release();
-+ srcBuffer = NULL;
-+
-+ setState(ERROR);
-+ return false;
-+ }
-+
-+ mLeftOverBuffer = srcBuffer;
-+ break;
-+ }
-+
-+ bool releaseBuffer = true;
-+ if (mFlags & kStoreMetaDataInVideoBuffers) {
-+ releaseBuffer = false;
-+ info->mMediaBuffer = srcBuffer;
-+ }
-+
-+ if (mFlags & kUseSecureInputBuffers) {
-+ // Data in "info" is already provided at this time.
-+
-+ releaseBuffer = false;
-+
-+ CHECK(info->mMediaBuffer == NULL);
-+ info->mMediaBuffer = srcBuffer;
-+ } else {
-+ CHECK(srcBuffer->data() != NULL) ;
-+ memcpy((uint8_t *)info->mData offset,
-+ (const uint8_t *)srcBuffer->data()
-+ srcBuffer->range_offset(),
-+ srcBuffer->range_length());
-+ }
-+
-+ int64_t lastBufferTimeUs;
-+ CHECK(srcBuffer->meta_data()->findInt64(kKeyTime, &lastBufferTimeUs));
-+ CHECK(lastBufferTimeUs >= 0);
-+ if (mIsEncoder && mIsVideo) {
-+ mDecodingTimeList.push_back(lastBufferTimeUs);
-+ }
-+
-+ if (offset == 0) {
-+ timestampUs = lastBufferTimeUs;
-+ }
-+
-+ offset = srcBuffer->range_length();
-+
-+ if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_VORBIS, mMIME)) {
-+ CHECK(!(mQuirks & kSupportsMultipleFramesPerInputBuffer));
-+ CHECK_GE(info->mSize, offset sizeof(int32_t));
-+
-+ int32_t numPageSamples;
-+ if (!srcBuffer->meta_data()->findInt32(
-+ kKeyValidSamples, &numPageSamples)) {
-+ numPageSamples = -1;
-+ }
-+
-+ memcpy((uint8_t *)info->mData offset,
-+ &numPageSamples,
-+ sizeof(numPageSamples));
-+
-+ offset = sizeof(numPageSamples);
-+ }
-+
-+ if (releaseBuffer) {
-+ srcBuffer->release();
-+ srcBuffer = NULL;
-+ }
-+
-+ n;
-+
-+ if (!(mQuirks & kSupportsMultipleFramesPerInputBuffer)) {
-+ break;
-+ }
-+
-+ int64_t coalescedDurationUs = lastBufferTimeUs - timestampUs;
-+
-+ if (coalescedDurationUs > 250000ll) {
-+ // Don't coalesce more than 250ms worth of encoded data at once.
-+ break;
-+ }
-+ }
-+
-+ if (n > 1) {
-+ ALOGV("coalesced %d frames into one input buffer", n);
-+ }
-+
-+ OMX_U32 flags = OMX_BUFFERFLAG_ENDOFFRAME;
-+
-+ if (signalEOS) {
-+ flags |= OMX_BUFFERFLAG_EOS;
-+ } else {
-+ mNoMoreOutputData = false;
-+ }
-+
-+ if (info == NULL) {
-+ CHECK(mFlags & kUseSecureInputBuffers);
-+ CHECK(signalEOS);
-+
-+ // This is fishy, there's still a MediaBuffer corresponding to this
-+ // info available to the source at this point even though we're going
-+ // to use it to signal EOS to the codec.
-+ info = findEmptyInputBuffer();
-+ }
-+
-+ CODEC_LOGV("Calling emptyBuffer on buffer %u (length %zu), "
-+ "timestamp %lld us (%.2f secs)",
-+ info->mBuffer, offset,
-+ (long long)timestampUs, timestampUs / 1E6);
-+
-+ err = mOMX->emptyBuffer(
-+ mNode, info->mBuffer, 0, offset,
-+ flags, timestampUs);
-+
-+ if (err != OK) {
-+ setState(ERROR);
-+ return false;
-+ }
-+
-+ info->mStatus = OWNED_BY_COMPONENT;
-+
-+ return true;
-+}
-+
-+void OMXCodec::fillOutputBuffer(BufferInfo *info) {
-+ CHECK_EQ((int)info->mStatus, (int)OWNED_BY_US);
-+
-+ if (mNoMoreOutputData) {
-+ CODEC_LOGV("There is no more output data available, not "
-+ "calling fillOutputBuffer");
-+ return;
-+ }
-+
-+ CODEC_LOGV("Calling fillBuffer on buffer %u", info->mBuffer);
-+ status_t err = mOMX->fillBuffer(mNode, info->mBuffer);
-+
-+ if (err != OK) {
-+ CODEC_LOGE("fillBuffer failed w/ error 0x%08x", err);
-+
-+ setState(ERROR);
-+ return;
-+ }
-+
-+ info->mStatus = OWNED_BY_COMPONENT;
-+}
-+
-+bool OMXCodec::drainInputBuffer(IOMX::buffer_id buffer) {
-+ Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexInput];
-+ for (size_t i = 0; i < buffers->size(); i) {
-+ if ((*buffers)[i].mBuffer == buffer) {
-+ return drainInputBuffer(&buffers->editItemAt(i));
-+ }
-+ }
-+
-+ CHECK(!"should not be here.");
-+
-+ return false;
-+}
-+
-+void OMXCodec::fillOutputBuffer(IOMX::buffer_id buffer) {
-+ Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];
-+ for (size_t i = 0; i < buffers->size(); i) {
-+ if ((*buffers)[i].mBuffer == buffer) {
-+ fillOutputBuffer(&buffers->editItemAt(i));
-+ return;
-+ }
-+ }
-+
-+ CHECK(!"should not be here.");
-+}
-+
-+void OMXCodec::setState(State newState) {
-+ mState = newState;
-+ mAsyncCompletion.signal();
-+
-+ // This may cause some spurious wakeups but is necessary to
-+ // unblock the reader if we enter ERROR state.
-+ mBufferFilled.signal();
-+}
-+
-+status_t OMXCodec::waitForBufferFilled_l() {
-+
-+ if (mIsEncoder) {
-+ // For timelapse video recording, the timelapse video recording may
-+ // not send an input frame for a _long_ time. Do not use timeout
-+ // for video encoding.
-+ return mBufferFilled.wait(mLock);
-+ }
-+ status_t err = mBufferFilled.waitRelative(mLock, kBufferFilledEventTimeOutNs);
-+ if (err != OK) {
-+ CODEC_LOGE("Timed out waiting for output buffers: %zu/%zu",
-+ countBuffersWeOwn(mPortBuffers[kPortIndexInput]),
-+ countBuffersWeOwn(mPortBuffers[kPortIndexOutput]));
-+ }
-+ return err;
-+}
-+
-+void OMXCodec::setRawAudioFormat(
-+ OMX_U32 portIndex, int32_t sampleRate, int32_t numChannels) {
-+
-+ // port definition
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = portIndex;
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+ def.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
-+ CHECK_EQ(mOMX->setParameter(mNode, OMX_IndexParamPortDefinition,
-+ &def, sizeof(def)), (status_t)OK);
-+
-+ // pcm param
-+ OMX_AUDIO_PARAM_PCMMODETYPE pcmParams;
-+ InitOMXParams(&pcmParams);
-+ pcmParams.nPortIndex = portIndex;
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams));
-+
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ pcmParams.nChannels = numChannels;
-+ pcmParams.eNumData = OMX_NumericalDataSigned;
-+ pcmParams.bInterleaved = OMX_TRUE;
-+ pcmParams.nBitPerSample = 16;
-+ pcmParams.nSamplingRate = sampleRate;
-+ pcmParams.ePCMMode = OMX_AUDIO_PCMModeLinear;
-+
-+ CHECK_EQ(getOMXChannelMapping(
-+ numChannels, pcmParams.eChannelMapping), (status_t)OK);
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams));
-+
-+ CHECK_EQ(err, (status_t)OK);
-+}
-+
-+static OMX_AUDIO_AMRBANDMODETYPE pickModeFromBitRate(bool isAMRWB, int32_t bps) {
-+ if (isAMRWB) {
-+ if (bps <= 6600) {
-+ return OMX_AUDIO_AMRBandModeWB0;
-+ } else if (bps <= 8850) {
-+ return OMX_AUDIO_AMRBandModeWB1;
-+ } else if (bps <= 12650) {
-+ return OMX_AUDIO_AMRBandModeWB2;
-+ } else if (bps <= 14250) {
-+ return OMX_AUDIO_AMRBandModeWB3;
-+ } else if (bps <= 15850) {
-+ return OMX_AUDIO_AMRBandModeWB4;
-+ } else if (bps <= 18250) {
-+ return OMX_AUDIO_AMRBandModeWB5;
-+ } else if (bps <= 19850) {
-+ return OMX_AUDIO_AMRBandModeWB6;
-+ } else if (bps <= 23050) {
-+ return OMX_AUDIO_AMRBandModeWB7;
-+ }
-+
-+ // 23850 bps
-+ return OMX_AUDIO_AMRBandModeWB8;
-+ } else { // AMRNB
-+ if (bps <= 4750) {
-+ return OMX_AUDIO_AMRBandModeNB0;
-+ } else if (bps <= 5150) {
-+ return OMX_AUDIO_AMRBandModeNB1;
-+ } else if (bps <= 5900) {
-+ return OMX_AUDIO_AMRBandModeNB2;
-+ } else if (bps <= 6700) {
-+ return OMX_AUDIO_AMRBandModeNB3;
-+ } else if (bps <= 7400) {
-+ return OMX_AUDIO_AMRBandModeNB4;
-+ } else if (bps <= 7950) {
-+ return OMX_AUDIO_AMRBandModeNB5;
-+ } else if (bps <= 10200) {
-+ return OMX_AUDIO_AMRBandModeNB6;
-+ }
-+
-+ // 12200 bps
-+ return OMX_AUDIO_AMRBandModeNB7;
-+ }
-+}
-+
-+void OMXCodec::setAMRFormat(bool isWAMR, int32_t bitRate) {
-+ OMX_U32 portIndex = mIsEncoder ? kPortIndexOutput : kPortIndexInput;
-+
-+ OMX_AUDIO_PARAM_AMRTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = portIndex;
-+
-+ status_t err =
-+ mOMX->getParameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def));
-+
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ def.eAMRFrameFormat = OMX_AUDIO_AMRFrameFormatFSF;
-+
-+ def.eAMRBandMode = pickModeFromBitRate(isWAMR, bitRate);
-+ err = mOMX->setParameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ ////////////////////////
-+
-+ if (mIsEncoder) {
-+ sp<MetaData> format = mSource->getFormat();
-+ int32_t sampleRate;
-+ int32_t numChannels;
-+ CHECK(format->findInt32(kKeySampleRate, &sampleRate));
-+ CHECK(format->findInt32(kKeyChannelCount, &numChannels));
-+
-+ setRawAudioFormat(kPortIndexInput, sampleRate, numChannels);
-+ }
-+}
-+
-+status_t OMXCodec::setAACFormat(
-+ int32_t numChannels, int32_t sampleRate, int32_t bitRate, int32_t aacProfile, bool isADTS) {
-+ if (numChannels > 2) {
-+ ALOGW("Number of channels: (%d) \n", numChannels);
-+ }
-+
-+ if (mIsEncoder) {
-+ if (isADTS) {
-+ return -EINVAL;
-+ }
-+
-+ //////////////// input port ////////////////////
-+ setRawAudioFormat(kPortIndexInput, sampleRate, numChannels);
-+
-+ //////////////// output port ////////////////////
-+ // format
-+ OMX_AUDIO_PARAM_PORTFORMATTYPE format;
-+ InitOMXParams(&format);
-+ format.nPortIndex = kPortIndexOutput;
-+ format.nIndex = 0;
-+ status_t err = OMX_ErrorNone;
-+ while (OMX_ErrorNone == err) {
-+ CHECK_EQ(mOMX->getParameter(mNode, OMX_IndexParamAudioPortFormat,
-+ &format, sizeof(format)), (status_t)OK);
-+ if (format.eEncoding == OMX_AUDIO_CodingAAC) {
-+ break;
-+ }
-+ format.nIndex;
-+ }
-+ CHECK_EQ((status_t)OK, err);
-+ CHECK_EQ(mOMX->setParameter(mNode, OMX_IndexParamAudioPortFormat,
-+ &format, sizeof(format)), (status_t)OK);
-+
-+ // port definition
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = kPortIndexOutput;
-+ CHECK_EQ(mOMX->getParameter(mNode, OMX_IndexParamPortDefinition,
-+ &def, sizeof(def)), (status_t)OK);
-+ def.format.audio.bFlagErrorConcealment = OMX_TRUE;
-+ def.format.audio.eEncoding = OMX_AUDIO_CodingAAC;
-+ CHECK_EQ(mOMX->setParameter(mNode, OMX_IndexParamPortDefinition,
-+ &def, sizeof(def)), (status_t)OK);
-+
-+ // profile
-+ OMX_AUDIO_PARAM_AACPROFILETYPE profile;
-+ InitOMXParams(&profile);
-+ profile.nPortIndex = kPortIndexOutput;
-+ CHECK_EQ(mOMX->getParameter(mNode, OMX_IndexParamAudioAac,
-+ &profile, sizeof(profile)), (status_t)OK);
-+ profile.nChannels = numChannels;
-+ profile.eChannelMode = (numChannels == 1?
-+ OMX_AUDIO_ChannelModeMono: OMX_AUDIO_ChannelModeStereo);
-+ profile.nSampleRate = sampleRate;
-+ profile.nBitRate = bitRate;
-+ profile.nAudioBandWidth = 0;
-+ profile.nFrameLength = 0;
-+ profile.nAACtools = OMX_AUDIO_AACToolAll;
-+ profile.nAACERtools = OMX_AUDIO_AACERNone;
-+ profile.eAACProfile = (OMX_AUDIO_AACPROFILETYPE) aacProfile;
-+ profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4FF;
-+ err = mOMX->setParameter(mNode, OMX_IndexParamAudioAac,
-+ &profile, sizeof(profile));
-+
-+ if (err != OK) {
-+ CODEC_LOGE("setParameter('OMX_IndexParamAudioAac') failed "
-+ "(err = %d)",
-+ err);
-+ return err;
-+ }
-+ } else {
-+ OMX_AUDIO_PARAM_AACPROFILETYPE profile;
-+ InitOMXParams(&profile);
-+ profile.nPortIndex = kPortIndexInput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ profile.nChannels = numChannels;
-+ profile.nSampleRate = sampleRate;
-+
-+ profile.eAACStreamFormat =
-+ isADTS
-+ ? OMX_AUDIO_AACStreamFormatMP4ADTS
-+ : OMX_AUDIO_AACStreamFormatMP4FF;
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile));
-+
-+ if (err != OK) {
-+ CODEC_LOGE("setParameter('OMX_IndexParamAudioAac') failed "
-+ "(err = %d)",
-+ err);
-+ return err;
-+ }
-+ }
-+
-+ return OK;
-+}
-+
-+status_t OMXCodec::setAC3Format(int32_t numChannels, int32_t sampleRate) {
-+ OMX_AUDIO_PARAM_ANDROID_AC3TYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = kPortIndexInput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode,
-+ (OMX_INDEXTYPE)OMX_IndexParamAudioAndroidAc3,
-+ &def,
-+ sizeof(def));
-+
-+ if (err != OK) {
-+ return err;
-+ }
-+
-+ def.nChannels = numChannels;
-+ def.nSampleRate = sampleRate;
-+
-+ return mOMX->setParameter(
-+ mNode,
-+ (OMX_INDEXTYPE)OMX_IndexParamAudioAndroidAc3,
-+ &def,
-+ sizeof(def));
-+}
-+
-+void OMXCodec::setG711Format(int32_t sampleRate, int32_t numChannels) {
-+ CHECK(!mIsEncoder);
-+ setRawAudioFormat(kPortIndexInput, sampleRate, numChannels);
-+}
-+
-+void OMXCodec::setImageOutputFormat(
-+ OMX_COLOR_FORMATTYPE format, OMX_U32 width, OMX_U32 height) {
-+ CODEC_LOGV("setImageOutputFormat(%u, %u)", width, height);
-+
-+#if 0
-+ OMX_INDEXTYPE index;
-+ status_t err = mOMX->get_extension_index(
-+ mNode, "OMX.TI.JPEG.decode.Config.OutputColorFormat", &index);
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ err = mOMX->set_config(mNode, index, &format, sizeof(format));
-+ CHECK_EQ(err, (status_t)OK);
-+#endif
-+
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = kPortIndexOutput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ CHECK_EQ((int)def.eDomain, (int)OMX_PortDomainImage);
-+
-+ OMX_IMAGE_PORTDEFINITIONTYPE *imageDef = &def.format.image;
-+
-+ CHECK_EQ((int)imageDef->eCompressionFormat, (int)OMX_IMAGE_CodingUnused);
-+ imageDef->eColorFormat = format;
-+ imageDef->nFrameWidth = width;
-+ imageDef->nFrameHeight = height;
-+
-+ switch (format) {
-+ case OMX_COLOR_FormatYUV420PackedPlanar:
-+ case OMX_COLOR_FormatYUV411Planar:
-+ {
-+ def.nBufferSize = (width * height * 3) / 2;
-+ break;
-+ }
-+
-+ case OMX_COLOR_FormatCbYCrY:
-+ {
-+ def.nBufferSize = width * height * 2;
-+ break;
-+ }
-+
-+ case OMX_COLOR_Format32bitARGB8888:
-+ {
-+ def.nBufferSize = width * height * 4;
-+ break;
-+ }
-+
-+ case OMX_COLOR_Format16bitARGB4444:
-+ case OMX_COLOR_Format16bitARGB1555:
-+ case OMX_COLOR_Format16bitRGB565:
-+ case OMX_COLOR_Format16bitBGR565:
-+ {
-+ def.nBufferSize = width * height * 2;
-+ break;
-+ }
-+
-+ default:
-+ CHECK(!"Should not be here. Unknown color format.");
-+ break;
-+ }
-+
-+ def.nBufferCountActual = def.nBufferCountMin;
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+}
-+
-+void OMXCodec::setJPEGInputFormat(
-+ OMX_U32 width, OMX_U32 height, OMX_U32 compressedSize) {
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = kPortIndexInput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ CHECK_EQ((int)def.eDomain, (int)OMX_PortDomainImage);
-+ OMX_IMAGE_PORTDEFINITIONTYPE *imageDef = &def.format.image;
-+
-+ CHECK_EQ((int)imageDef->eCompressionFormat, (int)OMX_IMAGE_CodingJPEG);
-+ imageDef->nFrameWidth = width;
-+ imageDef->nFrameHeight = height;
-+
-+ def.nBufferSize = compressedSize;
-+ def.nBufferCountActual = def.nBufferCountMin;
-+
-+ err = mOMX->setParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+}
-+
-+void OMXCodec::addCodecSpecificData(const void *data, size_t size) {
-+ CodecSpecificData *specific =
-+ (CodecSpecificData *)malloc(sizeof(CodecSpecificData) size - 1);
-+
-+ specific->mSize = size;
-+ memcpy(specific->mData, data, size);
-+
-+ mCodecSpecificData.push(specific);
-+}
-+
-+void OMXCodec::clearCodecSpecificData() {
-+ for (size_t i = 0; i < mCodecSpecificData.size(); i) {
-+ free(mCodecSpecificData.editItemAt(i));
-+ }
-+ mCodecSpecificData.clear();
-+ mCodecSpecificDataIndex = 0;
-+}
-+
-+status_t OMXCodec::start(MetaData *meta) {
-+ Mutex::Autolock autoLock(mLock);
-+
-+ if (mPaused) {
-+ status_t err = resumeLocked(true);
-+ return err;
-+ }
-+
-+ if (mState != LOADED) {
-+ CODEC_LOGE("called start in the unexpected state: %d", mState);
-+ return UNKNOWN_ERROR;
-+ }
-+
-+ sp<MetaData> params = new MetaData;
-+ if (mQuirks & kWantsNALFragments) {
-+ params->setInt32(kKeyWantsNALFragments, true);
-+ }
-+ if (meta) {
-+ int64_t startTimeUs = 0;
-+ int64_t timeUs;
-+ if (meta->findInt64(kKeyTime, &timeUs)) {
-+ startTimeUs = timeUs;
-+ }
-+ params->setInt64(kKeyTime, startTimeUs);
-+ }
-+
-+ mCodecSpecificDataIndex = 0;
-+ mInitialBufferSubmit = true;
-+ mSignalledEOS = false;
-+ mNoMoreOutputData = false;
-+ mOutputPortSettingsHaveChanged = false;
-+ mSeekTimeUs = -1;
-+ mSeekMode = ReadOptions::SEEK_CLOSEST_SYNC;
-+ mTargetTimeUs = -1;
-+ mFilledBuffers.clear();
-+ mPaused = false;
-+
-+ status_t err;
-+ if (mIsEncoder) {
-+ // Calling init() before starting its source so that we can configure,
-+ // if supported, the source to use exactly the same number of input
-+ // buffers as requested by the encoder.
-+ if ((err = init()) != OK) {
-+ CODEC_LOGE("init failed: %d", err);
-+ return err;
-+ }
-+
-+ params->setInt32(kKeyNumBuffers, mPortBuffers[kPortIndexInput].size());
-+ err = mSource->start(params.get());
-+ if (err != OK) {
-+ CODEC_LOGE("source failed to start: %d", err);
-+ stopOmxComponent_l();
-+ }
-+ return err;
-+ }
-+
-+ // Decoder case
-+ if ((err = mSource->start(params.get())) != OK) {
-+ CODEC_LOGE("source failed to start: %d", err);
-+ return err;
-+ }
-+ return init();
-+}
-+
-+status_t OMXCodec::stop() {
-+ CODEC_LOGV("stop mState=%d", mState);
-+ Mutex::Autolock autoLock(mLock);
-+ status_t err = stopOmxComponent_l();
-+ mSource->stop();
-+
-+ CODEC_LOGV("stopped in state %d", mState);
-+ return err;
-+}
-+
-+status_t OMXCodec::stopOmxComponent_l() {
-+ CODEC_LOGV("stopOmxComponent_l mState=%d", mState);
-+
-+ while (isIntermediateState(mState)) {
-+ mAsyncCompletion.wait(mLock);
-+ }
-+
-+ bool isError = false;
-+ switch (mState) {
-+ case LOADED:
-+ break;
-+
-+ case ERROR:
-+ {
-+ if (mPortStatus[kPortIndexOutput] == ENABLING) {
-+ // Codec is in a wedged state (technical term)
-+ // We've seen an output port settings change from the codec,
-+ // We've disabled the output port, then freed the output
-+ // buffers, initiated re-enabling the output port but
-+ // failed to reallocate the output buffers.
-+ // There doesn't seem to be a way to orderly transition
-+ // from executing->idle and idle->loaded now that the
-+ // output port hasn't been reenabled yet...
-+ // Simply free as many resources as we can and pretend
-+ // that we're in LOADED state so that the destructor
-+ // will free the component instance without asserting.
-+ freeBuffersOnPort(kPortIndexInput, true /* onlyThoseWeOwn */);
-+ freeBuffersOnPort(kPortIndexOutput, true /* onlyThoseWeOwn */);
-+ setState(LOADED);
-+ break;
-+ } else {
-+ OMX_STATETYPE state = OMX_StateInvalid;
-+ status_t err = mOMX->getState(mNode, &state);
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ if (state != OMX_StateExecuting) {
-+ break;
-+ }
-+ // else fall through to the idling code
-+ }
-+
-+ isError = true;
-+ }
-+
-+ case PAUSED:
-+ case EXECUTING:
-+ {
-+ setState(EXECUTING_TO_IDLE);
-+
-+ if (mQuirks & kRequiresFlushBeforeShutdown) {
-+ CODEC_LOGV("This component requires a flush before transitioning "
-+ "from EXECUTING to IDLE...");
-+
-+ bool emulateInputFlushCompletion =
-+ !flushPortAsync(kPortIndexInput);
-+
-+ bool emulateOutputFlushCompletion =
-+ !flushPortAsync(kPortIndexOutput);
-+
-+ if (emulateInputFlushCompletion) {
-+ onCmdComplete(OMX_CommandFlush, kPortIndexInput);
-+ }
-+
-+ if (emulateOutputFlushCompletion) {
-+ onCmdComplete(OMX_CommandFlush, kPortIndexOutput);
-+ }
-+ } else {
-+ mPortStatus[kPortIndexInput] = SHUTTING_DOWN;
-+ mPortStatus[kPortIndexOutput] = SHUTTING_DOWN;
-+
-+ status_t err =
-+ mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
-+ CHECK_EQ(err, (status_t)OK);
-+ }
-+
-+ while (mState != LOADED && mState != ERROR) {
-+ mAsyncCompletion.wait(mLock);
-+ }
-+
-+ if (isError) {
-+ // We were in the ERROR state coming in, so restore that now
-+ // that we've idled the OMX component.
-+ setState(ERROR);
-+ }
-+
-+ break;
-+ }
-+
-+ default:
-+ {
-+ CHECK(!"should not be here.");
-+ break;
-+ }
-+ }
-+
-+ if (mLeftOverBuffer) {
-+ mLeftOverBuffer->release();
-+ mLeftOverBuffer = NULL;
-+ }
-+
-+ return OK;
-+}
-+
-+sp<MetaData> OMXCodec::getFormat() {
-+ Mutex::Autolock autoLock(mLock);
-+
-+ return mOutputFormat;
-+}
-+
-+status_t OMXCodec::read(
-+ MediaBuffer **buffer, const ReadOptions *options) {
-+ status_t err = OK;
-+ *buffer = NULL;
-+
-+ Mutex::Autolock autoLock(mLock);
-+
-+ if (mPaused) {
-+ err = resumeLocked(false);
-+ if(err != OK) {
-+ CODEC_LOGE("Failed to restart codec err= %d", err);
-+ return err;
-+ }
-+ }
-+
-+ if (mState != EXECUTING && mState != RECONFIGURING) {
-+ return UNKNOWN_ERROR;
-+ }
-+
-+ bool seeking = false;
-+ int64_t seekTimeUs;
-+ ReadOptions::SeekMode seekMode;
-+ if (options && options->getSeekTo(&seekTimeUs, &seekMode)) {
-+ seeking = true;
-+ }
-+
-+ if (mInitialBufferSubmit) {
-+ mInitialBufferSubmit = false;
-+
-+ if (seeking) {
-+ CHECK(seekTimeUs >= 0);
-+ mSeekTimeUs = seekTimeUs;
-+ mSeekMode = seekMode;
-+
-+ // There's no reason to trigger the code below, there's
-+ // nothing to flush yet.
-+ seeking = false;
-+ mPaused = false;
-+ }
-+
-+ drainInputBuffers();
-+
-+ if (mState == EXECUTING) {
-+ // Otherwise mState == RECONFIGURING and this code will trigger
-+ // after the output port is reenabled.
-+ fillOutputBuffers();
-+ }
-+ }
-+
-+ if (seeking) {
-+ while (mState == RECONFIGURING) {
-+ if ((err = waitForBufferFilled_l()) != OK) {
-+ return err;
-+ }
-+ }
-+
-+ if (mState != EXECUTING) {
-+ return UNKNOWN_ERROR;
-+ }
-+
-+ CODEC_LOGV("seeking to %" PRId64 " us (%.2f secs)", seekTimeUs, seekTimeUs / 1E6);
-+
-+ mSignalledEOS = false;
-+
-+ CHECK(seekTimeUs >= 0);
-+ mSeekTimeUs = seekTimeUs;
-+ mSeekMode = seekMode;
-+
-+ mFilledBuffers.clear();
-+
-+ CHECK_EQ((int)mState, (int)EXECUTING);
-+ //DSP supports flushing of ports simultaneously. Flushing individual port is not supported.
-+ setState(FLUSHING);
-+
-+ bool emulateInputFlushCompletion = !flushPortAsync(kPortIndexInput);
-+ bool emulateOutputFlushCompletion = !flushPortAsync(kPortIndexOutput);
-+
-+ if (emulateInputFlushCompletion) {
-+ onCmdComplete(OMX_CommandFlush, kPortIndexInput);
-+ }
-+
-+ if (emulateOutputFlushCompletion) {
-+ onCmdComplete(OMX_CommandFlush, kPortIndexOutput);
-+ }
-+
-+ while (mSeekTimeUs >= 0) {
-+ if ((err = waitForBufferFilled_l()) != OK) {
-+ return err;
-+ }
-+ }
-+ }
-+
-+ while (mState != ERROR && !mNoMoreOutputData && mFilledBuffers.empty()) {
-+ if ((err = waitForBufferFilled_l()) != OK) {
-+ return err;
-+ }
-+ }
-+
-+ if (mState == ERROR) {
-+ return UNKNOWN_ERROR;
-+ }
-+
-+ if (seeking) {
-+ CHECK_EQ((int)mState, (int)FLUSHING);
-+ setState(EXECUTING);
-+ }
-+
-+ if (mFilledBuffers.empty()) {
-+ return mSignalledEOS ? mFinalStatus : ERROR_END_OF_STREAM;
-+ }
-+
-+ if (mOutputPortSettingsHaveChanged) {
-+ mOutputPortSettingsHaveChanged = false;
-+
-+ return INFO_FORMAT_CHANGED;
-+ }
-+
-+ size_t index = *mFilledBuffers.begin();
-+ mFilledBuffers.erase(mFilledBuffers.begin());
-+
-+ BufferInfo *info = &mPortBuffers[kPortIndexOutput].editItemAt(index);
-+ CHECK_EQ((int)info->mStatus, (int)OWNED_BY_US);
-+ info->mStatus = OWNED_BY_CLIENT;
-+
-+ info->mMediaBuffer->add_ref();
-+ if (mSkipCutBuffer != NULL) {
-+ mSkipCutBuffer->submit(info->mMediaBuffer);
-+ }
-+ *buffer = info->mMediaBuffer;
-+
-+ return OK;
-+}
-+
-+void OMXCodec::signalBufferReturned(MediaBuffer *buffer) {
-+ Mutex::Autolock autoLock(mLock);
-+
-+ Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];
-+ for (size_t i = 0; i < buffers->size(); i) {
-+ BufferInfo *info = &buffers->editItemAt(i);
-+
-+ if (info->mMediaBuffer == buffer) {
-+ CHECK_EQ((int)mPortStatus[kPortIndexOutput], (int)ENABLED);
-+ CHECK_EQ((int)info->mStatus, (int)OWNED_BY_CLIENT);
-+
-+ info->mStatus = OWNED_BY_US;
-+
-+ if (buffer->graphicBuffer() == 0) {
-+ fillOutputBuffer(info);
-+ } else {
-+ sp<MetaData> metaData = info->mMediaBuffer->meta_data();
-+ int32_t rendered = 0;
-+ if (!metaData->findInt32(kKeyRendered, &rendered)) {
-+ rendered = 0;
-+ }
-+ if (!rendered) {
-+ status_t err = cancelBufferToNativeWindow(info);
-+ if (err < 0) {
-+ return;
-+ }
-+ }
-+
-+ info->mStatus = OWNED_BY_NATIVE_WINDOW;
-+
-+ // Dequeue the next buffer from the native window.
-+ BufferInfo *nextBufInfo = dequeueBufferFromNativeWindow();
-+ if (nextBufInfo == 0) {
-+ return;
-+ }
-+
-+ // Give the buffer to the OMX node to fill.
-+ fillOutputBuffer(nextBufInfo);
-+ }
-+ return;
-+ }
-+ }
-+
-+ CHECK(!"should not be here.");
-+}
-+
-+void OMXCodec::dumpPortStatus(OMX_U32 portIndex) {
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = portIndex;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ printf("%s Port = {\n", portIndex == kPortIndexInput ? "Input" : "Output");
-+
-+ CHECK((portIndex == kPortIndexInput && def.eDir == OMX_DirInput)
-+ || (portIndex == kPortIndexOutput && def.eDir == OMX_DirOutput));
-+
-+ printf(" nBufferCountActual = %" PRIu32 "\n", def.nBufferCountActual);
-+ printf(" nBufferCountMin = %" PRIu32 "\n", def.nBufferCountMin);
-+ printf(" nBufferSize = %" PRIu32 "\n", def.nBufferSize);
-+
-+ switch (def.eDomain) {
-+ case OMX_PortDomainImage:
-+ {
-+ const OMX_IMAGE_PORTDEFINITIONTYPE *imageDef = &def.format.image;
-+
-+ printf("\n");
-+ printf(" // Image\n");
-+ printf(" nFrameWidth = %" PRIu32 "\n", imageDef->nFrameWidth);
-+ printf(" nFrameHeight = %" PRIu32 "\n", imageDef->nFrameHeight);
-+ printf(" nStride = %" PRIu32 "\n", imageDef->nStride);
-+
-+ printf(" eCompressionFormat = %s\n",
-+ asString(imageDef->eCompressionFormat));
-+
-+ printf(" eColorFormat = %s\n",
-+ asString(imageDef->eColorFormat));
-+
-+ break;
-+ }
-+
-+ case OMX_PortDomainVideo:
-+ {
-+ OMX_VIDEO_PORTDEFINITIONTYPE *videoDef = &def.format.video;
-+
-+ printf("\n");
-+ printf(" // Video\n");
-+ printf(" nFrameWidth = %" PRIu32 "\n", videoDef->nFrameWidth);
-+ printf(" nFrameHeight = %" PRIu32 "\n", videoDef->nFrameHeight);
-+ printf(" nStride = %" PRIu32 "\n", videoDef->nStride);
-+
-+ printf(" eCompressionFormat = %s\n",
-+ asString(videoDef->eCompressionFormat));
-+
-+ printf(" eColorFormat = %s\n",
-+ asString(videoDef->eColorFormat));
-+
-+ break;
-+ }
-+
-+ case OMX_PortDomainAudio:
-+ {
-+ OMX_AUDIO_PORTDEFINITIONTYPE *audioDef = &def.format.audio;
-+
-+ printf("\n");
-+ printf(" // Audio\n");
-+ printf(" eEncoding = %s\n",
-+ asString(audioDef->eEncoding));
-+
-+ if (audioDef->eEncoding == OMX_AUDIO_CodingPCM) {
-+ OMX_AUDIO_PARAM_PCMMODETYPE params;
-+ InitOMXParams(¶ms);
-+ params.nPortIndex = portIndex;
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamAudioPcm, ¶ms, sizeof(params));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ printf(" nSamplingRate = %" PRIu32 "\n", params.nSamplingRate);
-+ printf(" nChannels = %" PRIu32 "\n", params.nChannels);
-+ printf(" bInterleaved = %d\n", params.bInterleaved);
-+ printf(" nBitPerSample = %" PRIu32 "\n", params.nBitPerSample);
-+
-+ printf(" eNumData = %s\n",
-+ params.eNumData == OMX_NumericalDataSigned
-+ ? "signed" : "unsigned");
-+
-+ printf(" ePCMMode = %s\n", asString(params.ePCMMode));
-+ } else if (audioDef->eEncoding == OMX_AUDIO_CodingAMR) {
-+ OMX_AUDIO_PARAM_AMRTYPE amr;
-+ InitOMXParams(&amr);
-+ amr.nPortIndex = portIndex;
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamAudioAmr, &amr, sizeof(amr));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ printf(" nChannels = %" PRIu32 "\n", amr.nChannels);
-+ printf(" eAMRBandMode = %s\n",
-+ asString(amr.eAMRBandMode));
-+ printf(" eAMRFrameFormat = %s\n",
-+ asString(amr.eAMRFrameFormat));
-+ }
-+
-+ break;
-+ }
-+
-+ default:
-+ {
-+ printf(" // Unknown\n");
-+ break;
-+ }
-+ }
-+
-+ printf("}\n");
-+}
-+
-+status_t OMXCodec::initNativeWindow() {
-+ // Enable use of a GraphicBuffer as the output for this node. This must
-+ // happen before getting the IndexParamPortDefinition parameter because it
-+ // will affect the pixel format that the node reports.
-+ status_t err = mOMX->enableGraphicBuffers(mNode, kPortIndexOutput, OMX_TRUE);
-+ if (err != 0) {
-+ return err;
-+ }
-+
-+ return OK;
-+}
-+
-+void OMXCodec::initNativeWindowCrop() {
-+ int32_t left, top, right, bottom;
-+
-+ CHECK(mOutputFormat->findRect(
-+ kKeyCropRect,
-+ &left, &top, &right, &bottom));
-+
-+ android_native_rect_t crop;
-+ crop.left = left;
-+ crop.top = top;
-+ crop.right = right 1;
-+ crop.bottom = bottom 1;
-+
-+ // We'll ignore any errors here, if the surface is
-+ // already invalid, we'll know soon enough.
-+ native_window_set_crop(mNativeWindow.get(), &crop);
-+}
-+
-+void OMXCodec::initOutputFormat(const sp<MetaData> &inputFormat) {
-+ mOutputFormat = new MetaData;
-+ mOutputFormat->setCString(kKeyDecoderComponent, mComponentName);
-+ if (mIsEncoder) {
-+ int32_t timeScale;
-+ if (inputFormat->findInt32(kKeyTimeScale, &timeScale)) {
-+ mOutputFormat->setInt32(kKeyTimeScale, timeScale);
-+ }
-+ }
-+
-+ OMX_PARAM_PORTDEFINITIONTYPE def;
-+ InitOMXParams(&def);
-+ def.nPortIndex = kPortIndexOutput;
-+
-+ status_t err = mOMX->getParameter(
-+ mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ switch (def.eDomain) {
-+ case OMX_PortDomainImage:
-+ {
-+ OMX_IMAGE_PORTDEFINITIONTYPE *imageDef = &def.format.image;
-+ CHECK_EQ((int)imageDef->eCompressionFormat,
-+ (int)OMX_IMAGE_CodingUnused);
-+
-+ mOutputFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RAW);
-+ mOutputFormat->setInt32(kKeyColorFormat, imageDef->eColorFormat);
-+ mOutputFormat->setInt32(kKeyWidth, imageDef->nFrameWidth);
-+ mOutputFormat->setInt32(kKeyHeight, imageDef->nFrameHeight);
-+ break;
-+ }
-+
-+ case OMX_PortDomainAudio:
-+ {
-+ OMX_AUDIO_PORTDEFINITIONTYPE *audio_def = &def.format.audio;
-+
-+ if (audio_def->eEncoding == OMX_AUDIO_CodingPCM) {
-+ OMX_AUDIO_PARAM_PCMMODETYPE params;
-+ InitOMXParams(¶ms);
-+ params.nPortIndex = kPortIndexOutput;
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamAudioPcm, ¶ms, sizeof(params));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ CHECK_EQ((int)params.eNumData, (int)OMX_NumericalDataSigned);
-+ CHECK_EQ(params.nBitPerSample, 16u);
-+ CHECK_EQ((int)params.ePCMMode, (int)OMX_AUDIO_PCMModeLinear);
-+
-+ int32_t numChannels, sampleRate;
-+ inputFormat->findInt32(kKeyChannelCount, &numChannels);
-+ inputFormat->findInt32(kKeySampleRate, &sampleRate);
-+
-+ if ((OMX_U32)numChannels != params.nChannels) {
-+ ALOGV("Codec outputs a different number of channels than "
-+ "the input stream contains (contains %d channels, "
-+ "codec outputs %u channels).",
-+ numChannels, params.nChannels);
-+ }
-+
-+ if (sampleRate != (int32_t)params.nSamplingRate) {
-+ ALOGV("Codec outputs at different sampling rate than "
-+ "what the input stream contains (contains data at "
-+ "%d Hz, codec outputs %u Hz)",
-+ sampleRate, params.nSamplingRate);
-+ }
-+
-+ mOutputFormat->setCString(
-+ kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW);
-+
-+ // Use the codec-advertised number of channels, as some
-+ // codecs appear to output stereo even if the input data is
-+ // mono. If we know the codec lies about this information,
-+ // use the actual number of channels instead.
-+ mOutputFormat->setInt32(
-+ kKeyChannelCount,
-+ (mQuirks & kDecoderLiesAboutNumberOfChannels)
-+ ? numChannels : params.nChannels);
-+
-+ mOutputFormat->setInt32(kKeySampleRate, params.nSamplingRate);
-+ } else if (audio_def->eEncoding == OMX_AUDIO_CodingAMR) {
-+ OMX_AUDIO_PARAM_AMRTYPE amr;
-+ InitOMXParams(&amr);
-+ amr.nPortIndex = kPortIndexOutput;
-+
-+ err = mOMX->getParameter(
-+ mNode, OMX_IndexParamAudioAmr, &amr, sizeof(amr));
-+ CHECK_EQ(err, (status_t)OK);
-+
-+ CHECK_EQ(amr.nChannels, 1u);
-+ mOutputFormat->setInt32(kKeyChannelCount, 1);
-+
-+ if (amr.eAMRBandMode >= OMX_AUDIO_AMRBandModeNB0
-+ && amr.eAMRBandMode <= OMX_AUDIO_AMRBandModeNB7) {
-+ mOutputFormat->setCString(
-+ kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AMR_NB);
-+ mOutputFormat->setInt32(kKeySampleRate, 8000);
-+ } else if (amr.eAMRBandMode >= OMX_AUDIO_AMRBandModeWB0
-+ && amr.eAMRBandMode <= OMX_AUDIO_AMRBandModeWB8) {
-+ mOutputFormat->setCString(
-+ kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AMR_WB);
-+ mOutputFormat->setInt32(kKeySampleRate, 16000);
-+ } else {
-+ CHECK(!"Unknown AMR band mode.");
-+ }
-+ } else if (audio_def->eEncoding == OMX_AUDIO_CodingAAC) {
-+ mOutputFormat->setCString(
-+ kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
-+ int32_t numChannels, sampleRate, bitRate;
-+ inputFormat->findInt32(kKeyChannelCount, &numChannels);
-+ inputFormat->findInt32(kKeySampleRate, &sampleRate);
-+ inputFormat->findInt32(kKeyBitRate, &bitRate);
-+ mOutputFormat->setInt32(kKeyChannelCount, numChannels);
-+ mOutputFormat->setInt32(kKeySampleRate, sampleRate);
-+ mOutputFormat->setInt32(kKeyBitRate, bitRate);
-+ } else if (audio_def->eEncoding ==
-+ (OMX_AUDIO_CODINGTYPE)OMX_AUDIO_CodingAndroidAC3) {
-+ mOutputFormat->setCString(
-+ kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
-+ int32_t numChannels, sampleRate, bitRate;
-+ inputFormat->findInt32(kKeyChannelCount, &numChannels);
-+ inputFormat->findInt32(kKeySampleRate, &sampleRate);
-+ inputFormat->findInt32(kKeyBitRate, &bitRate);
-+ mOutputFormat->setInt32(kKeyChannelCount, numChannels);
-+ mOutputFormat->setInt32(kKeySampleRate, sampleRate);
-+ mOutputFormat->setInt32(kKeyBitRate, bitRate);
-+ } else {
-+ CHECK(!"Should not be here. Unknown audio encoding.");
-+ }
-+ break;
-+ }
-+
-+ case OMX_PortDomainVideo:
-+ {
-+ OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;
-+
-+ if (video_def->eCompressionFormat == OMX_VIDEO_CodingUnused) {
-+ mOutputFormat->setCString(
-+ kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RAW);
-+ } else if (video_def->eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
-+ mOutputFormat->setCString(
-+ kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
-+ } else if (video_def->eCompressionFormat == OMX_VIDEO_CodingH263) {
-+ mOutputFormat->setCString(
-+ kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
-+ } else if (video_def->eCompressionFormat == OMX_VIDEO_CodingAVC) {
-+ mOutputFormat->setCString(
-+ kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
-+ } else {
-+ CHECK(!"Unknown compression format.");
-+ }
-+
-+ mOutputFormat->setInt32(kKeyWidth, video_def->nFrameWidth);
-+ mOutputFormat->setInt32(kKeyHeight, video_def->nFrameHeight);
-+ mOutputFormat->setInt32(kKeyColorFormat, video_def->eColorFormat);
-+
-+ if (!mIsEncoder) {
-+ OMX_CONFIG_RECTTYPE rect;
-+ InitOMXParams(&rect);
-+ rect.nPortIndex = kPortIndexOutput;
-+ status_t err =
-+ mOMX->getConfig(
-+ mNode, OMX_IndexConfigCommonOutputCrop,
-+ &rect, sizeof(rect));
-+
-+ CODEC_LOGI("video dimensions are %u x %u",
-+ video_def->nFrameWidth, video_def->nFrameHeight);
-+
-+ if (err == OK) {
-+ CHECK_GE(rect.nLeft, 0);
-+ CHECK_GE(rect.nTop, 0);
-+ CHECK_GE(rect.nWidth, 0u);
-+ CHECK_GE(rect.nHeight, 0u);
-+ CHECK_LE(rect.nLeft rect.nWidth - 1, video_def->nFrameWidth);
-+ CHECK_LE(rect.nTop rect.nHeight - 1, video_def->nFrameHeight);
-+
-+ mOutputFormat->setRect(
-+ kKeyCropRect,
-+ rect.nLeft,
-+ rect.nTop,
-+ rect.nLeft rect.nWidth - 1,
-+ rect.nTop rect.nHeight - 1);
-+
-+ CODEC_LOGI("Crop rect is %u x %u @ (%d, %d)",
-+ rect.nWidth, rect.nHeight, rect.nLeft, rect.nTop);
-+ } else {
-+ mOutputFormat->setRect(
-+ kKeyCropRect,
-+ 0, 0,
-+ video_def->nFrameWidth - 1,
-+ video_def->nFrameHeight - 1);
-+ }
-+
-+ if (mNativeWindow != NULL) {
-+ initNativeWindowCrop();
-+ }
-+ }
-+ break;
-+ }
-+
-+ default:
-+ {
-+ CHECK(!"should not be here, neither audio nor video.");
-+ break;
-+ }
-+ }
-+
-+ // If the input format contains rotation information, flag the output
-+ // format accordingly.
-+
-+ int32_t rotationDegrees;
-+ if (mSource->getFormat()->findInt32(kKeyRotation, &rotationDegrees)) {
-+ mOutputFormat->setInt32(kKeyRotation, rotationDegrees);
-+ }
-+}
-+
-+status_t OMXCodec::pause() {
-+ CODEC_LOGV("pause mState=%d", mState);
-+
-+ Mutex::Autolock autoLock(mLock);
-+
-+ if (mState != EXECUTING) {
-+ return UNKNOWN_ERROR;
-+ }
-+
-+ while (isIntermediateState(mState)) {
-+ mAsyncCompletion.wait(mLock);
-+ }
-+ if (!strncmp(mComponentName, "OMX.qcom.", 9)) {
-+ status_t err = mOMX->sendCommand(mNode,
-+ OMX_CommandStateSet, OMX_StatePause);
-+ CHECK_EQ(err, (status_t)OK);
-+ setState(PAUSING);
-+
-+ mPaused = true;
-+ while (mState != PAUSED && mState != ERROR) {
-+ mAsyncCompletion.wait(mLock);
-+ }
-+ return mState == ERROR ? UNKNOWN_ERROR : OK;
-+ } else {
-+ mPaused = true;
-+ return OK;
-+ }
-+
-+}
-+
-+status_t OMXCodec::resumeLocked(bool drainInputBuf) {
-+ CODEC_LOGV("resume mState=%d", mState);
-+
-+ if (!strncmp(mComponentName, "OMX.qcom.", 9)) {
-+ while (isIntermediateState(mState)) {
-+ mAsyncCompletion.wait(mLock);
-+ }
-+ CHECK_EQ(mState, (status_t)PAUSED);
-+ status_t err = mOMX->sendCommand(mNode,
-+ OMX_CommandStateSet, OMX_StateExecuting);
-+ CHECK_EQ(err, (status_t)OK);
-+ setState(IDLE_TO_EXECUTING);
-+ mPaused = false;
-+ while (mState != EXECUTING && mState != ERROR) {
-+ mAsyncCompletion.wait(mLock);
-+ }
-+ if(drainInputBuf)
-+ drainInputBuffers();
-+ return mState == ERROR ? UNKNOWN_ERROR : OK;
-+ } else { // SW Codec
-+ mPaused = false;
-+ if(drainInputBuf)
-+ drainInputBuffers();
-+ return OK;
-+ }
-+}
-+
-+////////////////////////////////////////////////////////////////////////////////
-+
-+status_t QueryCodecs(
-+ const sp<IOMX> &omx,
-+ const char *mime, bool queryDecoders, bool hwCodecOnly,
-+ Vector<CodecCapabilities> *results) {
-+ Vector<OMXCodec::CodecNameAndQuirks> matchingCodecs;
-+ results->clear();
-+
-+ OMXCodec::findMatchingCodecs(mime,
-+ !queryDecoders /*createEncoder*/,
-+ NULL /*matchComponentName*/,
-+ hwCodecOnly ? OMXCodec::kHardwareCodecsOnly : 0 /*flags*/,
-+ &matchingCodecs);
-+
-+ for (size_t c = 0; c < matchingCodecs.size(); c) {
-+ const char *componentName = matchingCodecs.itemAt(c).mName.string();
-+
-+ results->push();
-+ CodecCapabilities *caps = &results->editItemAt(results->size() - 1);
-+
-+ status_t err =
-+ QueryCodec(omx, componentName, mime, !queryDecoders, caps);
-+
-+ if (err != OK) {
-+ results->removeAt(results->size() - 1);
-+ }
-+ }
-+
-+ return OK;
-+}
-+
-+status_t QueryCodec(
-+ const sp<IOMX> &omx,
-+ const char *componentName, const char *mime,
-+ bool isEncoder,
-+ CodecCapabilities *caps) {
-+ bool isVideo = !strncasecmp(mime, "video/", 6);
-+
-+ sp<OMXCodecObserver> observer = new OMXCodecObserver;
-+ IOMX::node_id node;
-+ status_t err = omx->allocateNode(componentName, observer, &node);
-+
-+ if (err != OK) {
-+ return err;
-+ }
-+
-+ OMXCodec::setComponentRole(omx, node, isEncoder, mime);
-+
-+ caps->mFlags = 0;
-+ caps->mComponentName = componentName;
-+
-+ // NOTE: OMX does not provide a way to query AAC profile support
-+ if (isVideo) {
-+ OMX_VIDEO_PARAM_PROFILELEVELTYPE param;
-+ InitOMXParams(¶m);
-+
-+ param.nPortIndex = !isEncoder ? 0 : 1;
-+
-+ for (param.nProfileIndex = 0;; param.nProfileIndex) {
-+ err = omx->getParameter(
-+ node, OMX_IndexParamVideoProfileLevelQuerySupported,
-+ ¶m, sizeof(param));
-+
-+ if (err != OK) {
-+ break;
-+ }
-+
-+ CodecProfileLevel profileLevel;
-+ profileLevel.mProfile = param.eProfile;
-+ profileLevel.mLevel = param.eLevel;
-+
-+ caps->mProfileLevels.push(profileLevel);
-+ }
-+
-+ // Color format query
-+ // return colors in the order reported by the OMX component
-+ // prefix "flexible" standard ones with the flexible equivalent
-+ OMX_VIDEO_PARAM_PORTFORMATTYPE portFormat;
-+ InitOMXParams(&portFormat);
-+ portFormat.nPortIndex = !isEncoder ? 1 : 0;
-+ for (portFormat.nIndex = 0;; portFormat.nIndex) {
-+ err = omx->getParameter(
-+ node, OMX_IndexParamVideoPortFormat,
-+ &portFormat, sizeof(portFormat));
-+ if (err != OK) {
-+ break;
-+ }
-+
-+ OMX_U32 flexibleEquivalent;
-+ if (ACodec::isFlexibleColorFormat(
-+ omx, node, portFormat.eColorFormat, false /* usingNativeWindow */,
-+ &flexibleEquivalent)) {
-+ bool marked = false;
-+ for (size_t i = 0; i < caps->mColorFormats.size(); i) {
-+ if (caps->mColorFormats.itemAt(i) == flexibleEquivalent) {
-+ marked = true;
-+ break;
-+ }
-+ }
-+ if (!marked) {
-+ caps->mColorFormats.push(flexibleEquivalent);
-+ }
-+ }
-+ caps->mColorFormats.push(portFormat.eColorFormat);
-+ }
-+ }
-+
-+ if (isVideo && !isEncoder) {
-+ if (omx->storeMetaDataInBuffers(
-+ node, 1 /* port index */, OMX_TRUE) == OK ||
-+ omx->prepareForAdaptivePlayback(
-+ node, 1 /* port index */, OMX_TRUE,
-+ 1280 /* width */, 720 /* height */) == OK) {
-+ caps->mFlags |= CodecCapabilities::kFlagSupportsAdaptivePlayback;
-+ }
-+ }
-+
-+ CHECK_EQ(omx->freeNode(node), (status_t)OK);
-+
-+ return OK;
-+}
-+
-+status_t QueryCodecs(
-+ const sp<IOMX> &omx,
-+ const char *mimeType, bool queryDecoders,
-+ Vector<CodecCapabilities> *results) {
-+ return QueryCodecs(omx, mimeType, queryDecoders, false /*hwCodecOnly*/, results);
-+}
-+
-+// These are supposed be equivalent to the logic in
-+// "audio_channel_out_mask_from_count".
-+status_t getOMXChannelMapping(size_t numChannels, OMX_AUDIO_CHANNELTYPE map[]) {
-+ switch (numChannels) {
-+ case 1:
-+ map[0] = OMX_AUDIO_ChannelCF;
-+ break;
-+ case 2:
-+ map[0] = OMX_AUDIO_ChannelLF;
-+ map[1] = OMX_AUDIO_ChannelRF;
-+ break;
-+ case 3:
-+ map[0] = OMX_AUDIO_ChannelLF;
-+ map[1] = OMX_AUDIO_ChannelRF;
-+ map[2] = OMX_AUDIO_ChannelCF;
-+ break;
-+ case 4:
-+ map[0] = OMX_AUDIO_ChannelLF;
-+ map[1] = OMX_AUDIO_ChannelRF;
-+ map[2] = OMX_AUDIO_ChannelLR;
-+ map[3] = OMX_AUDIO_ChannelRR;
-+ break;
-+ case 5:
-+ map[0] = OMX_AUDIO_ChannelLF;
-+ map[1] = OMX_AUDIO_ChannelRF;
-+ map[2] = OMX_AUDIO_ChannelCF;
-+ map[3] = OMX_AUDIO_ChannelLR;
-+ map[4] = OMX_AUDIO_ChannelRR;
-+ break;
-+ case 6:
-+ map[0] = OMX_AUDIO_ChannelLF;
-+ map[1] = OMX_AUDIO_ChannelRF;
-+ map[2] = OMX_AUDIO_ChannelCF;
-+ map[3] = OMX_AUDIO_ChannelLFE;
-+ map[4] = OMX_AUDIO_ChannelLR;
-+ map[5] = OMX_AUDIO_ChannelRR;
-+ break;
-+ case 7:
-+ map[0] = OMX_AUDIO_ChannelLF;
-+ map[1] = OMX_AUDIO_ChannelRF;
-+ map[2] = OMX_AUDIO_ChannelCF;
-+ map[3] = OMX_AUDIO_ChannelLFE;
-+ map[4] = OMX_AUDIO_ChannelLR;
-+ map[5] = OMX_AUDIO_ChannelRR;
-+ map[6] = OMX_AUDIO_ChannelCS;
-+ break;
-+ case 8:
-+ map[0] = OMX_AUDIO_ChannelLF;
-+ map[1] = OMX_AUDIO_ChannelRF;
-+ map[2] = OMX_AUDIO_ChannelCF;
-+ map[3] = OMX_AUDIO_ChannelLFE;
-+ map[4] = OMX_AUDIO_ChannelLR;
-+ map[5] = OMX_AUDIO_ChannelRR;
-+ map[6] = OMX_AUDIO_ChannelLS;
-+ map[7] = OMX_AUDIO_ChannelRS;
-+ break;
-+ default:
-+ return -EINVAL;
-+ }
-+
-+ return OK;
-+}
-+
-+} // namespace android
-diff --git a/media/libstagefright/colorconversion/Android.mk b/media/libstagefright/colorconversion/Android.mk
-index 0bf9701c8..334aa7e5e 100644
---- a/media/libstagefright/colorconversion/Android.mk
-+++ b/media/libstagefright/colorconversion/Android.mk
-@@ -13,6 +13,13 @@ LOCAL_C_INCLUDES := \
- LOCAL_STATIC_LIBRARIES := \
- libyuv_static \
-
-+ifeq ($(BOARD_HAS_MTK_HARDWARE),true)
-+LOCAL_CFLAGS += -DMTK_HARDWARE
-+
-+LOCAL_C_INCLUDES += \
-+ $(TOP)/frameworks/av/include/media/stagefright/dpframework
-+endif
-+
- LOCAL_CFLAGS += -Werror
- LOCAL_CLANG := true
- LOCAL_SANITIZE := signed-integer-overflow
-diff --git a/media/libstagefright/colorconversion/ColorConverter.cpp b/media/libstagefright/colorconversion/ColorConverter.cpp
-index 3ca7cc05c..b250342e7 100644
---- a/media/libstagefright/colorconversion/ColorConverter.cpp
-+++ b/media/libstagefright/colorconversion/ColorConverter.cpp
-@@ -26,6 +26,14 @@
-
- #define USE_LIBYUV
-
-+#ifdef MTK_HARDWARE
-+#include <DpBlitStream.h>
-+
-+const OMX_COLOR_FORMATTYPE OMX_MTK_COLOR_FormatYV12 = (OMX_COLOR_FORMATTYPE)0x7F000200;
-+const OMX_COLOR_FORMATTYPE OMX_COLOR_FormatVendorMTKYUV = (OMX_COLOR_FORMATTYPE)0x7F000001;
-+const OMX_COLOR_FORMATTYPE OMX_COLOR_FormatVendorMTKYUV_FCM = (OMX_COLOR_FORMATTYPE)0x7F000002;
-+#endif
-+
- namespace android {
-
- ColorConverter::ColorConverter(
-@@ -51,6 +59,11 @@ bool ColorConverter::isValid() const {
- case OMX_QCOM_COLOR_FormatYVU420SemiPlanar:
- case OMX_COLOR_FormatYUV420SemiPlanar:
- case OMX_TI_COLOR_FormatYUV420PackedSemiPlanar:
-+#ifdef MTK_HARDWARE
-+ case OMX_MTK_COLOR_FormatYV12:
-+ case OMX_COLOR_FormatVendorMTKYUV:
-+ case OMX_COLOR_FormatVendorMTKYUV_FCM:
-+#endif
- return true;
-
- default:
-@@ -557,4 +570,92 @@ uint8_t *ColorConverter::initClip() {
- return &mClip[-kClipMin];
- }
-
-+#ifdef MTK_HARDWARE
-+status_t ColorConverter::convertYUVToRGBHW(const BitmapParams &src, const BitmapParams &dst) {
-+ DpBlitStream blitStream;
-+ unsigned int srcWStride = src.mWidth;
-+ unsigned int srcHStride = src.mHeight;
-+
-+ DpRect srcRoi;
-+ srcRoi.x = src.mCropLeft;
-+ srcRoi.y = src.mCropTop;
-+ srcRoi.w = src.mCropRight - src.mCropLeft;
-+ srcRoi.h = src.mCropBottom - src.mCropTop;
-+
-+ unsigned int dstWStride = dst.mWidth ;
-+ unsigned int dstHStride = dst.mHeight ;
-+ char name_yuv[100];
-+ char retriever_yuv_propty[100];
-+ char name_rgb[100];
-+ char retriever_propty_rgb[100];
-+
-+ if (mSrcFormat == OMX_COLOR_FormatYUV420Planar) {
-+ char* planar[3];
-+ unsigned int length[3];
-+ planar[0] = (char*)src.mBits;
-+ length[0] = srcWStride*srcHStride;
-+ planar[1] = planar[0] + length[0];
-+ length[1] = srcWStride*srcHStride/4;
-+ planar[2] = planar[1] + length[1];
-+ length[2] = length[1];
-+
-+ blitStream.setSrcBuffer((void**)planar, (unsigned int*)length, 3);
-+ blitStream.setSrcConfig(srcWStride, srcHStride, eYUV_420_3P, eInterlace_None, &srcRoi);
-+ }
-+ else if (mSrcFormat == OMX_MTK_COLOR_FormatYV12) {
-+ char* planar[3];
-+ unsigned int length[3];
-+ planar[0] = (char*)src.mBits;
-+ length[0] = srcWStride*srcHStride;
-+ planar[1] = planar[0] + length[0];
-+ length[1] = srcWStride*srcHStride/4;
-+ planar[2] = planar[1] + length[1];
-+ length[2] = length[1];
-+
-+ blitStream.setSrcBuffer((void**)planar, (unsigned int*)length, 3);
-+ blitStream.setSrcConfig(srcWStride, srcHStride, eYV12, eInterlace_None, &srcRoi);
-+ }
-+ else if (mSrcFormat == OMX_COLOR_FormatVendorMTKYUV) {
-+ char* planar[2];
-+ unsigned int length[2];
-+ planar[0] = (char*)src.mBits;
-+ length[0] = srcWStride*srcHStride;
-+ planar[1] = planar[0] + length[0];
-+ length[1] = srcWStride*srcHStride/2;
-+
-+ blitStream.setSrcBuffer((void**)planar, (unsigned int*)length, 2);
-+ blitStream.setSrcConfig(srcWStride, srcHStride, srcWStride * 32, srcWStride * 16, eNV12_BLK, DP_PROFILE_BT601, eInterlace_None, &srcRoi);
-+ }
-+ else if (mSrcFormat == OMX_COLOR_FormatVendorMTKYUV_FCM) {
-+ char* planar[2];
-+ unsigned int length[2];
-+ planar[0] = (char*)src.mBits;
-+ length[0] = srcWStride*srcHStride;
-+ planar[1] = planar[0] + length[0];
-+ length[1] = srcWStride*srcHStride/2;
-+
-+ blitStream.setSrcBuffer((void**)planar, (unsigned int*)length, 2);
-+ blitStream.setSrcConfig(srcWStride, srcHStride, srcWStride * 32, srcWStride * 16, eNV12_BLK_FCM, DP_PROFILE_BT601, eInterlace_None, &srcRoi);
-+ }
-+
-+ if (mDstFormat == OMX_COLOR_Format16bitRGB565) {
-+ blitStream.setDstBuffer(dst.mBits, dst.mWidth * dst.mHeight * 2);
-+ blitStream.setDstConfig(dst.mWidth, dst.mHeight, eRGB565);
-+ }
-+ else if (mDstFormat == OMX_COLOR_Format32bitARGB8888) {
-+ blitStream.setDstBuffer(dst.mBits, dst.mWidth * dst.mHeight * 4);
-+ blitStream.setDstConfig(dst.mWidth, dst.mHeight, eRGBA8888);
-+ }
-+
-+ // Add Sharpness in Video Thumbnail
-+ blitStream.setTdshp(1);
-+ bool bRet = blitStream.invalidate();
-+
-+ if (!bRet)
-+ return OK;
-+ else
-+ return UNKNOWN_ERROR;
-+}
-+#endif
-+
- } // namespace android
---
-2.11.0
-
projects / GitHub / mt8127 / android_device_alcatel_ttab.git / commitdiff