SoftAVCEncoder.cpp revision 84333e0475bc911adc16417f4ca327c975cf6c36 
1/*
2 * Copyright (C) 2012 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//#define LOG_NDEBUG 0
18#define LOG_TAG "SoftAVCEncoder"
19#include <utils/Log.h>
20
21#include "avcenc_api.h"
22#include "avcenc_int.h"
23#include "OMX_Video.h"
24
25#include <HardwareAPI.h>
26#include <MetadataBufferType.h>
27#include <media/stagefright/foundation/ADebug.h>
28#include <media/stagefright/MediaDefs.h>
29#include <media/stagefright/MediaErrors.h>
30#include <media/stagefright/MetaData.h>
31#include <media/stagefright/Utils.h>
32#include <ui/Rect.h>
33#include <ui/GraphicBufferMapper.h>
34
35#include "SoftAVCEncoder.h"
36
37#if LOG_NDEBUG
38#define UNUSED_UNLESS_VERBOSE(x) (void)(x)
39#else
40#define UNUSED_UNLESS_VERBOSE(x)
41#endif
42
43namespace android {
44
45template<class T>
46static void InitOMXParams(T *params) {
47    params->nSize = sizeof(T);
48    params->nVersion.s.nVersionMajor = 1;
49    params->nVersion.s.nVersionMinor = 0;
50    params->nVersion.s.nRevision = 0;
51    params->nVersion.s.nStep = 0;
52}
53
54typedef struct LevelConversion {
55    OMX_U32 omxLevel;
56    AVCLevel avcLevel;
57} LevelConcersion;
58
59static LevelConversion ConversionTable[] = {
60    { OMX_VIDEO_AVCLevel1,  AVC_LEVEL1_B },
61    { OMX_VIDEO_AVCLevel1b, AVC_LEVEL1   },
62    { OMX_VIDEO_AVCLevel11, AVC_LEVEL1_1 },
63    { OMX_VIDEO_AVCLevel12, AVC_LEVEL1_2 },
64    { OMX_VIDEO_AVCLevel13, AVC_LEVEL1_3 },
65    { OMX_VIDEO_AVCLevel2,  AVC_LEVEL2 },
66#if 0
67    // encoding speed is very poor if video
68    // resolution is higher than CIF
69    { OMX_VIDEO_AVCLevel21, AVC_LEVEL2_1 },
70    { OMX_VIDEO_AVCLevel22, AVC_LEVEL2_2 },
71    { OMX_VIDEO_AVCLevel3,  AVC_LEVEL3   },
72    { OMX_VIDEO_AVCLevel31, AVC_LEVEL3_1 },
73    { OMX_VIDEO_AVCLevel32, AVC_LEVEL3_2 },
74    { OMX_VIDEO_AVCLevel4,  AVC_LEVEL4   },
75    { OMX_VIDEO_AVCLevel41, AVC_LEVEL4_1 },
76    { OMX_VIDEO_AVCLevel42, AVC_LEVEL4_2 },
77    { OMX_VIDEO_AVCLevel5,  AVC_LEVEL5   },
78    { OMX_VIDEO_AVCLevel51, AVC_LEVEL5_1 },
79#endif
80};
81
82static status_t ConvertOmxAvcLevelToAvcSpecLevel(
83        OMX_U32 omxLevel, AVCLevel *avcLevel) {
84    for (size_t i = 0, n = sizeof(ConversionTable)/sizeof(ConversionTable[0]);
85        i < n; ++i) {
86        if (omxLevel == ConversionTable[i].omxLevel) {
87            *avcLevel = ConversionTable[i].avcLevel;
88            return OK;
89        }
90    }
91
92    ALOGE("ConvertOmxAvcLevelToAvcSpecLevel: %d level not supported",
93            (int32_t)omxLevel);
94
95    return BAD_VALUE;
96}
97
98static status_t ConvertAvcSpecLevelToOmxAvcLevel(
99    AVCLevel avcLevel, OMX_U32 *omxLevel) {
100    for (size_t i = 0, n = sizeof(ConversionTable)/sizeof(ConversionTable[0]);
101        i < n; ++i) {
102        if (avcLevel == ConversionTable[i].avcLevel) {
103            *omxLevel = ConversionTable[i].omxLevel;
104            return OK;
105        }
106    }
107
108    ALOGE("ConvertAvcSpecLevelToOmxAvcLevel: %d level not supported",
109            (int32_t) avcLevel);
110
111    return BAD_VALUE;
112}
113
114inline static void ConvertYUV420SemiPlanarToYUV420Planar(
115        uint8_t *inyuv, uint8_t* outyuv,
116        int32_t width, int32_t height) {
117
118    int32_t outYsize = width * height;
119    uint32_t *outy =  (uint32_t *) outyuv;
120    uint16_t *outcb = (uint16_t *) (outyuv + outYsize);
121    uint16_t *outcr = (uint16_t *) (outyuv + outYsize + (outYsize >> 2));
122
123    /* Y copying */
124    memcpy(outy, inyuv, outYsize);
125
126    /* U & V copying */
127    uint32_t *inyuv_4 = (uint32_t *) (inyuv + outYsize);
128    for (int32_t i = height >> 1; i > 0; --i) {
129        for (int32_t j = width >> 2; j > 0; --j) {
130            uint32_t temp = *inyuv_4++;
131            uint32_t tempU = temp & 0xFF;
132            tempU = tempU | ((temp >> 8) & 0xFF00);
133
134            uint32_t tempV = (temp >> 8) & 0xFF;
135            tempV = tempV | ((temp >> 16) & 0xFF00);
136
137            // Flip U and V
138            *outcb++ = tempV;
139            *outcr++ = tempU;
140        }
141    }
142}
143
144static void* MallocWrapper(
145        void * /* userData */, int32_t size, int32_t /* attrs */) {
146    void *ptr = malloc(size);
147    if (ptr)
148        memset(ptr, 0, size);
149    return ptr;
150}
151
152static void FreeWrapper(void * /* userData */, void* ptr) {
153    free(ptr);
154}
155
156static int32_t DpbAllocWrapper(void *userData,
157        unsigned int sizeInMbs, unsigned int numBuffers) {
158    SoftAVCEncoder *encoder = static_cast<SoftAVCEncoder *>(userData);
159    CHECK(encoder != NULL);
160    return encoder->allocOutputBuffers(sizeInMbs, numBuffers);
161}
162
163static int32_t BindFrameWrapper(
164        void *userData, int32_t index, uint8_t **yuv) {
165    SoftAVCEncoder *encoder = static_cast<SoftAVCEncoder *>(userData);
166    CHECK(encoder != NULL);
167    return encoder->bindOutputBuffer(index, yuv);
168}
169
170static void UnbindFrameWrapper(void *userData, int32_t index) {
171    SoftAVCEncoder *encoder = static_cast<SoftAVCEncoder *>(userData);
172    CHECK(encoder != NULL);
173    return encoder->unbindOutputBuffer(index);
174}
175
176SoftAVCEncoder::SoftAVCEncoder(
177            const char *name,
178            const OMX_CALLBACKTYPE *callbacks,
179            OMX_PTR appData,
180            OMX_COMPONENTTYPE **component)
181    : SimpleSoftOMXComponent(name, callbacks, appData, component),
182      mVideoWidth(176),
183      mVideoHeight(144),
184      mVideoFrameRate(30),
185      mVideoBitRate(192000),
186      mVideoColorFormat(OMX_COLOR_FormatYUV420Planar),
187      mStoreMetaDataInBuffers(false),
188      mIDRFrameRefreshIntervalInSec(1),
189      mAVCEncProfile(AVC_BASELINE),
190      mAVCEncLevel(AVC_LEVEL2),
191      mNumInputFrames(-1),
192      mPrevTimestampUs(-1),
193      mStarted(false),
194      mSawInputEOS(false),
195      mSignalledError(false),
196      mHandle(new tagAVCHandle),
197      mEncParams(new tagAVCEncParam),
198      mInputFrameData(NULL),
199      mSliceGroup(NULL) {
200
201    initPorts();
202    ALOGI("Construct SoftAVCEncoder");
203}
204
205SoftAVCEncoder::~SoftAVCEncoder() {
206    ALOGV("Destruct SoftAVCEncoder");
207    releaseEncoder();
208    List<BufferInfo *> &outQueue = getPortQueue(1);
209    List<BufferInfo *> &inQueue = getPortQueue(0);
210    CHECK(outQueue.empty());
211    CHECK(inQueue.empty());
212}
213
214OMX_ERRORTYPE SoftAVCEncoder::initEncParams() {
215    CHECK(mHandle != NULL);
216    memset(mHandle, 0, sizeof(tagAVCHandle));
217    mHandle->AVCObject = NULL;
218    mHandle->userData = this;
219    mHandle->CBAVC_DPBAlloc = DpbAllocWrapper;
220    mHandle->CBAVC_FrameBind = BindFrameWrapper;
221    mHandle->CBAVC_FrameUnbind = UnbindFrameWrapper;
222    mHandle->CBAVC_Malloc = MallocWrapper;
223    mHandle->CBAVC_Free = FreeWrapper;
224
225    CHECK(mEncParams != NULL);
226    memset(mEncParams, 0, sizeof(*mEncParams));
227    mEncParams->rate_control = AVC_ON;
228    mEncParams->initQP = 0;
229    mEncParams->init_CBP_removal_delay = 1600;
230
231    mEncParams->intramb_refresh = 0;
232    mEncParams->auto_scd = AVC_ON;
233    mEncParams->out_of_band_param_set = AVC_ON;
234    mEncParams->poc_type = 2;
235    mEncParams->log2_max_poc_lsb_minus_4 = 12;
236    mEncParams->delta_poc_zero_flag = 0;
237    mEncParams->offset_poc_non_ref = 0;
238    mEncParams->offset_top_bottom = 0;
239    mEncParams->num_ref_in_cycle = 0;
240    mEncParams->offset_poc_ref = NULL;
241
242    mEncParams->num_ref_frame = 1;
243    mEncParams->num_slice_group = 1;
244    mEncParams->fmo_type = 0;
245
246    mEncParams->db_filter = AVC_ON;
247    mEncParams->disable_db_idc = 0;
248
249    mEncParams->alpha_offset = 0;
250    mEncParams->beta_offset = 0;
251    mEncParams->constrained_intra_pred = AVC_OFF;
252
253    mEncParams->data_par = AVC_OFF;
254    mEncParams->fullsearch = AVC_OFF;
255    mEncParams->search_range = 16;
256    mEncParams->sub_pel = AVC_OFF;
257    mEncParams->submb_pred = AVC_OFF;
258    mEncParams->rdopt_mode = AVC_OFF;
259    mEncParams->bidir_pred = AVC_OFF;
260
261    mEncParams->use_overrun_buffer = AVC_OFF;
262
263    if (mVideoColorFormat == OMX_COLOR_FormatYUV420SemiPlanar) {
264        // Color conversion is needed.
265        CHECK(mInputFrameData == NULL);
266        mInputFrameData =
267            (uint8_t *) malloc((mVideoWidth * mVideoHeight * 3 ) >> 1);
268        CHECK(mInputFrameData != NULL);
269    }
270
271    // PV's AVC encoder requires the video dimension of multiple
272    if (mVideoWidth % 16 != 0 || mVideoHeight % 16 != 0) {
273        ALOGE("Video frame size %dx%d must be a multiple of 16",
274            mVideoWidth, mVideoHeight);
275        return OMX_ErrorBadParameter;
276    }
277
278    mEncParams->width = mVideoWidth;
279    mEncParams->height = mVideoHeight;
280    mEncParams->bitrate = mVideoBitRate;
281    mEncParams->frame_rate = 1000 * mVideoFrameRate;  // In frames/ms!
282    mEncParams->CPB_size = (uint32_t) (mVideoBitRate >> 1);
283
284    int32_t nMacroBlocks = ((((mVideoWidth + 15) >> 4) << 4) *
285            (((mVideoHeight + 15) >> 4) << 4)) >> 8;
286    CHECK(mSliceGroup == NULL);
287    mSliceGroup = (uint32_t *) malloc(sizeof(uint32_t) * nMacroBlocks);
288    CHECK(mSliceGroup != NULL);
289    for (int ii = 0, idx = 0; ii < nMacroBlocks; ++ii) {
290        mSliceGroup[ii] = idx++;
291        if (idx >= mEncParams->num_slice_group) {
292            idx = 0;
293        }
294    }
295    mEncParams->slice_group = mSliceGroup;
296
297    // Set IDR frame refresh interval
298    if (mIDRFrameRefreshIntervalInSec < 0) {
299        mEncParams->idr_period = -1;
300    } else if (mIDRFrameRefreshIntervalInSec == 0) {
301        mEncParams->idr_period = 1;  // All I frames
302    } else {
303        mEncParams->idr_period =
304            (mIDRFrameRefreshIntervalInSec * mVideoFrameRate);
305    }
306
307    // Set profile and level
308    mEncParams->profile = mAVCEncProfile;
309    mEncParams->level = mAVCEncLevel;
310
311    return OMX_ErrorNone;
312}
313
314OMX_ERRORTYPE SoftAVCEncoder::initEncoder() {
315    CHECK(!mStarted);
316
317    OMX_ERRORTYPE errType = OMX_ErrorNone;
318    if (OMX_ErrorNone != (errType = initEncParams())) {
319        ALOGE("Failed to initialized encoder params");
320        mSignalledError = true;
321        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
322        return errType;
323    }
324
325    AVCEnc_Status err;
326    err = PVAVCEncInitialize(mHandle, mEncParams, NULL, NULL);
327    if (err != AVCENC_SUCCESS) {
328        ALOGE("Failed to initialize the encoder: %d", err);
329        mSignalledError = true;
330        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
331        return OMX_ErrorUndefined;
332    }
333
334    mNumInputFrames = -2;  // 1st two buffers contain SPS and PPS
335    mSpsPpsHeaderReceived = false;
336    mReadyForNextFrame = true;
337    mIsIDRFrame = false;
338    mStarted = true;
339
340    return OMX_ErrorNone;
341}
342
343OMX_ERRORTYPE SoftAVCEncoder::releaseEncoder() {
344    if (!mStarted) {
345        return OMX_ErrorNone;
346    }
347
348    PVAVCCleanUpEncoder(mHandle);
349    releaseOutputBuffers();
350
351    delete mInputFrameData;
352    mInputFrameData = NULL;
353
354    delete mSliceGroup;
355    mSliceGroup = NULL;
356
357    delete mEncParams;
358    mEncParams = NULL;
359
360    delete mHandle;
361    mHandle = NULL;
362
363    mStarted = false;
364
365    return OMX_ErrorNone;
366}
367
368void SoftAVCEncoder::releaseOutputBuffers() {
369    for (size_t i = 0; i < mOutputBuffers.size(); ++i) {
370        MediaBuffer *buffer = mOutputBuffers.editItemAt(i);
371        buffer->setObserver(NULL);
372        buffer->release();
373    }
374    mOutputBuffers.clear();
375}
376
377void SoftAVCEncoder::initPorts() {
378    OMX_PARAM_PORTDEFINITIONTYPE def;
379    InitOMXParams(&def);
380
381    const size_t kInputBufferSize = (mVideoWidth * mVideoHeight * 3) >> 1;
382
383    // 31584 is PV's magic number.  Not sure why.
384    const size_t kOutputBufferSize =
385            (kInputBufferSize > 31584) ? kInputBufferSize: 31584;
386
387    def.nPortIndex = 0;
388    def.eDir = OMX_DirInput;
389    def.nBufferCountMin = kNumBuffers;
390    def.nBufferCountActual = def.nBufferCountMin;
391    def.nBufferSize = kInputBufferSize;
392    def.bEnabled = OMX_TRUE;
393    def.bPopulated = OMX_FALSE;
394    def.eDomain = OMX_PortDomainVideo;
395    def.bBuffersContiguous = OMX_FALSE;
396    def.nBufferAlignment = 1;
397
398    def.format.video.cMIMEType = const_cast<char *>("video/raw");
399    def.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
400    def.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
401    def.format.video.xFramerate = (mVideoFrameRate << 16);  // Q16 format
402    def.format.video.nBitrate = mVideoBitRate;
403    def.format.video.nFrameWidth = mVideoWidth;
404    def.format.video.nFrameHeight = mVideoHeight;
405    def.format.video.nStride = mVideoWidth;
406    def.format.video.nSliceHeight = mVideoHeight;
407
408    addPort(def);
409
410    def.nPortIndex = 1;
411    def.eDir = OMX_DirOutput;
412    def.nBufferCountMin = kNumBuffers;
413    def.nBufferCountActual = def.nBufferCountMin;
414    def.nBufferSize = kOutputBufferSize;
415    def.bEnabled = OMX_TRUE;
416    def.bPopulated = OMX_FALSE;
417    def.eDomain = OMX_PortDomainVideo;
418    def.bBuffersContiguous = OMX_FALSE;
419    def.nBufferAlignment = 2;
420
421    def.format.video.cMIMEType = const_cast<char *>("video/avc");
422    def.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
423    def.format.video.eColorFormat = OMX_COLOR_FormatUnused;
424    def.format.video.xFramerate = (0 << 16);  // Q16 format
425    def.format.video.nBitrate = mVideoBitRate;
426    def.format.video.nFrameWidth = mVideoWidth;
427    def.format.video.nFrameHeight = mVideoHeight;
428    def.format.video.nStride = mVideoWidth;
429    def.format.video.nSliceHeight = mVideoHeight;
430
431    addPort(def);
432}
433
434OMX_ERRORTYPE SoftAVCEncoder::internalGetParameter(
435        OMX_INDEXTYPE index, OMX_PTR params) {
436    switch (index) {
437        case OMX_IndexParamVideoErrorCorrection:
438        {
439            return OMX_ErrorNotImplemented;
440        }
441
442        case OMX_IndexParamVideoBitrate:
443        {
444            OMX_VIDEO_PARAM_BITRATETYPE *bitRate =
445                (OMX_VIDEO_PARAM_BITRATETYPE *) params;
446
447            if (bitRate->nPortIndex != 1) {
448                return OMX_ErrorUndefined;
449            }
450
451            bitRate->eControlRate = OMX_Video_ControlRateVariable;
452            bitRate->nTargetBitrate = mVideoBitRate;
453            return OMX_ErrorNone;
454        }
455
456        case OMX_IndexParamVideoPortFormat:
457        {
458            OMX_VIDEO_PARAM_PORTFORMATTYPE *formatParams =
459                (OMX_VIDEO_PARAM_PORTFORMATTYPE *)params;
460
461            if (formatParams->nPortIndex > 1) {
462                return OMX_ErrorUndefined;
463            }
464
465            if (formatParams->nIndex > 2) {
466                return OMX_ErrorNoMore;
467            }
468
469            if (formatParams->nPortIndex == 0) {
470                formatParams->eCompressionFormat = OMX_VIDEO_CodingUnused;
471                if (formatParams->nIndex == 0) {
472                    formatParams->eColorFormat = OMX_COLOR_FormatYUV420Planar;
473                } else if (formatParams->nIndex == 1) {
474                    formatParams->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
475                } else {
476                    formatParams->eColorFormat = OMX_COLOR_FormatAndroidOpaque;
477                }
478            } else {
479                formatParams->eCompressionFormat = OMX_VIDEO_CodingAVC;
480                formatParams->eColorFormat = OMX_COLOR_FormatUnused;
481            }
482
483            return OMX_ErrorNone;
484        }
485
486        case OMX_IndexParamVideoAvc:
487        {
488            OMX_VIDEO_PARAM_AVCTYPE *avcParams =
489                (OMX_VIDEO_PARAM_AVCTYPE *)params;
490
491            if (avcParams->nPortIndex != 1) {
492                return OMX_ErrorUndefined;
493            }
494
495            avcParams->eProfile = OMX_VIDEO_AVCProfileBaseline;
496            OMX_U32 omxLevel = AVC_LEVEL2;
497            if (OMX_ErrorNone !=
498                ConvertAvcSpecLevelToOmxAvcLevel(mAVCEncLevel, &omxLevel)) {
499                return OMX_ErrorUndefined;
500            }
501
502            avcParams->eLevel = (OMX_VIDEO_AVCLEVELTYPE) omxLevel;
503            avcParams->nRefFrames = 1;
504            avcParams->nBFrames = 0;
505            avcParams->bUseHadamard = OMX_TRUE;
506            avcParams->nAllowedPictureTypes =
507                    (OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP);
508            avcParams->nRefIdx10ActiveMinus1 = 0;
509            avcParams->nRefIdx11ActiveMinus1 = 0;
510            avcParams->bWeightedPPrediction = OMX_FALSE;
511            avcParams->bEntropyCodingCABAC = OMX_FALSE;
512            avcParams->bconstIpred = OMX_FALSE;
513            avcParams->bDirect8x8Inference = OMX_FALSE;
514            avcParams->bDirectSpatialTemporal = OMX_FALSE;
515            avcParams->nCabacInitIdc = 0;
516            return OMX_ErrorNone;
517        }
518
519        case OMX_IndexParamVideoProfileLevelQuerySupported:
520        {
521            OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevel =
522                (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)params;
523
524            if (profileLevel->nPortIndex != 1) {
525                return OMX_ErrorUndefined;
526            }
527
528            const size_t size =
529                    sizeof(ConversionTable) / sizeof(ConversionTable[0]);
530
531            if (profileLevel->nProfileIndex >= size) {
532                return OMX_ErrorNoMore;
533            }
534
535            profileLevel->eProfile = OMX_VIDEO_AVCProfileBaseline;
536            profileLevel->eLevel = ConversionTable[profileLevel->nProfileIndex].omxLevel;
537
538            return OMX_ErrorNone;
539        }
540
541        default:
542            return SimpleSoftOMXComponent::internalGetParameter(index, params);
543    }
544}
545
546OMX_ERRORTYPE SoftAVCEncoder::internalSetParameter(
547        OMX_INDEXTYPE index, const OMX_PTR params) {
548    int32_t indexFull = index;
549
550    switch (indexFull) {
551        case OMX_IndexParamVideoErrorCorrection:
552        {
553            return OMX_ErrorNotImplemented;
554        }
555
556        case OMX_IndexParamVideoBitrate:
557        {
558            OMX_VIDEO_PARAM_BITRATETYPE *bitRate =
559                (OMX_VIDEO_PARAM_BITRATETYPE *) params;
560
561            if (bitRate->nPortIndex != 1 ||
562                bitRate->eControlRate != OMX_Video_ControlRateVariable) {
563                return OMX_ErrorUndefined;
564            }
565
566            mVideoBitRate = bitRate->nTargetBitrate;
567            return OMX_ErrorNone;
568        }
569
570        case OMX_IndexParamPortDefinition:
571        {
572            OMX_PARAM_PORTDEFINITIONTYPE *def =
573                (OMX_PARAM_PORTDEFINITIONTYPE *)params;
574            if (def->nPortIndex > 1) {
575                return OMX_ErrorUndefined;
576            }
577
578            if (def->nPortIndex == 0) {
579                if (def->format.video.eCompressionFormat != OMX_VIDEO_CodingUnused ||
580                    (def->format.video.eColorFormat != OMX_COLOR_FormatYUV420Planar &&
581                     def->format.video.eColorFormat != OMX_COLOR_FormatYUV420SemiPlanar &&
582                     def->format.video.eColorFormat != OMX_COLOR_FormatAndroidOpaque)) {
583                    return OMX_ErrorUndefined;
584                }
585            } else {
586                if (def->format.video.eCompressionFormat != OMX_VIDEO_CodingAVC ||
587                    (def->format.video.eColorFormat != OMX_COLOR_FormatUnused)) {
588                    return OMX_ErrorUndefined;
589                }
590            }
591
592            OMX_ERRORTYPE err = SimpleSoftOMXComponent::internalSetParameter(index, params);
593            if (OMX_ErrorNone != err) {
594                return err;
595            }
596
597            if (def->nPortIndex == 0) {
598                mVideoWidth = def->format.video.nFrameWidth;
599                mVideoHeight = def->format.video.nFrameHeight;
600                mVideoFrameRate = def->format.video.xFramerate >> 16;
601                mVideoColorFormat = def->format.video.eColorFormat;
602
603                OMX_PARAM_PORTDEFINITIONTYPE *portDef =
604                    &editPortInfo(0)->mDef;
605                portDef->format.video.nFrameWidth = mVideoWidth;
606                portDef->format.video.nFrameHeight = mVideoHeight;
607                portDef->format.video.xFramerate = def->format.video.xFramerate;
608                portDef->format.video.eColorFormat =
609                    (OMX_COLOR_FORMATTYPE) mVideoColorFormat;
610                portDef = &editPortInfo(1)->mDef;
611                portDef->format.video.nFrameWidth = mVideoWidth;
612                portDef->format.video.nFrameHeight = mVideoHeight;
613            } else {
614                mVideoBitRate = def->format.video.nBitrate;
615            }
616
617            return OMX_ErrorNone;
618        }
619
620        case OMX_IndexParamStandardComponentRole:
621        {
622            const OMX_PARAM_COMPONENTROLETYPE *roleParams =
623                (const OMX_PARAM_COMPONENTROLETYPE *)params;
624
625            if (strncmp((const char *)roleParams->cRole,
626                        "video_encoder.avc",
627                        OMX_MAX_STRINGNAME_SIZE - 1)) {
628                return OMX_ErrorUndefined;
629            }
630
631            return OMX_ErrorNone;
632        }
633
634        case OMX_IndexParamVideoPortFormat:
635        {
636            const OMX_VIDEO_PARAM_PORTFORMATTYPE *formatParams =
637                (const OMX_VIDEO_PARAM_PORTFORMATTYPE *)params;
638
639            if (formatParams->nPortIndex > 1) {
640                return OMX_ErrorUndefined;
641            }
642
643            if (formatParams->nIndex > 2) {
644                return OMX_ErrorNoMore;
645            }
646
647            if (formatParams->nPortIndex == 0) {
648                if (formatParams->eCompressionFormat != OMX_VIDEO_CodingUnused ||
649                    ((formatParams->nIndex == 0 &&
650                      formatParams->eColorFormat != OMX_COLOR_FormatYUV420Planar) ||
651                    (formatParams->nIndex == 1 &&
652                     formatParams->eColorFormat != OMX_COLOR_FormatYUV420SemiPlanar) ||
653                    (formatParams->nIndex == 2 &&
654                     formatParams->eColorFormat != OMX_COLOR_FormatAndroidOpaque) )) {
655                    return OMX_ErrorUndefined;
656                }
657                mVideoColorFormat = formatParams->eColorFormat;
658            } else {
659                if (formatParams->eCompressionFormat != OMX_VIDEO_CodingAVC ||
660                    formatParams->eColorFormat != OMX_COLOR_FormatUnused) {
661                    return OMX_ErrorUndefined;
662                }
663            }
664
665            return OMX_ErrorNone;
666        }
667
668        case OMX_IndexParamVideoAvc:
669        {
670            OMX_VIDEO_PARAM_AVCTYPE *avcType =
671                (OMX_VIDEO_PARAM_AVCTYPE *)params;
672
673            if (avcType->nPortIndex != 1) {
674                return OMX_ErrorUndefined;
675            }
676
677            // PV's AVC encoder only supports baseline profile
678            if (avcType->eProfile != OMX_VIDEO_AVCProfileBaseline ||
679                avcType->nRefFrames != 1 ||
680                avcType->nBFrames != 0 ||
681                avcType->bUseHadamard != OMX_TRUE ||
682                (avcType->nAllowedPictureTypes & OMX_VIDEO_PictureTypeB) != 0 ||
683                avcType->nRefIdx10ActiveMinus1 != 0 ||
684                avcType->nRefIdx11ActiveMinus1 != 0 ||
685                avcType->bWeightedPPrediction != OMX_FALSE ||
686                avcType->bEntropyCodingCABAC != OMX_FALSE ||
687                avcType->bconstIpred != OMX_FALSE ||
688                avcType->bDirect8x8Inference != OMX_FALSE ||
689                avcType->bDirectSpatialTemporal != OMX_FALSE ||
690                avcType->nCabacInitIdc != 0) {
691                return OMX_ErrorUndefined;
692            }
693
694            if (OK != ConvertOmxAvcLevelToAvcSpecLevel(avcType->eLevel, &mAVCEncLevel)) {
695                return OMX_ErrorUndefined;
696            }
697
698            return OMX_ErrorNone;
699        }
700
701        case kStoreMetaDataExtensionIndex:
702        {
703            StoreMetaDataInBuffersParams *storeParams =
704                    (StoreMetaDataInBuffersParams*)params;
705            if (storeParams->nPortIndex != 0) {
706                ALOGE("%s: StoreMetadataInBuffersParams.nPortIndex not zero!",
707                        __FUNCTION__);
708                return OMX_ErrorUndefined;
709            }
710
711            mStoreMetaDataInBuffers = storeParams->bStoreMetaData;
712            ALOGV("StoreMetaDataInBuffers set to: %s",
713                    mStoreMetaDataInBuffers ? " true" : "false");
714
715            if (mStoreMetaDataInBuffers) {
716                mVideoColorFormat == OMX_COLOR_FormatYUV420SemiPlanar;
717                if (mInputFrameData == NULL) {
718                    mInputFrameData =
719                            (uint8_t *) malloc((mVideoWidth * mVideoHeight * 3 ) >> 1);
720                }
721            }
722
723            return OMX_ErrorNone;
724        }
725
726        default:
727            return SimpleSoftOMXComponent::internalSetParameter(index, params);
728    }
729}
730
731void SoftAVCEncoder::onQueueFilled(OMX_U32 /* portIndex */) {
732    if (mSignalledError || mSawInputEOS) {
733        return;
734    }
735
736    if (!mStarted) {
737        if (OMX_ErrorNone != initEncoder()) {
738            return;
739        }
740    }
741
742    List<BufferInfo *> &inQueue = getPortQueue(0);
743    List<BufferInfo *> &outQueue = getPortQueue(1);
744
745    while (!mSawInputEOS && !inQueue.empty() && !outQueue.empty()) {
746        BufferInfo *inInfo = *inQueue.begin();
747        OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader;
748        BufferInfo *outInfo = *outQueue.begin();
749        OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader;
750
751        outHeader->nTimeStamp = 0;
752        outHeader->nFlags = 0;
753        outHeader->nOffset = 0;
754        outHeader->nFilledLen = 0;
755        outHeader->nOffset = 0;
756
757        uint8_t *outPtr = (uint8_t *) outHeader->pBuffer;
758        uint32_t dataLength = outHeader->nAllocLen;
759
760        if (!mSpsPpsHeaderReceived && mNumInputFrames < 0) {
761            // 4 bytes are reserved for holding the start code 0x00000001
762            // of the sequence parameter set at the beginning.
763            outPtr += 4;
764            dataLength -= 4;
765        }
766
767        int32_t type;
768        AVCEnc_Status encoderStatus = AVCENC_SUCCESS;
769
770        // Combine SPS and PPS and place them in the very first output buffer
771        // SPS and PPS are separated by start code 0x00000001
772        // Assume that we have exactly one SPS and exactly one PPS.
773        while (!mSpsPpsHeaderReceived && mNumInputFrames <= 0) {
774            encoderStatus = PVAVCEncodeNAL(mHandle, outPtr, &dataLength, &type);
775            if (encoderStatus == AVCENC_WRONG_STATE) {
776                mSpsPpsHeaderReceived = true;
777                CHECK_EQ(0, mNumInputFrames);  // 1st video frame is 0
778                outHeader->nFlags = OMX_BUFFERFLAG_CODECCONFIG;
779                outQueue.erase(outQueue.begin());
780                outInfo->mOwnedByUs = false;
781                notifyFillBufferDone(outHeader);
782                return;
783            } else {
784                switch (type) {
785                    case AVC_NALTYPE_SPS:
786                        ++mNumInputFrames;
787                        memcpy((uint8_t *)outHeader->pBuffer, "\x00\x00\x00\x01", 4);
788                        outHeader->nFilledLen = 4 + dataLength;
789                        outPtr += (dataLength + 4);  // 4 bytes for next start code
790                        dataLength = outHeader->nAllocLen - outHeader->nFilledLen;
791                        break;
792                    default:
793                        CHECK_EQ(AVC_NALTYPE_PPS, type);
794                        ++mNumInputFrames;
795                        memcpy((uint8_t *) outHeader->pBuffer + outHeader->nFilledLen,
796                                "\x00\x00\x00\x01", 4);
797                        outHeader->nFilledLen += (dataLength + 4);
798                        outPtr += (dataLength + 4);
799                        break;
800                }
801            }
802        }
803
804        buffer_handle_t srcBuffer; // for MetaDataMode only
805
806        // Get next input video frame
807        if (mReadyForNextFrame) {
808            // Save the input buffer info so that it can be
809            // passed to an output buffer
810            InputBufferInfo info;
811            info.mTimeUs = inHeader->nTimeStamp;
812            info.mFlags = inHeader->nFlags;
813            mInputBufferInfoVec.push(info);
814            mPrevTimestampUs = inHeader->nTimeStamp;
815
816            if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
817                mSawInputEOS = true;
818            }
819
820            if (inHeader->nFilledLen > 0) {
821                AVCFrameIO videoInput;
822                memset(&videoInput, 0, sizeof(videoInput));
823                videoInput.height = ((mVideoHeight  + 15) >> 4) << 4;
824                videoInput.pitch = ((mVideoWidth + 15) >> 4) << 4;
825                videoInput.coding_timestamp = (inHeader->nTimeStamp + 500) / 1000;  // in ms
826                uint8_t *inputData = NULL;
827                if (mStoreMetaDataInBuffers) {
828                    if (inHeader->nFilledLen != 8) {
829                        ALOGE("MetaData buffer is wrong size! "
830                                "(got %lu bytes, expected 8)", inHeader->nFilledLen);
831                        mSignalledError = true;
832                        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
833                        return;
834                    }
835                    inputData =
836                            extractGrallocData(inHeader->pBuffer + inHeader->nOffset,
837                                    &srcBuffer);
838                    if (inputData == NULL) {
839                        ALOGE("Unable to extract gralloc buffer in metadata mode");
840                        mSignalledError = true;
841                        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
842                        return;
843                    }
844                    // TODO: Verify/convert pixel format enum
845                } else {
846                    inputData = (uint8_t *)inHeader->pBuffer + inHeader->nOffset;
847                }
848
849                if (mVideoColorFormat != OMX_COLOR_FormatYUV420Planar) {
850                    ConvertYUV420SemiPlanarToYUV420Planar(
851                        inputData, mInputFrameData, mVideoWidth, mVideoHeight);
852                    inputData = mInputFrameData;
853                }
854                CHECK(inputData != NULL);
855                videoInput.YCbCr[0] = inputData;
856                videoInput.YCbCr[1] = videoInput.YCbCr[0] + videoInput.height * videoInput.pitch;
857                videoInput.YCbCr[2] = videoInput.YCbCr[1] +
858                    ((videoInput.height * videoInput.pitch) >> 2);
859                videoInput.disp_order = mNumInputFrames;
860
861                encoderStatus = PVAVCEncSetInput(mHandle, &videoInput);
862                if (encoderStatus == AVCENC_SUCCESS || encoderStatus == AVCENC_NEW_IDR) {
863                    mReadyForNextFrame = false;
864                    ++mNumInputFrames;
865                    if (encoderStatus == AVCENC_NEW_IDR) {
866                        mIsIDRFrame = 1;
867                    }
868                } else {
869                    if (encoderStatus < AVCENC_SUCCESS) {
870                        ALOGE("encoderStatus = %d at line %d", encoderStatus, __LINE__);
871                        mSignalledError = true;
872                        releaseGrallocData(srcBuffer);
873                        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
874                        return;
875                    } else {
876                        ALOGV("encoderStatus = %d at line %d", encoderStatus, __LINE__);
877                        inQueue.erase(inQueue.begin());
878                        inInfo->mOwnedByUs = false;
879                        releaseGrallocData(srcBuffer);
880                        notifyEmptyBufferDone(inHeader);
881                        return;
882                    }
883                }
884            }
885        }
886
887        // Encode an input video frame
888        CHECK(encoderStatus == AVCENC_SUCCESS || encoderStatus == AVCENC_NEW_IDR);
889        dataLength = outHeader->nAllocLen;  // Reset the output buffer length
890        if (inHeader->nFilledLen > 0) {
891            if (outHeader->nAllocLen >= 4) {
892                memcpy(outPtr, "\x00\x00\x00\x01", 4);
893                outPtr += 4;
894                dataLength -= 4;
895            }
896            encoderStatus = PVAVCEncodeNAL(mHandle, outPtr, &dataLength, &type);
897            dataLength = outPtr + dataLength - outHeader->pBuffer;
898            if (encoderStatus == AVCENC_SUCCESS) {
899                CHECK(NULL == PVAVCEncGetOverrunBuffer(mHandle));
900            } else if (encoderStatus == AVCENC_PICTURE_READY) {
901                CHECK(NULL == PVAVCEncGetOverrunBuffer(mHandle));
902                if (mIsIDRFrame) {
903                    outHeader->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
904                    mIsIDRFrame = false;
905                }
906                mReadyForNextFrame = true;
907                AVCFrameIO recon;
908                if (PVAVCEncGetRecon(mHandle, &recon) == AVCENC_SUCCESS) {
909                    PVAVCEncReleaseRecon(mHandle, &recon);
910                }
911            } else {
912                dataLength = 0;
913                mReadyForNextFrame = true;
914            }
915
916            if (encoderStatus < AVCENC_SUCCESS) {
917                ALOGE("encoderStatus = %d at line %d", encoderStatus, __LINE__);
918                mSignalledError = true;
919                releaseGrallocData(srcBuffer);
920                notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
921                return;
922            }
923        } else {
924            dataLength = 0;
925        }
926
927        inQueue.erase(inQueue.begin());
928        inInfo->mOwnedByUs = false;
929        releaseGrallocData(srcBuffer);
930        notifyEmptyBufferDone(inHeader);
931
932        outQueue.erase(outQueue.begin());
933        CHECK(!mInputBufferInfoVec.empty());
934        InputBufferInfo *inputBufInfo = mInputBufferInfoVec.begin();
935        outHeader->nTimeStamp = inputBufInfo->mTimeUs;
936        outHeader->nFlags |= (inputBufInfo->mFlags | OMX_BUFFERFLAG_ENDOFFRAME);
937        if (mSawInputEOS) {
938            outHeader->nFlags |= OMX_BUFFERFLAG_EOS;
939        }
940        outHeader->nFilledLen = dataLength;
941        outInfo->mOwnedByUs = false;
942        notifyFillBufferDone(outHeader);
943        mInputBufferInfoVec.erase(mInputBufferInfoVec.begin());
944    }
945}
946
947int32_t SoftAVCEncoder::allocOutputBuffers(
948        unsigned int sizeInMbs, unsigned int numBuffers) {
949    CHECK(mOutputBuffers.isEmpty());
950    size_t frameSize = (sizeInMbs << 7) * 3;
951    for (unsigned int i = 0; i <  numBuffers; ++i) {
952        MediaBuffer *buffer = new MediaBuffer(frameSize);
953        buffer->setObserver(this);
954        mOutputBuffers.push(buffer);
955    }
956
957    return 1;
958}
959
960void SoftAVCEncoder::unbindOutputBuffer(int32_t index) {
961    CHECK(index >= 0);
962}
963
964int32_t SoftAVCEncoder::bindOutputBuffer(int32_t index, uint8_t **yuv) {
965    CHECK(index >= 0);
966    CHECK(index < (int32_t) mOutputBuffers.size());
967    *yuv = (uint8_t *) mOutputBuffers[index]->data();
968
969    return 1;
970}
971
972void SoftAVCEncoder::signalBufferReturned(MediaBuffer *buffer) {
973    UNUSED_UNLESS_VERBOSE(buffer);
974    ALOGV("signalBufferReturned: %p", buffer);
975}
976
977OMX_ERRORTYPE SoftAVCEncoder::getExtensionIndex(
978        const char *name, OMX_INDEXTYPE *index) {
979    if (!strcmp(name, "OMX.google.android.index.storeMetaDataInBuffers")) {
980        *(int32_t*)index = kStoreMetaDataExtensionIndex;
981        return OMX_ErrorNone;
982    }
983    return OMX_ErrorUndefined;
984}
985
986uint8_t *SoftAVCEncoder::extractGrallocData(void *data, buffer_handle_t *buffer) {
987    OMX_U32 type = *(OMX_U32*)data;
988    status_t res;
989    if (type != kMetadataBufferTypeGrallocSource) {
990        ALOGE("Data passed in with metadata mode does not have type "
991                "kMetadataBufferTypeGrallocSource (%d), has type %ld instead",
992                kMetadataBufferTypeGrallocSource, type);
993        return NULL;
994    }
995    buffer_handle_t imgBuffer = *(buffer_handle_t*)((uint8_t*)data + 4);
996
997    const Rect rect(mVideoWidth, mVideoHeight);
998    uint8_t *img;
999    res = GraphicBufferMapper::get().lock(imgBuffer,
1000            GRALLOC_USAGE_HW_VIDEO_ENCODER,
1001            rect, (void**)&img);
1002    if (res != OK) {
1003        ALOGE("%s: Unable to lock image buffer %p for access", __FUNCTION__,
1004                imgBuffer);
1005        return NULL;
1006    }
1007
1008    *buffer = imgBuffer;
1009    return img;
1010}
1011
1012void SoftAVCEncoder::releaseGrallocData(buffer_handle_t buffer) {
1013    if (mStoreMetaDataInBuffers) {
1014        GraphicBufferMapper::get().unlock(buffer);
1015    }
1016}
1017
1018}  // namespace android
1019
1020android::SoftOMXComponent *createSoftOMXComponent(
1021        const char *name, const OMX_CALLBACKTYPE *callbacks,
1022        OMX_PTR appData, OMX_COMPONENTTYPE **component) {
1023    return new android::SoftAVCEncoder(name, callbacks, appData, component);
1024}
1025