exynos4/libcodec/video/v4l2/enc/ExynosVideoEncoder.c

   1 /*
   2  *
   3  * Copyright 2012 Samsung Electronics S.LSI Co. LTD
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 /*
  19  * @file        ExynosVideoEncoder.c
  20  * @brief
  21  * @author      Hyeyeon Chung (hyeon.chung@samsung.com)
  22  * @author      Jinsung Yang (jsgood.yang@samsung.com)
  23  * @author      Yunji Kim (yunji.kim@samsung.com)
  24  * @version     1.0.0
  25  * @history
  26  *   2012.02.09: Initial Version
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <string.h>
  33 #include <fcntl.h>
  34
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <sys/ioctl.h>
  38 #include <sys/mman.h>
  39 #include <pthread.h>
  40
  41 #include <sys/poll.h>
  42
  43 #include "ExynosVideoApi.h"
  44 #include "ExynosVideoEnc.h"
  45
  46 /* #define LOG_NDEBUG 0 */
  47 #define LOG_TAG "ExynosVideoEncoder"
  48 #ifndef TIZEN_FEATURE_E3250 /* build env */
  49 #include <utils/Log.h>
  50 #else
  51 #include "Exynos_OSAL_Log.h"
  52 #endif
  53
  54 #define MAX_CTRL_NUM    91
  55 #define H264_CTRL_NUM   91
  56 #define MPEG4_CTRL_NUM  26
  57 #define H263_CTRL_NUM   18
  58
  59 /* FIXME: build error related with kernel-header pkg */
  60 #if 0
  61 #ifndef V4L2_CID_MPEG_VIDEO_H264_PREPEND_SPSPPS_TO_IDR
  62 #define V4L2_CID_MPEG_VIDEO_H264_PREPEND_SPSPPS_TO_IDR (V4L2_CID_MPEG_MFC_BASE + 46)
  63 #endif
  64 #endif
  65 /*
  66  * [Common] __CodingType_To_V4L2PixelFormat
  67  */
  68 static unsigned int __CodingType_To_V4L2PixelFormat(ExynosVideoCodingType codingType)
  69 {
  70     unsigned int pixelformat = V4L2_PIX_FMT_H264;
  71
  72     switch (codingType) {
  73     case VIDEO_CODING_AVC:
  74         pixelformat = V4L2_PIX_FMT_H264;
  75         break;
  76     case VIDEO_CODING_MPEG4:
  77         pixelformat = V4L2_PIX_FMT_MPEG4;
  78         break;
  79     case VIDEO_CODING_VP8:
  80         pixelformat = V4L2_PIX_FMT_VP8;
  81         break;
  82     case VIDEO_CODING_H263:
  83         pixelformat = V4L2_PIX_FMT_H263;
  84         break;
  85     case VIDEO_CODING_VC1:
  86         pixelformat = V4L2_PIX_FMT_VC1_ANNEX_G;
  87         break;
  88     case VIDEO_CODING_VC1_RCV:
  89         pixelformat = V4L2_PIX_FMT_VC1_ANNEX_L;
  90         break;
  91     case VIDEO_CODING_MPEG2:
  92         pixelformat = V4L2_PIX_FMT_MPEG2;
  93         break;
  94     default:
  95         pixelformat = V4L2_PIX_FMT_H264;
  96         break;
  97     }
  98
  99     return pixelformat;
 100 }
 101
 102 /*
 103  * [Common] __ColorFormatType_To_V4L2PixelFormat
 104  */
 105 static unsigned int __ColorFormatType_To_V4L2PixelFormat(ExynosVideoColorFormatType colorFormatType)
 106 {
 107     unsigned int pixelformat = V4L2_PIX_FMT_NV12M;
 108
 109     switch (colorFormatType) {
 110     case VIDEO_COLORFORMAT_NV12_TILED:
 111 #ifdef EXYNOS_3250
 112         pixelformat = V4L2_PIX_FMT_NV12MT_16X16;
 113 #else
 114         pixelformat = V4L2_PIX_FMT_NV12MT;
 115 #endif
 116         break;
 117 #if 0
 118     case VIDEO_COLORFORMAT_NV21:
 119         pixelformat = V4L2_PIX_FMT_NV21M;
 120         break;
 121 #endif
 122     case VIDEO_COLORFORMAT_NV12:
 123     default:
 124         pixelformat = V4L2_PIX_FMT_NV12M;
 125         break;
 126     }
 127
 128     return pixelformat;
 129 }
 130
 131 /*
 132  * [Encoder OPS] Init
 133  */
 134 static void *MFC_Encoder_Init(int nMemoryType)
 135 {
 136     ExynosVideoEncContext *pCtx     = NULL;
 137     pthread_mutex_t       *pMutex   = NULL;
 138     int needCaps = (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING);
 139
 140     pCtx = (ExynosVideoEncContext *)malloc(sizeof(*pCtx));
 141     if (pCtx == NULL) {
 142         ALOGE("%s: Failed to allocate encoder context buffer", __func__);
 143         goto EXIT_ALLOC_FAIL;
 144     }
 145
 146     memset(pCtx, 0, sizeof(*pCtx));
 147
 148     pCtx->hEnc = exynos_v4l2_open_devname(VIDEO_ENCODER_NAME, O_RDWR, 0);
 149     if (pCtx->hEnc < 0) {
 150         ALOGE("%s: Failed to open encoder device", __func__);
 151         goto EXIT_OPEN_FAIL;
 152     }
 153
 154     if (!exynos_v4l2_querycap(pCtx->hEnc, needCaps)) {
 155         ALOGE("%s: Failed to querycap", __func__);
 156         goto EXIT_QUERYCAP_FAIL;
 157     }
 158
 159     pCtx->bStreamonInbuf = VIDEO_FALSE;
 160     pCtx->bStreamonOutbuf = VIDEO_FALSE;
 161
 162     pCtx->nMemoryType = nMemoryType;
 163
 164     pMutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
 165     if (pMutex == NULL) {
 166         ALOGE("%s: Failed to allocate mutex about input buffer", __func__);
 167         goto EXIT_QUERYCAP_FAIL;
 168     }
 169     if (pthread_mutex_init(pMutex, NULL) != 0) {
 170         free(pMutex);
 171         goto EXIT_QUERYCAP_FAIL;
 172     }
 173     pCtx->pInMutex = (void*)pMutex;
 174
 175     pMutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
 176     if (pMutex == NULL) {
 177         ALOGE("%s: Failed to allocate mutex about output buffer", __func__);
 178         goto EXIT_QUERYCAP_FAIL;
 179     }
 180     if (pthread_mutex_init(pMutex, NULL) != 0) {
 181         free(pMutex);
 182         goto EXIT_QUERYCAP_FAIL;
 183     }
 184     pCtx->pOutMutex = (void*)pMutex;
 185
 186     return (void *)pCtx;
 187
 188 EXIT_QUERYCAP_FAIL:
 189     if (pCtx->pInMutex != NULL) {
 190         pthread_mutex_destroy(pCtx->pInMutex);
 191         free(pCtx->pInMutex);
 192     }
 193
 194     if (pCtx->pOutMutex != NULL) {
 195         pthread_mutex_destroy(pCtx->pOutMutex);
 196         free(pCtx->pOutMutex);
 197     }
 198
 199     close(pCtx->hEnc);
 200
 201 EXIT_OPEN_FAIL:
 202     free(pCtx);
 203
 204 EXIT_ALLOC_FAIL:
 205     return NULL;
 206 }
 207
 208 /*
 209  * [Encoder OPS] Finalize
 210  */
 211 static ExynosVideoErrorType MFC_Encoder_Finalize(void *pHandle)
 212 {
 213     ExynosVideoEncContext *pCtx         = (ExynosVideoEncContext *)pHandle;
 214     ExynosVideoPlane      *pVideoPlane  = NULL;
 215     pthread_mutex_t       *pMutex       = NULL;
 216     ExynosVideoErrorType   ret          = VIDEO_ERROR_NONE;
 217     int i, j;
 218
 219     if (pCtx == NULL) {
 220         ALOGE("%s: Video context info must be supplied", __func__);
 221         ret = VIDEO_ERROR_BADPARAM;
 222         goto EXIT;
 223     }
 224
 225     if (pCtx->pOutMutex != NULL) {
 226         pMutex = (pthread_mutex_t*)pCtx->pOutMutex;
 227         pthread_mutex_destroy(pMutex);
 228         free(pMutex);
 229         pCtx->pOutMutex = NULL;
 230     }
 231
 232     if (pCtx->pInMutex != NULL) {
 233         pMutex = (pthread_mutex_t*)pCtx->pInMutex;
 234         pthread_mutex_destroy(pMutex);
 235         free(pMutex);
 236         pCtx->pInMutex = NULL;
 237     }
 238
 239     if (pCtx->bShareInbuf == VIDEO_FALSE) {
 240         for (i = 0; i < pCtx->nInbufs; i++) {
 241             for (j = 0; j < VIDEO_ENCODER_INBUF_PLANES; j++) {
 242                 pVideoPlane = &pCtx->pInbuf[i].planes[j];
 243                 if (pVideoPlane->addr != NULL) {
 244                     munmap(pVideoPlane->addr, pVideoPlane->allocSize);
 245                     pVideoPlane->addr = NULL;
 246                     pVideoPlane->allocSize = 0;
 247                     pVideoPlane->dataSize = 0;
 248                 }
 249
 250                 pCtx->pInbuf[i].pGeometry = NULL;
 251                 pCtx->pInbuf[i].bQueued = VIDEO_FALSE;
 252                 pCtx->pInbuf[i].bRegistered = VIDEO_FALSE;
 253             }
 254         }
 255     }
 256
 257     if (pCtx->bShareOutbuf == VIDEO_FALSE) {
 258         for (i = 0; i < pCtx->nOutbufs; i++) {
 259             for (j = 0; j < VIDEO_ENCODER_OUTBUF_PLANES; j++) {
 260                 pVideoPlane = &pCtx->pOutbuf[i].planes[j];
 261                 if (pVideoPlane->addr != NULL) {
 262                     munmap(pVideoPlane->addr, pVideoPlane->allocSize);
 263                     pVideoPlane->addr = NULL;
 264                     pVideoPlane->allocSize = 0;
 265                     pVideoPlane->dataSize = 0;
 266                 }
 267
 268                 pCtx->pOutbuf[i].pGeometry = NULL;
 269                 pCtx->pOutbuf[i].bQueued = VIDEO_FALSE;
 270                 pCtx->pOutbuf[i].bRegistered = VIDEO_FALSE;
 271             }
 272         }
 273     }
 274
 275     if (pCtx->pInbuf != NULL)
 276         free(pCtx->pInbuf);
 277
 278     if (pCtx->pOutbuf != NULL)
 279         free(pCtx->pOutbuf);
 280
 281     if (pCtx->hEnc > 0)
 282         close(pCtx->hEnc);
 283
 284     free(pCtx);
 285
 286 EXIT:
 287     return ret;
 288 }
 289
 290 /*
 291  * [Encoder OPS] Set Extended Control
 292  */
 293 static ExynosVideoErrorType MFC_Encoder_Set_EncParam (
 294     void                *pHandle,
 295     ExynosVideoEncParam *pEncParam)
 296 {
 297     ExynosVideoEncContext     *pCtx         = (ExynosVideoEncContext *)pHandle;
 298     ExynosVideoEncInitParam   *pInitParam   = NULL;
 299     ExynosVideoEncCommonParam *pCommonParam = NULL;
 300
 301     ExynosVideoErrorType       ret          = VIDEO_ERROR_NONE;
 302
 303     int i;
 304     struct v4l2_ext_control  ext_ctrl[MAX_CTRL_NUM];
 305     struct v4l2_ext_controls ext_ctrls;
 306     int k = 0;
 307
 308     if ((pCtx == NULL) || (pEncParam == NULL)) {
 309         ALOGE("%s: Video context info must be supplied", __func__);
 310         ret = VIDEO_ERROR_BADPARAM;
 311         goto EXIT;
 312     }
 313
 314     pInitParam = &pEncParam->initParam;
 315     pCommonParam = &pEncParam->commonParam;
 316
 317     /* common parameters */
 318     ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_GOP_SIZE;
 319     ext_ctrl[k++].value = pCommonParam->IDRPeriod;
 320     ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE;
 321     ext_ctrl[k++].value = pCommonParam->SliceMode;  /* 0: one, 1: fixed #mb, 3: fixed #bytes */
 322     ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB;
 323     ext_ctrl[k++].value = pCommonParam->RandomIntraMBRefresh;
 324     ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_PADDING;
 325     ext_ctrl[k++].value = pCommonParam->PadControlOn;
 326     ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV;
 327     ext_ctrl[k].value = pCommonParam->CrPadVal;
 328     ext_ctrl[k].value |= (pCommonParam->CbPadVal << 8);
 329     ext_ctrl[k++].value |= (pCommonParam->LumaPadVal << 16);
 330     ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE;
 331     ext_ctrl[k++].value = pCommonParam->EnableFRMRateControl;
 332     ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE;
 333     ext_ctrl[k++].value = pCommonParam->EnableMBRateControl;
 334     ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_BITRATE;
 335
 336     /* FIXME temporary fix */
 337     if (pCommonParam->Bitrate)
 338         ext_ctrl[k++].value = pCommonParam->Bitrate;
 339     else
 340         ext_ctrl[k++].value = 1; /* just for testing Movie studio */
 341
 342     /* codec specific parameters */
 343     switch (pEncParam->eCompressionFormat) {
 344     case VIDEO_CODING_AVC:
 345     {
 346         ExynosVideoEncH264Param *pH264Param = &pEncParam->codecParam.h264;
 347
 348         /* common parameters but id is depends on codec */
 349         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP;
 350         ext_ctrl[k++].value = pCommonParam->FrameQp;
 351         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP;
 352         ext_ctrl[k++].value = pCommonParam->FrameQp_P;
 353         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_MAX_QP;
 354         ext_ctrl[k++].value = pCommonParam->QSCodeMax;
 355         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_MIN_QP;
 356         ext_ctrl[k++].value = pCommonParam->QSCodeMin;
 357         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF;
 358         ext_ctrl[k++].value = pCommonParam->CBRPeriodRf;
 359
 360         /* H.264 specific parameters */
 361         switch (pCommonParam->SliceMode) {
 362         case 0:
 363             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB;
 364             ext_ctrl[k++].value = 1;  /* default */
 365             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES;
 366             ext_ctrl[k++].value = 2800; /* based on MFC6.x */
 367             break;
 368         case 1:
 369             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB;
 370             ext_ctrl[k++].value = pH264Param->SliceArgument;
 371             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES;
 372             ext_ctrl[k++].value = 2800; /* based on MFC6.x */
 373             break;
 374         case 2: /* Fixed Byte number Slice mode */
 375             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB;
 376             ext_ctrl[k++].value = 1; /* default */
 377             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES;
 378             ext_ctrl[k++].value = pH264Param->SliceArgument;
 379             break;
 380         default:
 381             break;
 382         }
 383
 384         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_PROFILE;
 385         ext_ctrl[k++].value = pH264Param->ProfileIDC;
 386         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_LEVEL;
 387         ext_ctrl[k++].value = pH264Param->LevelIDC;
 388         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P;
 389         ext_ctrl[k++].value = pH264Param->NumberRefForPframes;
 390         /*
 391          * It should be set using h264Param->NumberBFrames after being handled by appl.
 392          */
 393         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_B_FRAMES;
 394         ext_ctrl[k++].value = pH264Param->NumberBFrames;
 395         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE;
 396         ext_ctrl[k++].value = pH264Param->LoopFilterDisable;
 397         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA;
 398         ext_ctrl[k++].value = pH264Param->LoopFilterAlphaC0Offset;
 399         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA;
 400         ext_ctrl[k++].value = pH264Param->LoopFilterBetaOffset;
 401         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE;
 402         ext_ctrl[k++].value = pH264Param->SymbolMode;
 403 #ifdef V4L2_CID_MPEG_MFC51_VIDEO_H264_INTERLACE
 404         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_H264_INTERLACE;
 405         ext_ctrl[k++].value = pH264Param->PictureInterlace;
 406 #endif
 407         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM;
 408         ext_ctrl[k++].value = pH264Param->Transform8x8Mode;
 409 #ifdef V4L2_CID_MPEG_MFC51_VIDEO_H264_RC_FRAME_RATE
 410         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_H264_RC_FRAME_RATE;
 411         ext_ctrl[k++].value = pH264Param->FrameRate;
 412 #endif
 413         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP;
 414         ext_ctrl[k++].value = pH264Param->FrameQp_B;
 415
 416         ext_ctrl[k].id =  V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK;
 417         ext_ctrl[k++].value = pH264Param->DarkDisable;
 418         ext_ctrl[k].id =  V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH;
 419         ext_ctrl[k++].value = pH264Param->SmoothDisable;
 420         ext_ctrl[k].id =  V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC;
 421         ext_ctrl[k++].value = pH264Param->StaticDisable;
 422         ext_ctrl[k].id =  V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY;
 423         ext_ctrl[k++].value = pH264Param->ActivityDisable;
 424
 425         /* doesn't have to be set */
 426         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_GOP_CLOSURE;
 427         ext_ctrl[k++].value = 1;
 428         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_I_PERIOD;
 429         ext_ctrl[k++].value = 10;
 430         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_VBV_SIZE;
 431         ext_ctrl[k++].value = 0;
 432         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_HEADER_MODE;
 433         ext_ctrl[k++].value = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE; /* 0: seperated header, 1: header + first frame */
 434         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE;
 435         ext_ctrl[k++].value = 0;
 436         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC;
 437         ext_ctrl[k++].value = V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED;
 438         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH;
 439         ext_ctrl[k++].value = 0;
 440         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT;
 441         ext_ctrl[k++].value = 0;
 442
 443         /* Initial parameters : Frame Skip */
 444         switch (pInitParam->FrameSkip) {
 445         case VIDEO_FRAME_SKIP_MODE_LEVEL_LIMIT:
 446
 447             ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE;
 448             ext_ctrl[k++].value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_LEVEL_LIMIT;
 449             break;
 450         case VIDEO_FRAME_SKIP_MODE_BUF_LIMIT:
 451             ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE;
 452             ext_ctrl[k++].value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT;
 453             break;
 454         default:
 455             /* VIDEO_FRAME_SKIP_MODE_DISABLE (default) */
 456             ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE;
 457             ext_ctrl[k++].value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED;
 458             break;
 459         }
 460
 461         /* SVC is not supported yet */
 462         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING;
 463         ext_ctrl[k++].value = 0;
 464         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE;
 465         ext_ctrl[k++].value = V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_B;
 466         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER;
 467         ext_ctrl[k++].value = 3;
 468         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP;
 469         ext_ctrl[k++].value = (0 << 16 | 0);
 470         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP;
 471         ext_ctrl[k++].value = (1 << 16 | 0);
 472         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP;
 473         ext_ctrl[k++].value = (2 << 16 | 0);
 474         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING;
 475         ext_ctrl[k++].value = 0;
 476         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0;
 477         ext_ctrl[k++].value = 0;
 478 #ifdef V4L2_MPEG_VIDEO_H264_SEI_FP_TYPE_SIDE_BY_SIDE
 479         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE;
 480         ext_ctrl[k++].value = V4L2_MPEG_VIDEO_H264_SEI_FP_TYPE_SIDE_BY_SIDE;
 481 #endif
 482         /* FMO is not supported yet */
 483         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_FMO;
 484         ext_ctrl[k++].value = 0;
 485         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE;
 486         ext_ctrl[k++].value = V4L2_MPEG_VIDEO_H264_FMO_MAP_TYPE_INTERLEAVED_SLICES;
 487         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP;
 488         ext_ctrl[k++].value = 4;
 489         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH;
 490         ext_ctrl[k++].value = (0 << 30 | 0);
 491         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH;
 492         ext_ctrl[k++].value = (1 << 30 | 0);
 493         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH;
 494         ext_ctrl[k++].value = (2 << 30 | 0);
 495         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH;
 496         ext_ctrl[k++].value = (3 << 30 | 0);
 497         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION;
 498         ext_ctrl[k++].value = V4L2_MPEG_VIDEO_H264_FMO_CHANGE_DIR_RIGHT;
 499         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE;
 500         ext_ctrl[k++].value = 0;
 501
 502         /* ASO is not supported yet */
 503         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_ASO;
 504         ext_ctrl[k++].value = 0;
 505
 506         for (i = 0; i < 32; i++) {
 507             ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER;
 508             ext_ctrl[k++].value = (i << 16 | 0);
 509         }
 510
 511         ext_ctrls.count = H264_CTRL_NUM;
 512         break;
 513     }
 514
 515     case VIDEO_CODING_MPEG4:
 516     {
 517         ExynosVideoEncMpeg4Param *pMpeg4Param = &pEncParam->codecParam.mpeg4;
 518
 519         /* common parameters but id is depends on codec */
 520         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP;
 521         ext_ctrl[k++].value = pCommonParam->FrameQp;
 522         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP;
 523         ext_ctrl[k++].value = pCommonParam->FrameQp_P;
 524         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP;
 525         ext_ctrl[k++].value = pCommonParam->QSCodeMax;
 526         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP;
 527         ext_ctrl[k++].value = pCommonParam->QSCodeMin;
 528         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF;
 529         ext_ctrl[k++].value = pCommonParam->CBRPeriodRf;
 530
 531         /* MPEG4 specific parameters */
 532         switch (pCommonParam->SliceMode) {
 533         case 0:
 534             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB;
 535             ext_ctrl[k++].value = 1;  /* default */
 536             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES;
 537             ext_ctrl[k++].value = 2800; /* based on MFC6.x */
 538             break;
 539         case 1:
 540             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB;
 541             ext_ctrl[k++].value = pMpeg4Param->SliceArgument;
 542             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES;
 543             ext_ctrl[k++].value = 2800; /* based on MFC6.x */
 544             break;
 545         case 2:
 546             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB;
 547             ext_ctrl[k++].value = 1; /* default */
 548             ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES;
 549             ext_ctrl[k++].value = pMpeg4Param->SliceArgument;
 550             break;
 551         default:
 552             break;
 553         }
 554
 555         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE;
 556         ext_ctrl[k++].value = pMpeg4Param->ProfileIDC;
 557         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL;
 558         ext_ctrl[k++].value = pMpeg4Param->LevelIDC;
 559         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_MPEG4_QPEL;
 560         ext_ctrl[k++].value = pMpeg4Param->DisableQpelME;
 561
 562         /*
 563          * It should be set using mpeg4Param->NumberBFrames after being handled by appl.
 564          */
 565         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_B_FRAMES;
 566         ext_ctrl[k++].value = pMpeg4Param->NumberBFrames;
 567 #ifdef V4L2_CID_MPEG_MFC51_VIDEO_MPEG4_VOP_TIME_RES
 568         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_MPEG4_VOP_TIME_RES;
 569         ext_ctrl[k++].value = pMpeg4Param->TimeIncreamentRes;
 570 #endif
 571 #ifdef V4L2_CID_MPEG_MFC51_VIDEO_MPEG4_VOP_FRM_DELTA
 572         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_MPEG4_VOP_FRM_DELTA;
 573         ext_ctrl[k++].value = pMpeg4Param->VopTimeIncreament;
 574 #endif
 575         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP;
 576         ext_ctrl[k++].value = pMpeg4Param->FrameQp_B;
 577         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_VBV_SIZE;
 578         ext_ctrl[k++].value = 0;
 579         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_HEADER_MODE;
 580         ext_ctrl[k++].value = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE;
 581         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT;
 582         ext_ctrl[k++].value = 1;
 583
 584         /* Initial parameters : Frame Skip */
 585         switch (pInitParam->FrameSkip) {
 586         case VIDEO_FRAME_SKIP_MODE_LEVEL_LIMIT:
 587             ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE;
 588             ext_ctrl[k++].value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_LEVEL_LIMIT;
 589             break;
 590         case VIDEO_FRAME_SKIP_MODE_BUF_LIMIT:
 591             ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE;
 592             ext_ctrl[k++].value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT;
 593             break;
 594         default:
 595             /* VIDEO_FRAME_SKIP_MODE_DISABLE (default) */
 596             ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE;
 597             ext_ctrl[k++].value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED;
 598             break;
 599         }
 600
 601         ext_ctrls.count = MPEG4_CTRL_NUM;
 602         break;
 603     }
 604
 605     case VIDEO_CODING_H263:
 606     {
 607         ExynosVideoEncH263Param *pH263Param = &pEncParam->codecParam.h263;
 608
 609         /* common parameters but id is depends on codec */
 610         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP;
 611         ext_ctrl[k++].value = pCommonParam->FrameQp;
 612         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP;
 613         ext_ctrl[k++].value = pCommonParam->FrameQp_P;
 614         ext_ctrl[k].id =  V4L2_CID_MPEG_VIDEO_H263_MAX_QP;
 615         ext_ctrl[k++].value = pCommonParam->QSCodeMax;
 616         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_H263_MIN_QP;
 617         ext_ctrl[k++].value = pCommonParam->QSCodeMin;
 618         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF;
 619         ext_ctrl[k++].value = pCommonParam->CBRPeriodRf;
 620
 621         /* H263 specific parameters */
 622 #ifdef V4L2_CID_MPEG_MFC51_VIDEO_H263_RC_FRAME_RATE
 623         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_H263_RC_FRAME_RATE;
 624         ext_ctrl[k++].value = pH263Param->FrameRate;
 625 #endif
 626         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_VBV_SIZE;
 627         ext_ctrl[k++].value = 0;
 628         ext_ctrl[k].id = V4L2_CID_MPEG_VIDEO_HEADER_MODE;
 629         ext_ctrl[k++].value = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE;
 630         ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT;
 631         ext_ctrl[k++].value = 1;
 632
 633         /* Initial parameters : Frame Skip */
 634         switch (pInitParam->FrameSkip) {
 635         case VIDEO_FRAME_SKIP_MODE_LEVEL_LIMIT:
 636             ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE;
 637             ext_ctrl[k++].value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_LEVEL_LIMIT;
 638             break;
 639         case VIDEO_FRAME_SKIP_MODE_BUF_LIMIT:
 640             ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE;
 641             ext_ctrl[k++].value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT;
 642             break;
 643         default:
 644             /* VIDEO_FRAME_SKIP_MODE_DISABLE (default) */
 645             ext_ctrl[k].id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE;
 646             ext_ctrl[k++].value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED;
 647             break;
 648         }
 649         ext_ctrls.count = H263_CTRL_NUM;
 650         break;
 651     }
 652
 653     default:
 654         ALOGE("[%s] Undefined codec type",__func__);
 655         ret = VIDEO_ERROR_BADPARAM;
 656         goto EXIT;
 657     }
 658
 659     ext_ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
 660     ext_ctrls.controls = ext_ctrl;
 661
 662     if (exynos_v4l2_s_ext_ctrl(pCtx->hEnc, &ext_ctrls) != 0) {
 663         ALOGE("%s: Failed to s_ext_ctrl", __func__);
 664         ret = VIDEO_ERROR_APIFAIL;
 665         goto EXIT;
 666     }
 667
 668 EXIT:
 669     return ret;
 670 }
 671
 672 /*
 673  * [Encoder OPS] Set Frame Tag
 674  */
 675 static ExynosVideoErrorType MFC_Encoder_Set_FrameTag(
 676     void   *pHandle,
 677     int     frameTag)
 678 {
 679     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 680     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 681
 682     if (pCtx == NULL) {
 683         ALOGE("%s: Video context info must be supplied", __func__);
 684         ret = VIDEO_ERROR_BADPARAM;
 685         goto EXIT;
 686     }
 687 #ifdef V4L2_CID_MPEG_MFC51_VIDEO_FRAME_TAG
 688     if (exynos_v4l2_s_ctrl(pCtx->hEnc, V4L2_CID_MPEG_MFC51_VIDEO_FRAME_TAG, frameTag) != 0) {
 689         ALOGE("%s: Failed to s_ctrl", __func__);
 690         ret = VIDEO_ERROR_APIFAIL;
 691         goto EXIT;
 692     }
 693 #endif
 694 EXIT:
 695     return ret;
 696 }
 697
 698 /*
 699  * [Encoder OPS] Get Frame Tag
 700  */
 701 static int MFC_Encoder_Get_FrameTag(void *pHandle)
 702 {
 703     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 704
 705     int frameTag = -1;
 706
 707     if (pCtx == NULL) {
 708         ALOGE("%s: Video context info must be supplied", __func__);
 709         goto EXIT;
 710     }
 711 #ifdef V4L2_CID_MPEG_MFC51_VIDEO_FRAME_TAG
 712     if (exynos_v4l2_g_ctrl(pCtx->hEnc, V4L2_CID_MPEG_MFC51_VIDEO_FRAME_TAG, &frameTag) != 0) {
 713         ALOGE("%s: Failed to g_ctrl", __func__);
 714         goto EXIT;
 715     }
 716 #endif
 717 EXIT:
 718     return frameTag;
 719 }
 720
 721 /*
 722  * [Encoder OPS] Set Frame Type
 723  */
 724 static ExynosVideoErrorType MFC_Encoder_Set_FrameType(
 725     void                    *pHandle,
 726     ExynosVideoFrameType     frameType)
 727 {
 728     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 729     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 730
 731     if (pCtx == NULL) {
 732         ALOGE("%s: Video context info must be supplied", __func__);
 733         ret = VIDEO_ERROR_BADPARAM;
 734         goto EXIT;
 735     }
 736
 737
 738     if (exynos_v4l2_s_ctrl(pCtx->hEnc, V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE, frameType) != 0) {
 739         ALOGE("%s: Failed to s_ctrl", __func__);
 740         ret = VIDEO_ERROR_APIFAIL;
 741         goto EXIT;
 742     }
 743
 744
 745 EXIT:
 746     return ret;
 747 }
 748
 749 /*
 750  * [Encoder OPS] Set Frame Rate
 751  */
 752 static ExynosVideoErrorType MFC_Encoder_Set_FrameRate(
 753     void   *pHandle,
 754     int     frameRate)
 755 {
 756     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 757     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 758
 759     if (pCtx == NULL) {
 760         ALOGE("%s: Video context info must be supplied", __func__);
 761         ret = VIDEO_ERROR_BADPARAM;
 762         goto EXIT;
 763     }
 764 #ifdef V4L2_CID_MPEG_MFC51_VIDEO_FRAME_RATE_CH
 765     if (exynos_v4l2_s_ctrl(pCtx->hEnc, V4L2_CID_MPEG_MFC51_VIDEO_FRAME_RATE_CH, frameRate) != 0) {
 766         ALOGE("%s: Failed to s_ctrl", __func__);
 767         ret = VIDEO_ERROR_APIFAIL;
 768         goto EXIT;
 769     }
 770 #endif
 771
 772 EXIT:
 773     return ret;
 774 }
 775
 776 /*
 777  * [Encoder OPS] Set Bit Rate
 778  */
 779 static ExynosVideoErrorType MFC_Encoder_Set_BitRate(
 780     void   *pHandle,
 781     int     bitRate)
 782 {
 783     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 784     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 785
 786     if (pCtx == NULL) {
 787         ALOGE("%s: Video context info must be supplied", __func__);
 788         ret = VIDEO_ERROR_BADPARAM;
 789         goto EXIT;
 790     }
 791 #ifdef V4L2_CID_MPEG_MFC51_VIDEO_BIT_RATE_CH
 792     if (exynos_v4l2_s_ctrl(pCtx->hEnc, V4L2_CID_MPEG_MFC51_VIDEO_BIT_RATE_CH, bitRate) != 0) {
 793         ALOGE("%s: Failed to s_ctrl", __func__);
 794         ret = VIDEO_ERROR_APIFAIL;
 795         goto EXIT;
 796     }
 797 #endif
 798 EXIT:
 799     return ret;
 800 }
 801
 802 /*
 803  * [Encoder OPS] Set Frame Skip
 804  */
 805 static ExynosVideoErrorType MFC_Encoder_Set_FrameSkip(
 806     void   *pHandle,
 807     int     frameSkip)
 808 {
 809     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 810     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 811
 812     if (pCtx == NULL) {
 813         ALOGE("%s: Video context info must be supplied", __func__);
 814         ret = VIDEO_ERROR_BADPARAM;
 815         goto EXIT;
 816     }
 817
 818     if (exynos_v4l2_s_ctrl(pCtx->hEnc, V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE, frameSkip) != 0) {
 819         ALOGE("%s: Failed to s_ctrl", __func__);
 820         ret = VIDEO_ERROR_APIFAIL;
 821         goto EXIT;
 822     }
 823
 824 EXIT:
 825     return ret;
 826 }
 827
 828 /*
 829  * [Encoder OPS] Set IDR Period
 830  */
 831 static ExynosVideoErrorType MFC_Encoder_Set_IDRPeriod(
 832     void   *pHandle,
 833     int     IDRPeriod)
 834 {
 835     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 836     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 837
 838     if (pCtx == NULL) {
 839         ALOGE("%s: Video context info must be supplied", __func__);
 840         ret = VIDEO_ERROR_BADPARAM;
 841         goto EXIT;
 842     }
 843
 844     if (exynos_v4l2_s_ctrl(pCtx->hEnc, V4L2_CID_MPEG_VIDEO_H264_I_PERIOD, IDRPeriod) != 0) {
 845         ALOGE("%s: Failed to s_ctrl", __func__);
 846         ret = VIDEO_ERROR_APIFAIL;
 847         goto EXIT;
 848     }
 849
 850 EXIT:
 851     return ret;
 852 }
 853
 854 /*
 855  * [Encoder OPS] Enable Prepend SPS and PPS to every IDR Frames
 856  */
 857 static ExynosVideoErrorType MFC_Encoder_Enable_PrependSpsPpsToIdr(void *pHandle)
 858 {
 859     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 860     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 861
 862     if (pCtx == NULL) {
 863         ALOGE("%s: Video context info must be supplied", __func__);
 864         ret = VIDEO_ERROR_BADPARAM;
 865         goto EXIT;
 866     }
 867 #ifdef V4L2_CID_MPEG_VIDEO_H264_PREPEND_SPSPPS_TO_IDR
 868     if (exynos_v4l2_s_ctrl(pCtx->hEnc, V4L2_CID_MPEG_VIDEO_H264_PREPEND_SPSPPS_TO_IDR, 1) != 0) {
 869         ALOGE("%s: Failed to s_ctrl", __func__);
 870         ret = VIDEO_ERROR_APIFAIL;
 871         goto EXIT;
 872     }
 873 #endif
 874 EXIT:
 875     return ret;
 876 }
 877
 878 /*
 879  * [Encoder Buffer OPS] Enable Cacheable (Input)
 880  */
 881 static ExynosVideoErrorType MFC_Encoder_Enable_Cacheable_Inbuf(void *pHandle)
 882 {
 883     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 884     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 885
 886     if (pCtx == NULL) {
 887         ALOGE("%s: Video context info must be supplied", __func__);
 888         ret = VIDEO_ERROR_BADPARAM;
 889         goto EXIT;
 890     }
 891 #ifdef V4L2_CID_CACHEABLE
 892     if (exynos_v4l2_s_ctrl(pCtx->hEnc, V4L2_CID_CACHEABLE, 2) != 0) {
 893         ALOGE("%s: Failed V4L2_CID_CACHEABLE", __func__);
 894         ret = VIDEO_ERROR_APIFAIL;
 895         goto EXIT;
 896     }
 897 #endif
 898 EXIT:
 899     return ret;
 900 }
 901
 902 /*
 903  * [Encoder Buffer OPS] Enable Cacheable (Output)
 904  */
 905 static ExynosVideoErrorType MFC_Encoder_Enable_Cacheable_Outbuf(void *pHandle)
 906 {
 907     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 908     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 909
 910     if (pCtx == NULL) {
 911         ALOGE("%s: Video context info must be supplied", __func__);
 912         ret = VIDEO_ERROR_BADPARAM;
 913         goto EXIT;
 914     }
 915 #ifdef V4L2_CID_CACHEABLE
 916     if (exynos_v4l2_s_ctrl(pCtx->hEnc, V4L2_CID_CACHEABLE, 1) != 0) {
 917         ALOGE("%s: Failed V4L2_CID_CACHEABLE", __func__);
 918         ret = VIDEO_ERROR_APIFAIL;
 919         goto EXIT;
 920     }
 921 #endif
 922 EXIT:
 923     return ret;
 924 }
 925
 926 /*
 927  * [Encoder Buffer OPS] Set Shareable Buffer (Input)
 928  */
 929 static ExynosVideoErrorType MFC_Encoder_Set_Shareable_Inbuf(void *pHandle)
 930 {
 931     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 932     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 933
 934     if (pCtx == NULL) {
 935         ALOGE("%s: Video context info must be supplied", __func__);
 936         ret = VIDEO_ERROR_BADPARAM;
 937         goto EXIT;
 938     }
 939
 940     pCtx->bShareInbuf = VIDEO_TRUE;
 941
 942 EXIT:
 943     return ret;
 944 }
 945
 946 /*
 947  * [Encoder Buffer OPS] Set Shareable Buffer (Output)
 948  */
 949 static ExynosVideoErrorType MFC_Encoder_Set_Shareable_Outbuf(void *pHandle)
 950 {
 951     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 952     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 953
 954     if (pCtx == NULL) {
 955         ALOGE("%s: Video context info must be supplied", __func__);
 956         ret = VIDEO_ERROR_BADPARAM;
 957         goto EXIT;
 958     }
 959
 960     pCtx->bShareOutbuf = VIDEO_TRUE;
 961
 962 EXIT:
 963     return ret;
 964 }
 965
 966 /*
 967  * [Encoder Buffer OPS] Get Buffer (Input)
 968  */
 969 static ExynosVideoErrorType MFC_Encoder_Get_Buffer_Inbuf(
 970     void               *pHandle,
 971     int                 nIndex,
 972     ExynosVideoBuffer **pBuffer)
 973 {
 974     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
 975     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
 976
 977     if (pCtx == NULL) {
 978         ALOGE("%s: Video context info must be supplied", __func__);
 979         *pBuffer = NULL;
 980         ret = VIDEO_ERROR_NOBUFFERS;
 981         goto EXIT;
 982     }
 983
 984     if (pCtx->nInbufs <= nIndex) {
 985         *pBuffer = NULL;
 986         ret = VIDEO_ERROR_BADPARAM;
 987         goto EXIT;
 988     }
 989
 990     *pBuffer = (ExynosVideoBuffer *)&pCtx->pInbuf[nIndex];
 991
 992 EXIT:
 993     return ret;
 994 }
 995
 996 /*
 997  * [Encoder Buffer OPS] Get Buffer (Output)
 998  */
 999 static ExynosVideoErrorType MFC_Encoder_Get_Buffer_Outbuf(
1000     void               *pHandle,
1001     int                 nIndex,
1002     ExynosVideoBuffer **pBuffer)
1003 {
1004     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1005     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1006
1007     if (pCtx == NULL) {
1008         ALOGE("%s: Video context info must be supplied", __func__);
1009         *pBuffer = NULL;
1010         ret = VIDEO_ERROR_NOBUFFERS;
1011         goto EXIT;
1012     }
1013
1014     if (pCtx->nOutbufs <= nIndex) {
1015         *pBuffer = NULL;
1016         ret = VIDEO_ERROR_BADPARAM;
1017         goto EXIT;
1018     }
1019
1020     *pBuffer = (ExynosVideoBuffer *)&pCtx->pOutbuf[nIndex];
1021
1022 EXIT:
1023     return ret;
1024 }
1025
1026 /*
1027  * [Encoder Buffer OPS] Set Geometry (Src)
1028  */
1029 static ExynosVideoErrorType MFC_Encoder_Set_Geometry_Inbuf(
1030     void                *pHandle,
1031     ExynosVideoGeometry *bufferConf)
1032 {
1033     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1034     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1035
1036     struct v4l2_format fmt;
1037
1038     if (pCtx == NULL) {
1039         ALOGE("%s: Video context info must be supplied", __func__);
1040         ret = VIDEO_ERROR_BADPARAM;
1041         goto EXIT;
1042     }
1043
1044     if (bufferConf == NULL) {
1045         ALOGE("%s: Buffer geometry must be supplied", __func__);
1046         ret = VIDEO_ERROR_BADPARAM;
1047         goto EXIT;
1048     }
1049
1050     memset(&fmt, 0, sizeof(fmt));
1051
1052     fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1053     fmt.fmt.pix_mp.pixelformat = __ColorFormatType_To_V4L2PixelFormat(bufferConf->eColorFormat);
1054     fmt.fmt.pix_mp.width = bufferConf->nFrameWidth;
1055     fmt.fmt.pix_mp.height = bufferConf->nFrameHeight;
1056     fmt.fmt.pix_mp.num_planes = VIDEO_ENCODER_INBUF_PLANES;
1057
1058
1059     if (exynos_v4l2_s_fmt(pCtx->hEnc, &fmt) != 0) {
1060         ALOGE("%s: Failed to s_fmt", __func__);
1061         ret = VIDEO_ERROR_APIFAIL;
1062         goto EXIT;
1063     }
1064
1065     memcpy(&pCtx->inbufGeometry, bufferConf, sizeof(pCtx->inbufGeometry));
1066
1067 EXIT:
1068     return ret;
1069 }
1070
1071 /*
1072  * [Encoder Buffer OPS] Get Geometry (Src)
1073  */
1074 static ExynosVideoErrorType MFC_Encoder_Get_Geometry_Inbuf(
1075     void                *pHandle,
1076     ExynosVideoGeometry *bufferConf)
1077 {
1078     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1079     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1080
1081     struct v4l2_format fmt;
1082
1083     if (pCtx == NULL) {
1084         ALOGE("%s: Video context info must be supplied", __func__);
1085         ret = VIDEO_ERROR_BADPARAM;
1086         goto EXIT;
1087     }
1088
1089     if (bufferConf == NULL) {
1090         ALOGE("%s: Buffer geometry must be supplied", __func__);
1091         ret = VIDEO_ERROR_BADPARAM;
1092         goto EXIT;
1093     }
1094
1095     memset(&fmt, 0, sizeof(fmt));
1096
1097     fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1098     if (exynos_v4l2_g_fmt(pCtx->hEnc, &fmt) != 0) {
1099         ALOGE("%s: Failed to g_fmt", __func__);
1100         ret = VIDEO_ERROR_APIFAIL;
1101         goto EXIT;
1102     }
1103
1104     bufferConf->nFrameHeight = fmt.fmt.pix_mp.width;
1105     bufferConf->nFrameHeight = fmt.fmt.pix_mp.height;
1106     bufferConf->nSizeImage = fmt.fmt.pix_mp.plane_fmt[0].sizeimage;
1107
1108 EXIT:
1109     return ret;
1110 }
1111
1112 /*
1113  * [Encoder Buffer OPS] Set Geometry (Dst)
1114  */
1115 static ExynosVideoErrorType MFC_Encoder_Set_Geometry_Outbuf(
1116     void                *pHandle,
1117     ExynosVideoGeometry *bufferConf)
1118 {
1119     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1120     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1121
1122     struct v4l2_format fmt;
1123
1124     if (pCtx == NULL) {
1125         ALOGE("%s: Video context info must be supplied", __func__);
1126         ret = VIDEO_ERROR_BADPARAM;
1127         goto EXIT;
1128     }
1129
1130     if (bufferConf == NULL) {
1131         ALOGE("%s: Buffer geometry must be supplied", __func__);
1132         ret = VIDEO_ERROR_BADPARAM;
1133         goto EXIT;
1134     }
1135
1136     memset(&fmt, 0, sizeof(fmt));
1137
1138     fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1139     fmt.fmt.pix_mp.pixelformat = __CodingType_To_V4L2PixelFormat(bufferConf->eCompressionFormat);
1140     fmt.fmt.pix_mp.plane_fmt[0].sizeimage = bufferConf->nSizeImage;
1141
1142     if (exynos_v4l2_s_fmt(pCtx->hEnc, &fmt) != 0) {
1143         ALOGE("%s: Failed to s_fmt", __func__);
1144         ret = VIDEO_ERROR_APIFAIL;
1145         goto EXIT;
1146     }
1147
1148     memcpy(&pCtx->outbufGeometry, bufferConf, sizeof(pCtx->outbufGeometry));
1149
1150 EXIT:
1151     return ret;
1152 }
1153
1154 /*
1155  * [Encoder Buffer OPS] Get Geometry (Dst)
1156  */
1157 static ExynosVideoErrorType MFC_Encoder_Get_Geometry_Outbuf(
1158     void                *pHandle,
1159     ExynosVideoGeometry *bufferConf)
1160 {
1161     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1162     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1163
1164     struct v4l2_format fmt;
1165
1166     if (pCtx == NULL) {
1167         ALOGE("%s: Video context info must be supplied", __func__);
1168         ret = VIDEO_ERROR_BADPARAM;
1169         goto EXIT;
1170     }
1171
1172     if (bufferConf == NULL) {
1173         ALOGE("%s: Buffer geometry must be supplied", __func__);
1174         ret = VIDEO_ERROR_BADPARAM;
1175         goto EXIT;
1176     }
1177
1178     memset(&fmt, 0, sizeof(fmt));
1179
1180     fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1181     if (exynos_v4l2_g_fmt(pCtx->hEnc, &fmt) != 0) {
1182         ALOGE("%s: Failed to g_fmt", __func__);
1183         ret = VIDEO_ERROR_APIFAIL;
1184         goto EXIT;
1185     }
1186
1187
1188     bufferConf->nSizeImage = fmt.fmt.pix_mp.plane_fmt[0].sizeimage;
1189
1190 EXIT:
1191     return ret;
1192 }
1193
1194 /*
1195  * [Encoder Buffer OPS] Setup (Src)
1196  */
1197 static ExynosVideoErrorType MFC_Encoder_Setup_Inbuf(
1198     void           *pHandle,
1199     unsigned int    nBufferCount)
1200 {
1201     ExynosVideoEncContext *pCtx         = (ExynosVideoEncContext *)pHandle;
1202     ExynosVideoPlane      *pVideoPlane  = NULL;
1203     ExynosVideoErrorType   ret          = VIDEO_ERROR_NONE;
1204
1205     struct v4l2_requestbuffers req;
1206     struct v4l2_buffer buf;
1207     struct v4l2_plane planes[VIDEO_ENCODER_INBUF_PLANES];
1208     int i, j;
1209
1210     if (pCtx == NULL) {
1211         ALOGE("%s: Video context info must be supplied", __func__);
1212         ret = VIDEO_ERROR_BADPARAM;
1213         goto EXIT;
1214     }
1215
1216     if (nBufferCount == 0) {
1217         ALOGE("%s: Buffer count must be greater than 0", __func__);
1218         ret = VIDEO_ERROR_BADPARAM;
1219         goto EXIT;
1220     }
1221
1222     memset(&req, 0, sizeof(req));
1223
1224     req.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1225     req.count = nBufferCount;
1226
1227     if (pCtx->bShareInbuf == VIDEO_TRUE)
1228         req.memory = pCtx->nMemoryType;
1229     else
1230         req.memory = V4L2_MEMORY_MMAP;
1231
1232     if (exynos_v4l2_reqbufs(pCtx->hEnc, &req) != 0) {
1233         ALOGE("Failed to require buffer");
1234         ret = VIDEO_ERROR_APIFAIL;
1235         goto EXIT;
1236     }
1237
1238     pCtx->nInbufs = (int)req.count;
1239
1240     pCtx->pInbuf = malloc(sizeof(*pCtx->pInbuf) * pCtx->nInbufs);
1241     if (pCtx->pInbuf == NULL) {
1242         ALOGE("%s: Failed to allocate input buffer context", __func__);
1243         ret = VIDEO_ERROR_NOMEM;
1244         goto EXIT;
1245     }
1246     memset(pCtx->pInbuf, 0, sizeof(*pCtx->pInbuf) * pCtx->nInbufs);
1247
1248     memset(&buf, 0, sizeof(buf));
1249
1250     if (pCtx->bShareInbuf == VIDEO_FALSE) {
1251         buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1252         buf.memory = V4L2_MEMORY_MMAP;
1253         buf.m.planes = planes;
1254         buf.length = VIDEO_ENCODER_INBUF_PLANES;
1255
1256         for (i = 0; i < pCtx->nInbufs; i++) {
1257             buf.index = i;
1258             if (exynos_v4l2_querybuf(pCtx->hEnc, &buf) != 0) {
1259                 ALOGE("%s: Failed to querybuf", __func__);
1260                 ret = VIDEO_ERROR_APIFAIL;
1261                 goto EXIT;
1262             }
1263
1264             for (j = 0; j < VIDEO_ENCODER_INBUF_PLANES; j++) {
1265                 pVideoPlane = &pCtx->pInbuf[i].planes[j];
1266                 pVideoPlane->addr = mmap(NULL,
1267                         buf.m.planes[j].length, PROT_READ | PROT_WRITE,
1268                         MAP_SHARED, pCtx->hEnc, buf.m.planes[j].m.mem_offset);
1269
1270                 if (pVideoPlane->addr == MAP_FAILED) {
1271                     ALOGE("%s: Failed to map", __func__);
1272                     ret = VIDEO_ERROR_MAPFAIL;
1273                     goto EXIT;
1274                 }
1275
1276                 pVideoPlane->allocSize = buf.m.planes[j].length;
1277                 pVideoPlane->dataSize = 0;
1278             }
1279
1280             pCtx->pInbuf[i].pGeometry = &pCtx->inbufGeometry;
1281             pCtx->pInbuf[i].bQueued = VIDEO_FALSE;
1282             pCtx->pInbuf[i].bRegistered = VIDEO_TRUE;
1283
1284         }
1285     } else {
1286         for (i = 0; i < pCtx->nInbufs; i++) {
1287             pCtx->pInbuf[i].pGeometry = &pCtx->inbufGeometry;
1288             pCtx->pInbuf[i].bQueued = VIDEO_FALSE;
1289             pCtx->pInbuf[i].bRegistered = VIDEO_FALSE;
1290         }
1291     }
1292
1293     return ret;
1294
1295 EXIT:
1296     if ((pCtx != NULL) && (pCtx->pInbuf != NULL)) {
1297         if (pCtx->bShareInbuf == VIDEO_FALSE) {
1298             for (i = 0; i < pCtx->nInbufs; i++) {
1299                 for (j = 0; j < VIDEO_ENCODER_INBUF_PLANES; j++) {
1300                     pVideoPlane = &pCtx->pInbuf[i].planes[j];
1301                     if (pVideoPlane->addr == MAP_FAILED) {
1302                         pVideoPlane->addr = NULL;
1303                         break;
1304                     }
1305
1306                     munmap(pVideoPlane->addr, pVideoPlane->allocSize);
1307                 }
1308             }
1309         }
1310
1311         free(pCtx->pInbuf);
1312     }
1313
1314     return ret;
1315 }
1316
1317 /*
1318  * [Encoder Buffer OPS] Setup (Dst)
1319  */
1320 static ExynosVideoErrorType MFC_Encoder_Setup_Outbuf(
1321     void           *pHandle,
1322     unsigned int    nBufferCount)
1323 {
1324     ExynosVideoEncContext *pCtx         = (ExynosVideoEncContext *)pHandle;
1325     ExynosVideoPlane      *pVideoPlane  = NULL;
1326     ExynosVideoErrorType   ret          = VIDEO_ERROR_NONE;
1327
1328     struct v4l2_requestbuffers req;
1329     struct v4l2_buffer buf;
1330     struct v4l2_plane planes[VIDEO_ENCODER_OUTBUF_PLANES];
1331     int i, j;
1332
1333     if (pCtx == NULL) {
1334         ALOGE("%s: Video context info must be supplied", __func__);
1335         ret = VIDEO_ERROR_BADPARAM;
1336         goto EXIT;
1337     }
1338
1339     if (nBufferCount == 0) {
1340         ALOGE("%s: Buffer count must be greater than 0", __func__);
1341         ret = VIDEO_ERROR_BADPARAM;
1342         goto EXIT;
1343     }
1344
1345     memset(&req, 0, sizeof(req));
1346
1347     req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1348     req.count = nBufferCount;
1349
1350     if (pCtx->bShareOutbuf == VIDEO_TRUE)
1351         req.memory = pCtx->nMemoryType;
1352     else
1353         req.memory = V4L2_MEMORY_MMAP;
1354
1355     if (exynos_v4l2_reqbufs(pCtx->hEnc, &req) != 0) {
1356         ALOGE("%s: Failed to reqbuf", __func__);
1357         ret = VIDEO_ERROR_APIFAIL;
1358         goto EXIT;
1359     }
1360
1361     pCtx->nOutbufs = req.count;
1362
1363     pCtx->pOutbuf = malloc(sizeof(*pCtx->pOutbuf) * pCtx->nOutbufs);
1364     if (pCtx->pOutbuf == NULL) {
1365         ALOGE("%s: Failed to allocate output buffer context", __func__);
1366         ret = VIDEO_ERROR_NOMEM;
1367         goto EXIT;
1368     }
1369     memset(pCtx->pOutbuf, 0, sizeof(*pCtx->pOutbuf) * pCtx->nOutbufs);
1370
1371     memset(&buf, 0, sizeof(buf));
1372
1373     if (pCtx->bShareOutbuf == VIDEO_FALSE) {
1374         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1375         buf.memory = V4L2_MEMORY_MMAP;
1376         buf.m.planes = planes;
1377         buf.length = VIDEO_ENCODER_OUTBUF_PLANES;
1378
1379         for (i = 0; i < pCtx->nOutbufs; i++) {
1380             buf.index = i;
1381             if (exynos_v4l2_querybuf(pCtx->hEnc, &buf) != 0) {
1382                 ALOGE("%s: Failed to querybuf", __func__);
1383                 ret = VIDEO_ERROR_APIFAIL;
1384                 goto EXIT;
1385             }
1386
1387             for (j = 0; j < VIDEO_ENCODER_OUTBUF_PLANES; j++) {
1388                 pVideoPlane = &pCtx->pOutbuf[i].planes[j];
1389                 pVideoPlane->addr = mmap(NULL,
1390                         buf.m.planes[j].length, PROT_READ | PROT_WRITE,
1391                         MAP_SHARED, pCtx->hEnc, buf.m.planes[j].m.mem_offset);
1392
1393                 if (pVideoPlane->addr == MAP_FAILED) {
1394                     ALOGE("%s: Failed to map", __func__);
1395                     ret = VIDEO_ERROR_MAPFAIL;
1396                     goto EXIT;
1397                 }
1398
1399                 pVideoPlane->allocSize = buf.m.planes[j].length;
1400                 pVideoPlane->dataSize = 0;
1401             }
1402
1403             pCtx->pOutbuf[i].pGeometry = &pCtx->outbufGeometry;
1404             pCtx->pOutbuf[i].bQueued = VIDEO_FALSE;
1405             pCtx->pOutbuf[i].bRegistered = VIDEO_TRUE;
1406         }
1407     } else {
1408         for (i = 0; i < pCtx->nOutbufs; i++ ) {
1409             pCtx->pOutbuf[i].pGeometry = &pCtx->outbufGeometry;
1410             pCtx->pOutbuf[i].bQueued = VIDEO_FALSE;
1411             pCtx->pOutbuf[i].bRegistered = VIDEO_FALSE;
1412         }
1413     }
1414
1415     return ret;
1416
1417 EXIT:
1418     if ((pCtx != NULL) && (pCtx->pOutbuf != NULL)) {
1419         if (pCtx->bShareOutbuf == VIDEO_FALSE) {
1420             for (i = 0; i < pCtx->nOutbufs; i++) {
1421                 for (j = 0; j < VIDEO_ENCODER_OUTBUF_PLANES; j++) {
1422                     pVideoPlane = &pCtx->pOutbuf[i].planes[j];
1423                     if (pVideoPlane->addr == MAP_FAILED) {
1424                         pVideoPlane->addr = NULL;
1425                         break;
1426                     }
1427
1428                     munmap(pVideoPlane->addr, pVideoPlane->allocSize);
1429                 }
1430             }
1431         }
1432
1433         free(pCtx->pOutbuf);
1434     }
1435
1436     return ret;
1437 }
1438
1439 /*
1440  * [Encoder Buffer OPS] Run (src)
1441  */
1442 static ExynosVideoErrorType MFC_Encoder_Run_Inbuf(void *pHandle)
1443 {
1444     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1445     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1446
1447     if (pCtx == NULL) {
1448         ALOGE("%s: Video context info must be supplied", __func__);
1449         ret = VIDEO_ERROR_BADPARAM;
1450         goto EXIT;
1451     }
1452
1453     if (pCtx->bStreamonInbuf == VIDEO_FALSE) {
1454         if (exynos_v4l2_streamon(pCtx->hEnc, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) != 0) {
1455             ALOGE("%s: Failed to streamon for input buffer", __func__);
1456             ret = VIDEO_ERROR_APIFAIL;
1457             goto EXIT;
1458         }
1459         pCtx->bStreamonInbuf = VIDEO_TRUE;
1460     }
1461
1462 EXIT:
1463     return ret;
1464 }
1465
1466 /*
1467  * [Encoder Buffer OPS] Run (Dst)
1468  */
1469 static ExynosVideoErrorType MFC_Encoder_Run_Outbuf(void *pHandle)
1470 {
1471     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1472     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1473
1474     if (pCtx == NULL) {
1475         ALOGE("%s: Video context info must be supplied", __func__);
1476         ret = VIDEO_ERROR_BADPARAM;
1477         goto EXIT;
1478     }
1479
1480     if (pCtx->bStreamonOutbuf == VIDEO_FALSE) {
1481         if (exynos_v4l2_streamon(pCtx->hEnc, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) != 0) {
1482             ALOGE("%s: Failed to streamon for output buffer", __func__);
1483             ret = VIDEO_ERROR_APIFAIL;
1484             goto EXIT;
1485         }
1486         pCtx->bStreamonOutbuf = VIDEO_TRUE;
1487     }
1488
1489 EXIT:
1490     return ret;
1491 }
1492
1493 /*
1494  * [Encoder Buffer OPS] Stop (Src)
1495  */
1496 static ExynosVideoErrorType MFC_Encoder_Stop_Inbuf(void *pHandle)
1497 {
1498     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1499     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1500     int i = 0;
1501
1502     if (pCtx == NULL) {
1503         ALOGE("%s: Video context info must be supplied", __func__);
1504         ret = VIDEO_ERROR_BADPARAM;
1505         goto EXIT;
1506     }
1507
1508     if (pCtx->bStreamonInbuf == VIDEO_TRUE) {
1509         if (exynos_v4l2_streamoff(pCtx->hEnc, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) != 0) {
1510             ALOGE("%s: Failed to streamoff for input buffer", __func__);
1511             ret = VIDEO_ERROR_APIFAIL;
1512             goto EXIT;
1513         }
1514         pCtx->bStreamonInbuf = VIDEO_FALSE;
1515     }
1516
1517     for (i = 0; i <  pCtx->nInbufs; i++) {
1518         pCtx->pInbuf[i].bQueued = VIDEO_FALSE;
1519     }
1520
1521 EXIT:
1522     return ret;
1523 }
1524
1525 /*
1526  * [Encoder Buffer OPS] Stop (Dst)
1527  */
1528 static ExynosVideoErrorType MFC_Encoder_Stop_Outbuf(void *pHandle)
1529 {
1530     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1531     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1532     int i = 0;
1533
1534     if (pCtx == NULL) {
1535         ALOGE("%s: Video context info must be supplied", __func__);
1536         ret = VIDEO_ERROR_BADPARAM;
1537         goto EXIT;
1538     }
1539
1540     if (pCtx->bStreamonOutbuf == VIDEO_TRUE) {
1541         if (exynos_v4l2_streamoff(pCtx->hEnc, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) != 0) {
1542             ALOGE("%s: Failed to streamoff for output buffer", __func__);
1543             ret = VIDEO_ERROR_APIFAIL;
1544             goto EXIT;
1545         }
1546         pCtx->bStreamonOutbuf = VIDEO_FALSE;
1547     }
1548
1549     for (i = 0; i < pCtx->nOutbufs; i++) {
1550         pCtx->pOutbuf[i].bQueued = VIDEO_FALSE;
1551     }
1552
1553 EXIT:
1554     return ret;
1555 }
1556
1557 #if 0
1558 /*
1559  * [Encoder Buffer OPS] Wait (Src)
1560  */
1561 static ExynosVideoErrorType MFC_Encoder_Wait_Inbuf(void *pHandle)
1562 {
1563     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1564     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1565
1566     struct pollfd poll_events;
1567     int poll_state;
1568
1569     if (pCtx == NULL) {
1570         ALOGE("%s: Video context info must be supplied", __func__);
1571         ret = VIDEO_ERROR_BADPARAM;
1572         goto EXIT;
1573     }
1574
1575     poll_events.fd = pCtx->hEnc;
1576     poll_events.events = POLLOUT | POLLERR;
1577     poll_events.revents = 0;
1578
1579     do {
1580         poll_state = poll((struct pollfd*)&poll_events, 1, VIDEO_ENCODER_POLL_TIMEOUT);
1581         if (poll_state > 0) {
1582             if (poll_events.revents & POLLOUT) {
1583                 break;
1584             } else {
1585                 ALOGE("%s: Poll return error", __func__);
1586                 ret = VIDEO_ERROR_POLL;
1587                 break;
1588             }
1589         } else if (poll_state < 0) {
1590             ALOGE("%s: Poll state error", __func__);
1591             ret = VIDEO_ERROR_POLL;
1592             break;
1593         }
1594     } while (poll_state == 0);
1595
1596 EXIT:
1597     return ret;
1598 }
1599
1600 /*
1601  * [Encoder Buffer OPS] Wait (Dst)
1602  */
1603 static ExynosVideoErrorType MFC_Encoder_Wait_Outbuf(void *pHandle)
1604 {
1605     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1606     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1607
1608     struct pollfd poll_events;
1609     int poll_state;
1610     int bframe_count = 0; // FIXME
1611
1612     if (pCtx == NULL) {
1613         ALOGE("%s: Video context info must be supplied", __func__);
1614         ret = VIDEO_ERROR_BADPARAM;
1615         goto EXIT;
1616     }
1617
1618     poll_events.fd = pCtx->hEnc;
1619     poll_events.events = POLLIN | POLLERR;
1620     poll_events.revents = 0;
1621
1622     do {
1623         poll_state = poll((struct pollfd*)&poll_events, 1, VIDEO_ENCODER_POLL_TIMEOUT);
1624         if (poll_state > 0) {
1625             if (poll_events.revents & POLLIN) {
1626                 break;
1627             } else {
1628                 ALOGE("%s: Poll return error", __func__);
1629                 ret = VIDEO_ERROR_POLL;
1630                 break;
1631             }
1632         } else if (poll_state < 0) {
1633             ALOGE("%s: Poll state error", __func__);
1634             ret = VIDEO_ERROR_POLL;
1635             break;
1636         } else {
1637             bframe_count++; // FIXME
1638         }
1639     } while (poll_state == 0 && bframe_count < 5); // FIXME
1640
1641 EXIT:
1642     return ret;
1643 }
1644 #endif
1645
1646 static ExynosVideoErrorType MFC_Encoder_Register_Inbuf(
1647     void             *pHandle,
1648     ExynosVideoPlane *planes,
1649     int               nPlanes)
1650 {
1651     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1652     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1653     int nIndex;
1654
1655     if ((pCtx == NULL) || (planes == NULL) || (nPlanes != VIDEO_ENCODER_INBUF_PLANES)) {
1656         ALOGE("%s: input params must be supplied", __func__);
1657         ret = VIDEO_ERROR_BADPARAM;
1658         goto EXIT;
1659     }
1660
1661     for (nIndex = 0; nIndex < pCtx->nInbufs; nIndex++) {
1662         if (pCtx->pInbuf[nIndex].bRegistered == VIDEO_FALSE) {
1663             int plane;
1664             for (plane = 0; plane < nPlanes; plane++) {
1665                 pCtx->pInbuf[nIndex].planes[plane].addr = planes[plane].addr;
1666                 pCtx->pInbuf[nIndex].planes[plane].allocSize = planes[plane].allocSize;
1667                 pCtx->pInbuf[nIndex].planes[plane].fd = planes[plane].fd;
1668                 ALOGV("%s: addr = 0x%x", __func__, pCtx->pInbuf[nIndex].planes[plane].addr);
1669             }
1670             pCtx->pInbuf[nIndex].bRegistered = VIDEO_TRUE;
1671             break;
1672         }
1673     }
1674
1675     if (nIndex == pCtx->nInbufs) {
1676         ALOGE("%s: can not find non-registered input buffer", __func__);
1677         ret = VIDEO_ERROR_NOBUFFERS;
1678     }
1679
1680 EXIT:
1681     return ret;
1682 }
1683
1684 static ExynosVideoErrorType MFC_Encoder_Register_Outbuf(
1685     void             *pHandle,
1686     ExynosVideoPlane *planes,
1687     int               nPlanes)
1688 {
1689     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1690     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1691     int nIndex;
1692
1693     if ((pCtx == NULL) || (planes == NULL) || (nPlanes != VIDEO_ENCODER_OUTBUF_PLANES)) {
1694         ALOGE("%s: params must be supplied", __func__);
1695         ret = VIDEO_ERROR_BADPARAM;
1696         goto EXIT;
1697     }
1698
1699     for (nIndex = 0; nIndex < pCtx->nOutbufs; nIndex++) {
1700         if (pCtx->pOutbuf[nIndex].bRegistered == VIDEO_FALSE) {
1701             int plane;
1702             for (plane = 0; plane < nPlanes; plane++) {
1703                 pCtx->pOutbuf[nIndex].planes[plane].addr = planes[plane].addr;
1704                 pCtx->pOutbuf[nIndex].planes[plane].allocSize = planes[plane].allocSize;
1705                 pCtx->pOutbuf[nIndex].planes[plane].fd = planes[plane].fd;
1706             }
1707             pCtx->pOutbuf[nIndex].bRegistered = VIDEO_TRUE;
1708             break;
1709         }
1710     }
1711
1712     if (nIndex == pCtx->nOutbufs) {
1713         ALOGE("%s: can not find non-registered output buffer", __func__);
1714         ret = VIDEO_ERROR_NOBUFFERS;
1715     }
1716
1717 EXIT:
1718     return ret;
1719 }
1720
1721 static ExynosVideoErrorType MFC_Encoder_Clear_RegisteredBuffer_Inbuf(void *pHandle)
1722 {
1723     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1724     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1725     int nIndex = -1;
1726
1727     if (pCtx == NULL) {
1728         ALOGE("%s: Video context info must be supplied", __func__);
1729         ret = VIDEO_ERROR_BADPARAM;
1730         goto EXIT;
1731     }
1732
1733     for (nIndex = 0; nIndex < pCtx->nInbufs; nIndex++) {
1734             pCtx->pInbuf[nIndex].planes[0].addr = NULL;
1735             pCtx->pInbuf[nIndex].bRegistered = VIDEO_FALSE;
1736     }
1737
1738 EXIT:
1739     return ret;
1740 }
1741
1742 static ExynosVideoErrorType MFC_Encoder_Clear_RegisteredBuffer_Outbuf(void *pHandle)
1743 {
1744     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1745     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1746     int nIndex = -1;
1747
1748     if (pCtx == NULL) {
1749         ALOGE("%s: Video context info must be supplied", __func__);
1750         ret = VIDEO_ERROR_BADPARAM;
1751         goto EXIT;
1752     }
1753
1754     for (nIndex = 0; nIndex < pCtx->nOutbufs; nIndex++) {
1755             pCtx->pOutbuf[nIndex].planes[0].addr = NULL;
1756             pCtx->pOutbuf[nIndex].bRegistered = VIDEO_FALSE;
1757     }
1758
1759 EXIT:
1760     return ret;
1761 }
1762
1763 /*
1764  * [Encoder Buffer OPS] Find (Input)
1765  */
1766 static int MFC_Encoder_Find_Inbuf(
1767     void          *pHandle,
1768     unsigned char *pBuffer)
1769 {
1770     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1771     int nIndex = -1;
1772
1773     if (pCtx == NULL) {
1774         ALOGE("%s: Video context info must be supplied", __func__);
1775         goto EXIT;
1776     }
1777
1778     for (nIndex = 0; nIndex < pCtx->nInbufs; nIndex++) {
1779         if (pCtx->pInbuf[nIndex].bQueued == VIDEO_FALSE) {
1780             if ((pBuffer == NULL) ||
1781                 (pCtx->pInbuf[nIndex].planes[0].addr == pBuffer))
1782                 break;
1783         }
1784     }
1785
1786     if (nIndex == pCtx->nInbufs)
1787         nIndex = -1;
1788
1789 EXIT:
1790     return nIndex;
1791 }
1792
1793 /*
1794  * [Encoder Buffer OPS] Find (Output)
1795  */
1796 static int MFC_Encoder_Find_Outbuf(
1797     void          *pHandle,
1798     unsigned char *pBuffer)
1799 {
1800     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1801     int nIndex = -1;
1802
1803     if (pCtx == NULL) {
1804         ALOGE("%s: Video context info must be supplied", __func__);
1805         goto EXIT;
1806     }
1807
1808     for (nIndex = 0; nIndex < pCtx->nOutbufs; nIndex++) {
1809         if (pCtx->pOutbuf[nIndex].bQueued == VIDEO_FALSE) {
1810             if ((pBuffer == NULL) ||
1811                 (pCtx->pOutbuf[nIndex].planes[0].addr == pBuffer))
1812                 break;
1813         }
1814     }
1815
1816     if (nIndex == pCtx->nOutbufs)
1817         nIndex = -1;
1818
1819 EXIT:
1820     return nIndex;
1821 }
1822
1823 /*
1824  * [Encoder Buffer OPS] Enqueue (Input)
1825  */
1826 static ExynosVideoErrorType MFC_Encoder_Enqueue_Inbuf(
1827     void          *pHandle,
1828     unsigned char *pBuffer[],
1829     unsigned int   dataSize[],
1830     int            nPlanes,
1831     void          *pPrivate)
1832 {
1833     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1834     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1835     pthread_mutex_t       *pMutex = NULL;
1836
1837     struct v4l2_plane planes[VIDEO_ENCODER_INBUF_PLANES];
1838     struct v4l2_buffer buf;
1839     int index, i;
1840
1841     if (pCtx == NULL) {
1842         ALOGE("%s: Video context info must be supplied", __func__);
1843         ret = VIDEO_ERROR_BADPARAM;
1844         goto EXIT;
1845     }
1846
1847     if (VIDEO_ENCODER_INBUF_PLANES < nPlanes) {
1848         ALOGE("%s: Number of max planes : %d, nPlanes : %d", __func__,
1849                                     VIDEO_ENCODER_INBUF_PLANES, nPlanes);
1850         ret = VIDEO_ERROR_BADPARAM;
1851         goto EXIT;
1852     }
1853
1854     memset(&planes,0,sizeof(planes));
1855     memset(&buf, 0, sizeof(buf));
1856
1857     buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1858     buf.m.planes = planes;
1859     buf.length = VIDEO_ENCODER_INBUF_PLANES;
1860
1861     pMutex = (pthread_mutex_t*)pCtx->pInMutex;
1862     pthread_mutex_lock(pMutex);
1863     index = MFC_Encoder_Find_Inbuf(pCtx, pBuffer[0]);
1864     if (index == -1) {
1865         pthread_mutex_unlock(pMutex);
1866         ALOGE("%s: Failed to get index", __func__);
1867         ret = VIDEO_ERROR_NOBUFFERS;
1868         goto EXIT;
1869     }
1870
1871     buf.index = index;
1872     pCtx->pInbuf[buf.index].bQueued = VIDEO_TRUE;
1873     pthread_mutex_unlock(pMutex);
1874
1875     if (pCtx->bShareInbuf == VIDEO_TRUE) {
1876         buf.memory = pCtx->nMemoryType;
1877
1878         for (i = 0; i < nPlanes; i++) {
1879             /* V4L2_MEMORY_USERPTR */
1880             buf.m.planes[i].m.userptr = (unsigned long)pBuffer[i];
1881             buf.m.planes[i].length = pCtx->pInbuf[index].planes[i].allocSize;
1882             /* V4L2_MEMORY_DMABUF */
1883 #ifdef TIZEN_FEATURE_E3250 /* #ifdef USE_DMA_BUF */
1884             buf.m.planes[i].m.fd = pCtx->pInbuf[buf.index].planes[i].fd;
1885             buf.m.planes[i].length = 0; /* kernel give the length */
1886 #endif
1887             buf.m.planes[i].bytesused = dataSize[i];
1888         }
1889     } else {
1890         buf.memory = V4L2_MEMORY_MMAP;
1891         for (i = 0; i < nPlanes; i++)
1892             buf.m.planes[i].bytesused = dataSize[i];
1893     }
1894
1895         ALOGE("call exynos_v4l2_qbuf(): %d", buf.m.planes[0].m.fd);
1896     if (exynos_v4l2_qbuf(pCtx->hEnc, &buf) != 0) {
1897         ALOGE("%s: Failed to enqueue input buffer", __func__);
1898         pCtx->pInbuf[buf.index].bQueued = VIDEO_FALSE;
1899         ret = VIDEO_ERROR_APIFAIL;
1900         goto EXIT;
1901     }
1902
1903     pCtx->pInbuf[buf.index].pPrivate = pPrivate;
1904
1905 EXIT:
1906     return ret;
1907 }
1908
1909 /*
1910  * [Encoder Buffer OPS] Enqueue (Output)
1911  */
1912 static ExynosVideoErrorType MFC_Encoder_Enqueue_Outbuf(
1913     void          *pHandle,
1914     unsigned char *pBuffer[],
1915     unsigned int   dataSize[],
1916     int            nPlanes,
1917     void          *pPrivate)
1918 {
1919     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1920     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1921     pthread_mutex_t       *pMutex = NULL;
1922
1923     struct v4l2_plane planes[VIDEO_ENCODER_OUTBUF_PLANES];
1924     struct v4l2_buffer buf;
1925     int i, index;
1926
1927     if (pCtx == NULL) {
1928         ALOGE("%s: Video context info must be supplied", __func__);
1929         ret = VIDEO_ERROR_BADPARAM;
1930         goto EXIT;
1931     }
1932
1933     if (VIDEO_ENCODER_OUTBUF_PLANES < nPlanes) {
1934         ALOGE("%s: Number of max planes : %d, nPlanes : %d", __func__,
1935                                     VIDEO_ENCODER_OUTBUF_PLANES, nPlanes);
1936         ret = VIDEO_ERROR_BADPARAM;
1937         goto EXIT;
1938     }
1939
1940     memset(&buf, 0, sizeof(buf));
1941
1942     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1943     buf.m.planes = planes;
1944     buf.length = VIDEO_ENCODER_OUTBUF_PLANES;
1945
1946     pMutex = (pthread_mutex_t*)pCtx->pOutMutex;
1947     pthread_mutex_lock(pMutex);
1948     index = MFC_Encoder_Find_Outbuf(pCtx, pBuffer[0]);
1949     if (index == -1) {
1950         pthread_mutex_unlock(pMutex);
1951         ALOGE("%s: Failed to get index", __func__);
1952         ret = VIDEO_ERROR_NOBUFFERS;
1953         goto EXIT;
1954     }
1955     buf.index = index;
1956     pCtx->pOutbuf[buf.index].bQueued = VIDEO_TRUE;
1957     pthread_mutex_unlock(pMutex);
1958
1959     if (pCtx->bShareOutbuf == VIDEO_TRUE) {
1960         buf.memory = pCtx->nMemoryType;
1961         for (i = 0; i < nPlanes; i++) {
1962             /* V4L2_MEMORY_USERPTR */
1963             buf.m.planes[i].m.userptr = (unsigned long)pBuffer[i];
1964             buf.m.planes[i].length = pCtx->pOutbuf[index].planes[i].allocSize;
1965             /* V4L2_MEMORY_DMABUF */
1966 #ifdef USE_DMA_BUF
1967             buf.m.planes[i].m.fd = pCtx->pOutbuf[index].planes[i].fd;
1968             buf.m.planes[i].length = 0; /* kernel give the length */
1969 #endif
1970             buf.m.planes[i].bytesused = dataSize[i];
1971         }
1972     } else {
1973         buf.memory = V4L2_MEMORY_MMAP;
1974     }
1975
1976     if (exynos_v4l2_qbuf(pCtx->hEnc, &buf) != 0) {
1977         ALOGE("%s: Failed to enqueue output buffer", __func__);
1978         pCtx->pOutbuf[buf.index].bQueued = VIDEO_FALSE;
1979         ret = VIDEO_ERROR_APIFAIL;
1980         goto EXIT;
1981     }
1982
1983     pCtx->pOutbuf[buf.index].pPrivate = pPrivate;
1984
1985 EXIT:
1986     return ret;
1987 }
1988
1989 #if 0
1990 /*
1991  * [Encoder Buffer OPS] Enqueue All (Output)
1992  */
1993 static ExynosVideoErrorType MFC_Encoder_Enqueue_All_Outbuf(void *pHandle)
1994 {
1995     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
1996     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
1997
1998     unsigned char         *pBuffer[VIDEO_BUFFER_MAX_PLANES]  = {NULL, };
1999     unsigned int           dataSize[VIDEO_BUFFER_MAX_PLANES] = {0, };
2000
2001     int i;
2002
2003     if (pCtx == NULL) {
2004         ALOGE("%s: Video context info must be supplied", __func__);
2005         ret = VIDEO_ERROR_BADPARAM;
2006         goto EXIT;
2007     }
2008
2009     for (i = 0; i < pCtx->nOutbufs; i++) {
2010         ret = MFC_Encoder_Enqueue_Outbuf(pCtx, pBuffer, dataSize, 1, NULL);
2011         if (ret != VIDEO_ERROR_NONE)
2012             goto EXIT;
2013     }
2014
2015 EXIT:
2016     return ret;
2017 }
2018 #endif
2019
2020 /*
2021  * [Encoder Buffer OPS] Dequeue (Input)
2022  */
2023 static ExynosVideoBuffer *MFC_Encoder_Dequeue_Inbuf(void *pHandle)
2024 {
2025     ExynosVideoEncContext *pCtx     = (ExynosVideoEncContext *)pHandle;
2026     ExynosVideoBuffer     *pInbuf   = NULL;
2027
2028     struct v4l2_buffer buf;
2029
2030     if (pCtx == NULL) {
2031         ALOGE("%s: Video context info must be supplied", __func__);
2032         goto EXIT;
2033     }
2034
2035     if (pCtx->bStreamonInbuf == VIDEO_FALSE) {
2036         pInbuf = NULL;
2037         goto EXIT;
2038     }
2039
2040     memset(&buf, 0, sizeof(buf));
2041
2042     buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
2043
2044     if (pCtx->bShareInbuf == VIDEO_TRUE)
2045         buf.memory = pCtx->nMemoryType;
2046     else
2047         buf.memory = V4L2_MEMORY_MMAP;
2048
2049     if (exynos_v4l2_dqbuf(pCtx->hEnc, &buf) != 0) {
2050         pInbuf = NULL;
2051         goto EXIT;
2052     }
2053
2054     pInbuf = &pCtx->pInbuf[buf.index];
2055     pCtx->pInbuf[buf.index].bQueued = VIDEO_FALSE;
2056
2057 EXIT:
2058     return pInbuf;
2059 }
2060
2061 /*
2062  * [Encoder Buffer OPS] Dequeue (Output)
2063  */
2064 static ExynosVideoBuffer *MFC_Encoder_Dequeue_Outbuf(void *pHandle)
2065 {
2066     ExynosVideoEncContext *pCtx    = (ExynosVideoEncContext *)pHandle;
2067     ExynosVideoBuffer     *pOutbuf = NULL;
2068
2069     struct v4l2_buffer buf;
2070     struct v4l2_plane  planes[VIDEO_ENCODER_OUTBUF_PLANES];
2071
2072     if (pCtx == NULL) {
2073         ALOGE("%s: Video context info must be supplied", __func__);
2074         goto EXIT;
2075     }
2076
2077     if (pCtx->bStreamonOutbuf == VIDEO_FALSE) {
2078         pOutbuf = NULL;
2079         goto EXIT;
2080     }
2081
2082     memset(&buf, 0, sizeof(buf));
2083
2084     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
2085     buf.m.planes = planes;
2086     buf.length = 1;
2087
2088     if (pCtx->bShareOutbuf == VIDEO_TRUE)
2089         buf.memory = pCtx->nMemoryType;
2090     else
2091         buf.memory = V4L2_MEMORY_MMAP;
2092
2093     /* no error case for output buffer dequeue in encoder */
2094     if (exynos_v4l2_dqbuf(pCtx->hEnc, &buf) != 0) {
2095         goto EXIT;
2096     }
2097
2098     pOutbuf = &pCtx->pOutbuf[buf.index];
2099     pOutbuf->planes[0].dataSize = buf.m.planes[0].bytesused;
2100
2101     switch (buf.flags & (0x7 << 3)) {
2102     case V4L2_BUF_FLAG_KEYFRAME:
2103         pOutbuf->frameType = VIDEO_FRAME_I;
2104         break;
2105     case V4L2_BUF_FLAG_PFRAME:
2106         pOutbuf->frameType = VIDEO_FRAME_P;
2107         break;
2108     case V4L2_BUF_FLAG_BFRAME:
2109         pOutbuf->frameType = VIDEO_FRAME_B;
2110         break;
2111     default:
2112         ALOGI("%s: encoded frame type is = %d",__func__, (buf.flags & (0x7 << 3)));
2113         pOutbuf->frameType = VIDEO_FRAME_OTHERS;
2114         break;
2115     };
2116
2117     pOutbuf->bQueued = VIDEO_FALSE;
2118
2119 EXIT:
2120     return pOutbuf;
2121 }
2122
2123 static ExynosVideoErrorType MFC_Encoder_Clear_Queued_Inbuf(void *pHandle)
2124 {
2125     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
2126     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
2127     int i = 0;
2128
2129     if (pCtx == NULL) {
2130         ALOGE("%s: Video context info must be supplied", __func__);
2131         ret = VIDEO_ERROR_BADPARAM;
2132         goto EXIT;
2133     }
2134
2135     for (i = 0; i <  pCtx->nInbufs; i++) {
2136         pCtx->pInbuf[i].bQueued = VIDEO_FALSE;
2137     }
2138
2139 EXIT:
2140     return ret;
2141 }
2142
2143 static ExynosVideoErrorType MFC_Encoder_Clear_Queued_Outbuf(void *pHandle)
2144 {
2145     ExynosVideoEncContext *pCtx = (ExynosVideoEncContext *)pHandle;
2146     ExynosVideoErrorType   ret  = VIDEO_ERROR_NONE;
2147     int i = 0;
2148
2149     if (pCtx == NULL) {
2150         ALOGE("%s: Video context info must be supplied", __func__);
2151         ret = VIDEO_ERROR_BADPARAM;
2152         goto EXIT;
2153     }
2154
2155     for (i = 0; i < pCtx->nOutbufs; i++) {
2156         pCtx->pOutbuf[i].bQueued = VIDEO_FALSE;
2157     }
2158
2159 EXIT:
2160     return ret;
2161 }
2162
2163 /*
2164  * [Encoder OPS] Common
2165  */
2166 static ExynosVideoEncOps defEncOps = {
2167     .nSize          = 0,
2168     .Init           = MFC_Encoder_Init,
2169     .Finalize       = MFC_Encoder_Finalize,
2170     .Set_EncParam   = MFC_Encoder_Set_EncParam,
2171     .Set_FrameType  = MFC_Encoder_Set_FrameType,
2172     .Set_FrameRate  = MFC_Encoder_Set_FrameRate,
2173     .Set_BitRate    = MFC_Encoder_Set_BitRate,
2174     .Set_FrameSkip  = MFC_Encoder_Set_FrameSkip,
2175     .Set_IDRPeriod  = MFC_Encoder_Set_IDRPeriod,
2176     .Set_FrameTag   = MFC_Encoder_Set_FrameTag,
2177     .Get_FrameTag   = MFC_Encoder_Get_FrameTag,
2178     .Enable_PrependSpsPpsToIdr = MFC_Encoder_Enable_PrependSpsPpsToIdr,
2179 };
2180
2181 /*
2182  * [Encoder Buffer OPS] Input
2183  */
2184 static ExynosVideoEncBufferOps defInbufOps = {
2185     .nSize                  = 0,
2186     .Enable_Cacheable       = MFC_Encoder_Enable_Cacheable_Inbuf,
2187     .Set_Shareable          = MFC_Encoder_Set_Shareable_Inbuf,
2188     .Get_Buffer             = MFC_Encoder_Get_Buffer_Inbuf,
2189     .Set_Geometry           = MFC_Encoder_Set_Geometry_Inbuf,
2190     .Get_Geometry           = MFC_Encoder_Get_Geometry_Inbuf,
2191     .Setup                  = MFC_Encoder_Setup_Inbuf,
2192     .Run                    = MFC_Encoder_Run_Inbuf,
2193     .Stop                   = MFC_Encoder_Stop_Inbuf,
2194     .Enqueue                = MFC_Encoder_Enqueue_Inbuf,
2195     .Enqueue_All            = NULL,
2196     .Dequeue                = MFC_Encoder_Dequeue_Inbuf,
2197     .Register               = MFC_Encoder_Register_Inbuf,
2198     .Clear_RegisteredBuffer = MFC_Encoder_Clear_RegisteredBuffer_Inbuf,
2199     .Clear_Queue            = MFC_Encoder_Clear_Queued_Inbuf,
2200 };
2201
2202 /*
2203  * [Encoder Buffer OPS] Output
2204  */
2205 static ExynosVideoEncBufferOps defOutbufOps = {
2206     .nSize                  = 0,
2207     .Enable_Cacheable       = MFC_Encoder_Enable_Cacheable_Outbuf,
2208     .Set_Shareable          = MFC_Encoder_Set_Shareable_Outbuf,
2209     .Get_Buffer             = MFC_Encoder_Get_Buffer_Outbuf,
2210     .Set_Geometry           = MFC_Encoder_Set_Geometry_Outbuf,
2211     .Get_Geometry           = MFC_Encoder_Get_Geometry_Outbuf,
2212     .Setup                  = MFC_Encoder_Setup_Outbuf,
2213     .Run                    = MFC_Encoder_Run_Outbuf,
2214     .Stop                   = MFC_Encoder_Stop_Outbuf,
2215     .Enqueue                = MFC_Encoder_Enqueue_Outbuf,
2216     .Enqueue_All            = NULL,
2217     .Dequeue                = MFC_Encoder_Dequeue_Outbuf,
2218     .Register               = MFC_Encoder_Register_Outbuf,
2219     .Clear_RegisteredBuffer = MFC_Encoder_Clear_RegisteredBuffer_Outbuf,
2220     .Clear_Queue            = MFC_Encoder_Clear_Queued_Outbuf,
2221 };
2222
2223 int Exynos_Video_Register_Encoder(
2224     ExynosVideoEncOps *pEncOps,
2225     ExynosVideoEncBufferOps *pInbufOps,
2226     ExynosVideoEncBufferOps *pOutbufOps)
2227 {
2228     ExynosVideoErrorType ret = VIDEO_ERROR_NONE;
2229
2230     if ((pEncOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
2231         ret = VIDEO_ERROR_BADPARAM;
2232         goto EXIT;
2233     }
2234
2235     defEncOps.nSize = sizeof(defEncOps);
2236     defInbufOps.nSize = sizeof(defInbufOps);
2237     defOutbufOps.nSize = sizeof(defOutbufOps);
2238
2239     memcpy((char *)pEncOps + sizeof(pEncOps->nSize), (char *)&defEncOps + sizeof(defEncOps.nSize),
2240             pEncOps->nSize - sizeof(pEncOps->nSize));
2241
2242     memcpy((char *)pInbufOps + sizeof(pInbufOps->nSize), (char *)&defInbufOps + sizeof(defInbufOps.nSize),
2243             pInbufOps->nSize - sizeof(pInbufOps->nSize));
2244
2245     memcpy((char *)pOutbufOps + sizeof(pOutbufOps->nSize), (char *)&defOutbufOps + sizeof(defOutbufOps.nSize),
2246             pOutbufOps->nSize - sizeof(pOutbufOps->nSize));
2247
2248 EXIT:
2249     return ret;
2250 }