Home | History | Annotate | Download | only in omx 
      1 /*
      2  * Copyright 2014 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <inttypes.h>
     18 
     19 //#define LOG_NDEBUG 0
     20 #define LOG_TAG "SoftVideoEncoderOMXComponent"
     21 #include <utils/Log.h>
     22 #include <utils/misc.h>
     23 
     24 #include "include/SoftVideoEncoderOMXComponent.h"
     25 
     26 #include <media/hardware/HardwareAPI.h>
     27 #include <media/stagefright/foundation/ADebug.h>
     28 #include <media/stagefright/foundation/ALooper.h>
     29 #include <media/stagefright/foundation/AMessage.h>
     30 #include <media/stagefright/foundation/AUtils.h>
     31 #include <media/stagefright/MediaDefs.h>
     32 
     33 #include <ui/GraphicBuffer.h>
     34 #include <ui/GraphicBufferMapper.h>
     35 
     36 #include <OMX_IndexExt.h>
     37 
     38 namespace android {
     39 
     40 const static OMX_COLOR_FORMATTYPE kSupportedColorFormats[] = {
     41     OMX_COLOR_FormatYUV420Planar,
     42     OMX_COLOR_FormatYUV420SemiPlanar,
     43     OMX_COLOR_FormatAndroidOpaque
     44 };
     45 
     46 template<class T>
     47 static void InitOMXParams(T *params) {
     48     params->nSize = sizeof(T);
     49     params->nVersion.s.nVersionMajor = 1;
     50     params->nVersion.s.nVersionMinor = 0;
     51     params->nVersion.s.nRevision = 0;
     52     params->nVersion.s.nStep = 0;
     53 }
     54 
     55 SoftVideoEncoderOMXComponent::SoftVideoEncoderOMXComponent(
     56         const char *name,
     57         const char *componentRole,
     58         OMX_VIDEO_CODINGTYPE codingType,
     59         const CodecProfileLevel *profileLevels,
     60         size_t numProfileLevels,
     61         int32_t width,
     62         int32_t height,
     63         const OMX_CALLBACKTYPE *callbacks,
     64         OMX_PTR appData,
     65         OMX_COMPONENTTYPE **component)
     66     : SimpleSoftOMXComponent(name, callbacks, appData, component),
     67       mInputDataIsMeta(false),
     68       mWidth(width),
     69       mHeight(height),
     70       mBitrate(192000),
     71       mFramerate(30 << 16), // Q16 format
     72       mColorFormat(OMX_COLOR_FormatYUV420Planar),
     73       mMinOutputBufferSize(384), // arbitrary, using one uncompressed macroblock
     74       mMinCompressionRatio(1),   // max output size is normally the input size
     75       mComponentRole(componentRole),
     76       mCodingType(codingType),
     77       mProfileLevels(profileLevels),
     78       mNumProfileLevels(numProfileLevels) {
     79 }
     80 
     81 void SoftVideoEncoderOMXComponent::initPorts(
     82         OMX_U32 numInputBuffers, OMX_U32 numOutputBuffers, OMX_U32 outputBufferSize,
     83         const char *mime, OMX_U32 minCompressionRatio) {
     84     OMX_PARAM_PORTDEFINITIONTYPE def;
     85 
     86     mMinOutputBufferSize = outputBufferSize;
     87     mMinCompressionRatio = minCompressionRatio;
     88 
     89     InitOMXParams(&def);
     90 
     91     def.nPortIndex = kInputPortIndex;
     92     def.eDir = OMX_DirInput;
     93     def.nBufferCountMin = numInputBuffers;
     94     def.nBufferCountActual = def.nBufferCountMin;
     95     def.bEnabled = OMX_TRUE;
     96     def.bPopulated = OMX_FALSE;
     97     def.eDomain = OMX_PortDomainVideo;
     98     def.bBuffersContiguous = OMX_FALSE;
     99     def.format.video.pNativeRender = NULL;
    100     def.format.video.nFrameWidth = mWidth;
    101     def.format.video.nFrameHeight = mHeight;
    102     def.format.video.nStride = def.format.video.nFrameWidth;
    103     def.format.video.nSliceHeight = def.format.video.nFrameHeight;
    104     def.format.video.nBitrate = 0;
    105     // frameRate is in Q16 format.
    106     def.format.video.xFramerate = mFramerate;
    107     def.format.video.bFlagErrorConcealment = OMX_FALSE;
    108     def.nBufferAlignment = kInputBufferAlignment;
    109     def.format.video.cMIMEType = const_cast<char *>("video/raw");
    110     def.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
    111     def.format.video.eColorFormat = mColorFormat;
    112     def.format.video.pNativeWindow = NULL;
    113     // buffersize set in updatePortParams
    114 
    115     addPort(def);
    116 
    117     InitOMXParams(&def);
    118 
    119     def.nPortIndex = kOutputPortIndex;
    120     def.eDir = OMX_DirOutput;
    121     def.nBufferCountMin = numOutputBuffers;
    122     def.nBufferCountActual = def.nBufferCountMin;
    123     def.bEnabled = OMX_TRUE;
    124     def.bPopulated = OMX_FALSE;
    125     def.eDomain = OMX_PortDomainVideo;
    126     def.bBuffersContiguous = OMX_FALSE;
    127     def.format.video.pNativeRender = NULL;
    128     def.format.video.nFrameWidth = mWidth;
    129     def.format.video.nFrameHeight = mHeight;
    130     def.format.video.nStride = 0;
    131     def.format.video.nSliceHeight = 0;
    132     def.format.video.nBitrate = mBitrate;
    133     def.format.video.xFramerate = 0 << 16;
    134     def.format.video.bFlagErrorConcealment = OMX_FALSE;
    135     def.nBufferAlignment = kOutputBufferAlignment;
    136     def.format.video.cMIMEType = const_cast<char *>(mime);
    137     def.format.video.eCompressionFormat = mCodingType;
    138     def.format.video.eColorFormat = OMX_COLOR_FormatUnused;
    139     def.format.video.pNativeWindow = NULL;
    140     // buffersize set in updatePortParams
    141 
    142     addPort(def);
    143 
    144     updatePortParams();
    145 }
    146 
    147 void SoftVideoEncoderOMXComponent::updatePortParams() {
    148     OMX_PARAM_PORTDEFINITIONTYPE *inDef = &editPortInfo(kInputPortIndex)->mDef;
    149     inDef->format.video.nFrameWidth = mWidth;
    150     inDef->format.video.nFrameHeight = mHeight;
    151     inDef->format.video.nStride = inDef->format.video.nFrameWidth;
    152     inDef->format.video.nSliceHeight = inDef->format.video.nFrameHeight;
    153     inDef->format.video.xFramerate = mFramerate;
    154     inDef->format.video.eColorFormat = mColorFormat;
    155     uint32_t rawBufferSize =
    156         inDef->format.video.nStride * inDef->format.video.nSliceHeight * 3 / 2;
    157     if (inDef->format.video.eColorFormat == OMX_COLOR_FormatAndroidOpaque) {
    158         inDef->nBufferSize = max(sizeof(VideoNativeMetadata), sizeof(VideoGrallocMetadata));
    159     } else {
    160         inDef->nBufferSize = rawBufferSize;
    161     }
    162 
    163     OMX_PARAM_PORTDEFINITIONTYPE *outDef = &editPortInfo(kOutputPortIndex)->mDef;
    164     outDef->format.video.nFrameWidth = mWidth;
    165     outDef->format.video.nFrameHeight = mHeight;
    166     outDef->format.video.nBitrate = mBitrate;
    167 
    168     outDef->nBufferSize = max(mMinOutputBufferSize, rawBufferSize / mMinCompressionRatio);
    169 }
    170 
    171 OMX_ERRORTYPE SoftVideoEncoderOMXComponent::internalSetPortParams(
    172         const OMX_PARAM_PORTDEFINITIONTYPE *port) {
    173 
    174     if (!isValidOMXParam(port)) {
    175         return OMX_ErrorBadParameter;
    176     }
    177 
    178     if (port->nPortIndex == kInputPortIndex) {
    179         mWidth = port->format.video.nFrameWidth;
    180         mHeight = port->format.video.nFrameHeight;
    181 
    182         // xFramerate comes in Q16 format, in frames per second unit
    183         mFramerate = port->format.video.xFramerate;
    184 
    185         if (port->format.video.eCompressionFormat != OMX_VIDEO_CodingUnused
    186                 || (port->format.video.eColorFormat != OMX_COLOR_FormatYUV420Planar
    187                         && port->format.video.eColorFormat != OMX_COLOR_FormatYUV420SemiPlanar
    188                         && port->format.video.eColorFormat != OMX_COLOR_FormatAndroidOpaque)) {
    189             return OMX_ErrorUnsupportedSetting;
    190         }
    191 
    192         mColorFormat = port->format.video.eColorFormat;
    193     } else if (port->nPortIndex == kOutputPortIndex) {
    194         if (port->format.video.eCompressionFormat != mCodingType
    195                 || port->format.video.eColorFormat != OMX_COLOR_FormatUnused) {
    196             return OMX_ErrorUnsupportedSetting;
    197         }
    198 
    199         mBitrate = port->format.video.nBitrate;
    200     } else {
    201         return OMX_ErrorBadPortIndex;
    202     }
    203 
    204     updatePortParams();
    205     return OMX_ErrorNone;
    206 }
    207 
    208 OMX_ERRORTYPE SoftVideoEncoderOMXComponent::internalSetParameter(
    209         OMX_INDEXTYPE index, const OMX_PTR param) {
    210     // can include extension index OMX_INDEXEXTTYPE
    211     const int32_t indexFull = index;
    212 
    213     switch (indexFull) {
    214         case OMX_IndexParamVideoErrorCorrection:
    215         {
    216             return OMX_ErrorNotImplemented;
    217         }
    218 
    219         case OMX_IndexParamStandardComponentRole:
    220         {
    221             const OMX_PARAM_COMPONENTROLETYPE *roleParams =
    222                 (const OMX_PARAM_COMPONENTROLETYPE *)param;
    223 
    224             if (!isValidOMXParam(roleParams)) {
    225                 return OMX_ErrorBadParameter;
    226             }
    227 
    228             if (strncmp((const char *)roleParams->cRole,
    229                         mComponentRole,
    230                         OMX_MAX_STRINGNAME_SIZE - 1)) {
    231                 return OMX_ErrorUnsupportedSetting;
    232             }
    233 
    234             return OMX_ErrorNone;
    235         }
    236 
    237         case OMX_IndexParamPortDefinition:
    238         {
    239             OMX_ERRORTYPE err = internalSetPortParams((const OMX_PARAM_PORTDEFINITIONTYPE *)param);
    240 
    241             if (err != OMX_ErrorNone) {
    242                 return err;
    243             }
    244 
    245             return SimpleSoftOMXComponent::internalSetParameter(index, param);
    246         }
    247 
    248         case OMX_IndexParamVideoPortFormat:
    249         {
    250             const OMX_VIDEO_PARAM_PORTFORMATTYPE* format =
    251                 (const OMX_VIDEO_PARAM_PORTFORMATTYPE *)param;
    252 
    253             if (!isValidOMXParam(format)) {
    254                 return OMX_ErrorBadParameter;
    255             }
    256 
    257             if (format->nPortIndex == kInputPortIndex) {
    258                 if (format->eColorFormat == OMX_COLOR_FormatYUV420Planar ||
    259                     format->eColorFormat == OMX_COLOR_FormatYUV420SemiPlanar ||
    260                     format->eColorFormat == OMX_COLOR_FormatAndroidOpaque) {
    261                     mColorFormat = format->eColorFormat;
    262 
    263                     updatePortParams();
    264                     return OMX_ErrorNone;
    265                 } else {
    266                     ALOGE("Unsupported color format %i", format->eColorFormat);
    267                     return OMX_ErrorUnsupportedSetting;
    268                 }
    269             } else if (format->nPortIndex == kOutputPortIndex) {
    270                 if (format->eCompressionFormat == mCodingType) {
    271                     return OMX_ErrorNone;
    272                 } else {
    273                     return OMX_ErrorUnsupportedSetting;
    274                 }
    275             } else {
    276                 return OMX_ErrorBadPortIndex;
    277             }
    278         }
    279 
    280         case kStoreMetaDataExtensionIndex:
    281         {
    282             // storeMetaDataInBuffers
    283             const StoreMetaDataInBuffersParams *storeParam =
    284                 (const StoreMetaDataInBuffersParams *)param;
    285 
    286             if (!isValidOMXParam(storeParam)) {
    287                 return OMX_ErrorBadParameter;
    288             }
    289 
    290             if (storeParam->nPortIndex == kOutputPortIndex) {
    291                 return storeParam->bStoreMetaData ? OMX_ErrorUnsupportedSetting : OMX_ErrorNone;
    292             } else if (storeParam->nPortIndex != kInputPortIndex) {
    293                 return OMX_ErrorBadPortIndex;
    294             }
    295 
    296             mInputDataIsMeta = (storeParam->bStoreMetaData == OMX_TRUE);
    297             if (mInputDataIsMeta) {
    298                 mColorFormat = OMX_COLOR_FormatAndroidOpaque;
    299             } else if (mColorFormat == OMX_COLOR_FormatAndroidOpaque) {
    300                 mColorFormat = OMX_COLOR_FormatYUV420Planar;
    301             }
    302             updatePortParams();
    303             return OMX_ErrorNone;
    304         }
    305 
    306         default:
    307             return SimpleSoftOMXComponent::internalSetParameter(index, param);
    308     }
    309 }
    310 
    311 OMX_ERRORTYPE SoftVideoEncoderOMXComponent::internalGetParameter(
    312         OMX_INDEXTYPE index, OMX_PTR param) {
    313     switch ((int)index) {
    314         case OMX_IndexParamVideoErrorCorrection:
    315         {
    316             return OMX_ErrorNotImplemented;
    317         }
    318 
    319         case OMX_IndexParamVideoPortFormat:
    320         {
    321             OMX_VIDEO_PARAM_PORTFORMATTYPE *formatParams =
    322                 (OMX_VIDEO_PARAM_PORTFORMATTYPE *)param;
    323 
    324             if (!isValidOMXParam(formatParams)) {
    325                 return OMX_ErrorBadParameter;
    326             }
    327 
    328             if (formatParams->nPortIndex == kInputPortIndex) {
    329                 if (formatParams->nIndex >= NELEM(kSupportedColorFormats)) {
    330                     return OMX_ErrorNoMore;
    331                 }
    332 
    333                 // Color formats, in order of preference
    334                 formatParams->eColorFormat = kSupportedColorFormats[formatParams->nIndex];
    335                 formatParams->eCompressionFormat = OMX_VIDEO_CodingUnused;
    336                 formatParams->xFramerate = mFramerate;
    337                 return OMX_ErrorNone;
    338             } else if (formatParams->nPortIndex == kOutputPortIndex) {
    339                 formatParams->eCompressionFormat = mCodingType;
    340                 formatParams->eColorFormat = OMX_COLOR_FormatUnused;
    341                 formatParams->xFramerate = 0;
    342                 return OMX_ErrorNone;
    343             } else {
    344                 return OMX_ErrorBadPortIndex;
    345             }
    346         }
    347 
    348         case OMX_IndexParamVideoProfileLevelQuerySupported:
    349         {
    350             OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevel =
    351                   (OMX_VIDEO_PARAM_PROFILELEVELTYPE *) param;
    352 
    353             if (!isValidOMXParam(profileLevel)) {
    354                 return OMX_ErrorBadParameter;
    355             }
    356 
    357             if (profileLevel->nPortIndex != kOutputPortIndex) {
    358                 ALOGE("Invalid port index: %u", profileLevel->nPortIndex);
    359                 return OMX_ErrorUnsupportedIndex;
    360             }
    361 
    362             if (profileLevel->nProfileIndex >= mNumProfileLevels) {
    363                 return OMX_ErrorNoMore;
    364             }
    365 
    366             profileLevel->eProfile = mProfileLevels[profileLevel->nProfileIndex].mProfile;
    367             profileLevel->eLevel   = mProfileLevels[profileLevel->nProfileIndex].mLevel;
    368             return OMX_ErrorNone;
    369         }
    370 
    371         case OMX_IndexParamConsumerUsageBits:
    372         {
    373             OMX_U32 *usageBits = (OMX_U32 *)param;
    374             *usageBits = GRALLOC_USAGE_SW_READ_OFTEN;
    375             return OMX_ErrorNone;
    376         }
    377 
    378         default:
    379             return SimpleSoftOMXComponent::internalGetParameter(index, param);
    380     }
    381 }
    382 
    383 // static
    384 __attribute__((no_sanitize("integer")))
    385 void SoftVideoEncoderOMXComponent::ConvertFlexYUVToPlanar(
    386         uint8_t *dst, size_t dstStride, size_t dstVStride,
    387         struct android_ycbcr *ycbcr, int32_t width, int32_t height) {
    388     const uint8_t *src = (const uint8_t *)ycbcr->y;
    389     const uint8_t *srcU = (const uint8_t *)ycbcr->cb;
    390     const uint8_t *srcV = (const uint8_t *)ycbcr->cr;
    391     uint8_t *dstU = dst + dstVStride * dstStride;
    392     uint8_t *dstV = dstU + (dstVStride >> 1) * (dstStride >> 1);
    393 
    394     for (size_t y = height; y > 0; --y) {
    395         memcpy(dst, src, width);
    396         dst += dstStride;
    397         src += ycbcr->ystride;
    398     }
    399     if (ycbcr->cstride == ycbcr->ystride >> 1 && ycbcr->chroma_step == 1) {
    400         // planar
    401         for (size_t y = height >> 1; y > 0; --y) {
    402             memcpy(dstU, srcU, width >> 1);
    403             dstU += dstStride >> 1;
    404             srcU += ycbcr->cstride;
    405             memcpy(dstV, srcV, width >> 1);
    406             dstV += dstStride >> 1;
    407             srcV += ycbcr->cstride;
    408         }
    409     } else {
    410         // arbitrary
    411         for (size_t y = height >> 1; y > 0; --y) {
    412             for (size_t x = width >> 1; x > 0; --x) {
    413                 *dstU++ = *srcU;
    414                 *dstV++ = *srcV;
    415                 srcU += ycbcr->chroma_step;
    416                 srcV += ycbcr->chroma_step;
    417             }
    418             dstU += (dstStride >> 1) - (width >> 1);
    419             dstV += (dstStride >> 1) - (width >> 1);
    420             srcU += ycbcr->cstride - (width >> 1) * ycbcr->chroma_step;
    421             srcV += ycbcr->cstride - (width >> 1) * ycbcr->chroma_step;
    422         }
    423     }
    424 }
    425 
    426 // static
    427 __attribute__((no_sanitize("integer")))
    428 void SoftVideoEncoderOMXComponent::ConvertYUV420SemiPlanarToYUV420Planar(
    429         const uint8_t *inYVU, uint8_t* outYUV, int32_t width, int32_t height) {
    430     // TODO: add support for stride
    431     int32_t outYsize = width * height;
    432     uint32_t *outY  = (uint32_t *) outYUV;
    433     uint16_t *outCb = (uint16_t *) (outYUV + outYsize);
    434     uint16_t *outCr = (uint16_t *) (outYUV + outYsize + (outYsize >> 2));
    435 
    436     /* Y copying */
    437     memcpy(outY, inYVU, outYsize);
    438 
    439     /* U & V copying */
    440     // FIXME this only works if width is multiple of 4
    441     uint32_t *inYVU_4 = (uint32_t *) (inYVU + outYsize);
    442     for (int32_t i = height >> 1; i > 0; --i) {
    443         for (int32_t j = width >> 2; j > 0; --j) {
    444             uint32_t temp = *inYVU_4++;
    445             uint32_t tempU = temp & 0xFF;
    446             tempU = tempU | ((temp >> 8) & 0xFF00);
    447 
    448             uint32_t tempV = (temp >> 8) & 0xFF;
    449             tempV = tempV | ((temp >> 16) & 0xFF00);
    450 
    451             *outCb++ = tempU;
    452             *outCr++ = tempV;
    453         }
    454     }
    455 }
    456 
    457 // static
    458 __attribute__((no_sanitize("integer")))
    459 void SoftVideoEncoderOMXComponent::ConvertRGB32ToPlanar(
    460         uint8_t *dstY, size_t dstStride, size_t dstVStride,
    461         const uint8_t *src, size_t width, size_t height, size_t srcStride,
    462         bool bgr) {
    463     CHECK((width & 1) == 0);
    464     CHECK((height & 1) == 0);
    465 
    466     uint8_t *dstU = dstY + dstStride * dstVStride;
    467     uint8_t *dstV = dstU + (dstStride >> 1) * (dstVStride >> 1);
    468 
    469 #ifdef SURFACE_IS_BGR32
    470     bgr = !bgr;
    471 #endif
    472 
    473     const size_t redOffset   = bgr ? 2 : 0;
    474     const size_t greenOffset = 1;
    475     const size_t blueOffset  = bgr ? 0 : 2;
    476 
    477     for (size_t y = 0; y < height; ++y) {
    478         for (size_t x = 0; x < width; ++x) {
    479             unsigned red   = src[redOffset];
    480             unsigned green = src[greenOffset];
    481             unsigned blue  = src[blueOffset];
    482 
    483             // using ITU-R BT.601 conversion matrix
    484             unsigned luma =
    485                 ((red * 66 + green * 129 + blue * 25) >> 8) + 16;
    486 
    487             dstY[x] = luma;
    488 
    489             if ((x & 1) == 0 && (y & 1) == 0) {
    490                 unsigned U =
    491                     ((-red * 38 - green * 74 + blue * 112) >> 8) + 128;
    492 
    493                 unsigned V =
    494                     ((red * 112 - green * 94 - blue * 18) >> 8) + 128;
    495 
    496                 dstU[x >> 1] = U;
    497                 dstV[x >> 1] = V;
    498             }
    499             src += 4;
    500         }
    501 
    502         if ((y & 1) == 0) {
    503             dstU += dstStride >> 1;
    504             dstV += dstStride >> 1;
    505         }
    506 
    507         src += srcStride - 4 * width;
    508         dstY += dstStride;
    509     }
    510 }
    511 
    512 const uint8_t *SoftVideoEncoderOMXComponent::extractGraphicBuffer(
    513         uint8_t *dst, size_t dstSize,
    514         const uint8_t *src, size_t srcSize,
    515         size_t width, size_t height) const {
    516     size_t dstStride = width;
    517     size_t dstVStride = height;
    518 
    519     MetadataBufferType bufferType = *(MetadataBufferType *)src;
    520     bool usingANWBuffer = bufferType == kMetadataBufferTypeANWBuffer;
    521     if (!usingANWBuffer && bufferType != kMetadataBufferTypeGrallocSource) {
    522         ALOGE("Unsupported metadata type (%d)", bufferType);
    523         return NULL;
    524     }
    525 
    526     buffer_handle_t handle;
    527     int format;
    528     size_t srcStride;
    529     size_t srcVStride;
    530     if (usingANWBuffer) {
    531         if (srcSize < sizeof(VideoNativeMetadata)) {
    532             ALOGE("Metadata is too small (%zu vs %zu)", srcSize, sizeof(VideoNativeMetadata));
    533             return NULL;
    534         }
    535 
    536         VideoNativeMetadata &nativeMeta = *(VideoNativeMetadata *)src;
    537         ANativeWindowBuffer *buffer = nativeMeta.pBuffer;
    538         handle = buffer->handle;
    539         format = buffer->format;
    540         srcStride = buffer->stride;
    541         srcVStride = buffer->height;
    542         // convert stride from pixels to bytes
    543         if (format != HAL_PIXEL_FORMAT_YV12 &&
    544             format != HAL_PIXEL_FORMAT_YCbCr_420_888) {
    545             // TODO do we need to support other formats?
    546             srcStride *= 4;
    547         }
    548 
    549         if (nativeMeta.nFenceFd >= 0) {
    550             sp<Fence> fence = new Fence(nativeMeta.nFenceFd);
    551             nativeMeta.nFenceFd = -1;
    552             status_t err = fence->wait(IOMX::kFenceTimeoutMs);
    553             if (err != OK) {
    554                 ALOGE("Timed out waiting on input fence");
    555                 return NULL;
    556             }
    557         }
    558     } else {
    559         // TODO: remove this part.  Check if anyone uses this.
    560 
    561         if (srcSize < sizeof(VideoGrallocMetadata)) {
    562             ALOGE("Metadata is too small (%zu vs %zu)", srcSize, sizeof(VideoGrallocMetadata));
    563             return NULL;
    564         }
    565 
    566         VideoGrallocMetadata &grallocMeta = *(VideoGrallocMetadata *)(src);
    567         handle = grallocMeta.pHandle;
    568         // assume HAL_PIXEL_FORMAT_RGBA_8888
    569         // there is no way to get the src stride without the graphic buffer
    570         format = HAL_PIXEL_FORMAT_RGBA_8888;
    571         srcStride = width * 4;
    572         srcVStride = height;
    573     }
    574 
    575     size_t neededSize =
    576         dstStride * dstVStride + (width >> 1)
    577                 + (dstStride >> 1) * ((dstVStride >> 1) + (height >> 1) - 1);
    578     if (dstSize < neededSize) {
    579         ALOGE("destination buffer is too small (%zu vs %zu)", dstSize, neededSize);
    580         return NULL;
    581     }
    582 
    583     auto& mapper = GraphicBufferMapper::get();
    584 
    585     void *bits = NULL;
    586     struct android_ycbcr ycbcr;
    587     status_t res;
    588     if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
    589         res = mapper.lockYCbCr(
    590                  handle,
    591                  GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_NEVER,
    592                  Rect(width, height), &ycbcr);
    593     } else {
    594         res = mapper.lock(
    595                  handle,
    596                  GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_NEVER,
    597                  Rect(width, height), &bits);
    598     }
    599     if (res != OK) {
    600         ALOGE("Unable to lock image buffer %p for access", handle);
    601         return NULL;
    602     }
    603 
    604     switch (format) {
    605         case HAL_PIXEL_FORMAT_YV12:  // YCrCb / YVU planar
    606             // convert to flex YUV
    607             ycbcr.y = bits;
    608             ycbcr.cr = (uint8_t *)bits + srcStride * srcVStride;
    609             ycbcr.cb = (uint8_t *)ycbcr.cr + (srcStride >> 1) * (srcVStride >> 1);
    610             ycbcr.chroma_step = 1;
    611             ycbcr.cstride = srcVStride >> 1;
    612             ycbcr.ystride = srcVStride;
    613             ConvertFlexYUVToPlanar(dst, dstStride, dstVStride, &ycbcr, width, height);
    614             break;
    615         case HAL_PIXEL_FORMAT_YCrCb_420_SP:  // YCrCb / YVU semiplanar, NV21
    616             // convert to flex YUV
    617             ycbcr.y = bits;
    618             ycbcr.cr = (uint8_t *)bits + srcStride * srcVStride;
    619             ycbcr.cb = (uint8_t *)ycbcr.cr + 1;
    620             ycbcr.chroma_step = 2;
    621             ycbcr.cstride = srcVStride;
    622             ycbcr.ystride = srcVStride;
    623             ConvertFlexYUVToPlanar(dst, dstStride, dstVStride, &ycbcr, width, height);
    624             break;
    625         case HAL_PIXEL_FORMAT_YCbCr_420_888:
    626             ConvertFlexYUVToPlanar(dst, dstStride, dstVStride, &ycbcr, width, height);
    627             break;
    628         case HAL_PIXEL_FORMAT_RGBX_8888:
    629         case HAL_PIXEL_FORMAT_RGBA_8888:
    630         case HAL_PIXEL_FORMAT_BGRA_8888:
    631             ConvertRGB32ToPlanar(
    632                     dst, dstStride, dstVStride,
    633                     (const uint8_t *)bits, width, height, srcStride,
    634                     format == HAL_PIXEL_FORMAT_BGRA_8888);
    635             break;
    636         default:
    637             ALOGE("Unsupported pixel format %#x", format);
    638             dst = NULL;
    639             break;
    640     }
    641 
    642     if (mapper.unlock(handle) != OK) {
    643         ALOGE("Unable to unlock image buffer %p for access", handle);
    644     }
    645 
    646     return dst;
    647 }
    648 
    649 OMX_ERRORTYPE SoftVideoEncoderOMXComponent::getExtensionIndex(
    650         const char *name, OMX_INDEXTYPE *index) {
    651     if (!strcmp(name, "OMX.google.android.index.storeMetaDataInBuffers") ||
    652         !strcmp(name, "OMX.google.android.index.storeANWBufferInMetadata")) {
    653         *(int32_t*)index = kStoreMetaDataExtensionIndex;
    654         return OMX_ErrorNone;
    655     }
    656     return SimpleSoftOMXComponent::getExtensionIndex(name, index);
    657 }
    658 
    659 }  // namespace android
    660