SoftMPEG4Encoder.cpp revision a0940a569f2bc24b00dc10ce0fa7658b1dc3a3a5 
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 "SoftMPEG4Encoder"
19#include <utils/Log.h>
20#include <utils/misc.h>
21
22#include "mp4enc_api.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/foundation/AUtils.h>
29#include <media/stagefright/MediaDefs.h>
30#include <media/stagefright/MediaErrors.h>
31#include <media/stagefright/MetaData.h>
32#include <media/stagefright/Utils.h>
33#include <ui/Rect.h>
34#include <ui/GraphicBufferMapper.h>
35
36#include "SoftMPEG4Encoder.h"
37
38#include <inttypes.h>
39
40namespace android {
41
42template<class T>
43static void InitOMXParams(T *params) {
44    params->nSize = sizeof(T);
45    params->nVersion.s.nVersionMajor = 1;
46    params->nVersion.s.nVersionMinor = 0;
47    params->nVersion.s.nRevision = 0;
48    params->nVersion.s.nStep = 0;
49}
50
51static const CodecProfileLevel kMPEG4ProfileLevels[] = {
52    { OMX_VIDEO_MPEG4ProfileCore, OMX_VIDEO_MPEG4Level2 },
53};
54
55static const CodecProfileLevel kH263ProfileLevels[] = {
56    { OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45 },
57};
58
59SoftMPEG4Encoder::SoftMPEG4Encoder(
60            const char *name,
61            const char *componentRole,
62            OMX_VIDEO_CODINGTYPE codingType,
63            const char *mime,
64            const CodecProfileLevel *profileLevels,
65            size_t numProfileLevels,
66            const OMX_CALLBACKTYPE *callbacks,
67            OMX_PTR appData,
68            OMX_COMPONENTTYPE **component)
69    : SoftVideoEncoderOMXComponent(
70            name, componentRole, codingType,
71            profileLevels, numProfileLevels,
72            176 /* width */, 144 /* height */,
73            callbacks, appData, component),
74      mEncodeMode(COMBINE_MODE_WITH_ERR_RES),
75      mIDRFrameRefreshIntervalInSec(1),
76      mNumInputFrames(-1),
77      mStarted(false),
78      mSawInputEOS(false),
79      mSignalledError(false),
80      mHandle(new tagvideoEncControls),
81      mEncParams(new tagvideoEncOptions),
82      mInputFrameData(NULL) {
83
84    if (codingType == OMX_VIDEO_CodingH263) {
85        mEncodeMode = H263_MODE;
86    }
87
88    // 256 * 1024 is a magic number for PV's encoder, not sure why
89    const size_t kOutputBufferSize = 256 * 1024;
90
91    initPorts(kNumBuffers, kNumBuffers, kOutputBufferSize, mime);
92
93    ALOGI("Construct SoftMPEG4Encoder");
94}
95
96SoftMPEG4Encoder::~SoftMPEG4Encoder() {
97    ALOGV("Destruct SoftMPEG4Encoder");
98    releaseEncoder();
99    List<BufferInfo *> &outQueue = getPortQueue(1);
100    List<BufferInfo *> &inQueue = getPortQueue(0);
101    CHECK(outQueue.empty());
102    CHECK(inQueue.empty());
103}
104
105OMX_ERRORTYPE SoftMPEG4Encoder::initEncParams() {
106    CHECK(mHandle != NULL);
107    memset(mHandle, 0, sizeof(tagvideoEncControls));
108
109    CHECK(mEncParams != NULL);
110    memset(mEncParams, 0, sizeof(tagvideoEncOptions));
111    if (!PVGetDefaultEncOption(mEncParams, 0)) {
112        ALOGE("Failed to get default encoding parameters");
113        return OMX_ErrorUndefined;
114    }
115    mEncParams->encMode = mEncodeMode;
116    mEncParams->encWidth[0] = mWidth;
117    mEncParams->encHeight[0] = mHeight;
118    mEncParams->encFrameRate[0] = mFramerate >> 16; // mFramerate is in Q16 format
119    mEncParams->rcType = VBR_1;
120    mEncParams->vbvDelay = 5.0f;
121
122    // FIXME:
123    // Add more profile and level support for MPEG4 encoder
124    mEncParams->profile_level = CORE_PROFILE_LEVEL2;
125    mEncParams->packetSize = 32;
126    mEncParams->rvlcEnable = PV_OFF;
127    mEncParams->numLayers = 1;
128    mEncParams->timeIncRes = 1000;
129    mEncParams->tickPerSrc = ((int64_t)mEncParams->timeIncRes << 16) / mFramerate;
130
131    mEncParams->bitRate[0] = mBitrate;
132    mEncParams->iQuant[0] = 15;
133    mEncParams->pQuant[0] = 12;
134    mEncParams->quantType[0] = 0;
135    mEncParams->noFrameSkipped = PV_OFF;
136
137    if (mColorFormat != OMX_COLOR_FormatYUV420Planar || mInputDataIsMeta) {
138        // Color conversion is needed.
139        free(mInputFrameData);
140        mInputFrameData =
141            (uint8_t *) malloc((mWidth * mHeight * 3 ) >> 1);
142        CHECK(mInputFrameData != NULL);
143    }
144
145    // PV's MPEG4 encoder requires the video dimension of multiple
146    if (mWidth % 16 != 0 || mHeight % 16 != 0) {
147        ALOGE("Video frame size %dx%d must be a multiple of 16",
148            mWidth, mHeight);
149        return OMX_ErrorBadParameter;
150    }
151
152    // Set IDR frame refresh interval
153    if (mIDRFrameRefreshIntervalInSec < 0) {
154        mEncParams->intraPeriod = -1;
155    } else if (mIDRFrameRefreshIntervalInSec == 0) {
156        mEncParams->intraPeriod = 1;  // All I frames
157    } else {
158        mEncParams->intraPeriod =
159            (mIDRFrameRefreshIntervalInSec * mFramerate) >> 16;
160    }
161
162    mEncParams->numIntraMB = 0;
163    mEncParams->sceneDetect = PV_ON;
164    mEncParams->searchRange = 16;
165    mEncParams->mv8x8Enable = PV_OFF;
166    mEncParams->gobHeaderInterval = 0;
167    mEncParams->useACPred = PV_ON;
168    mEncParams->intraDCVlcTh = 0;
169
170    return OMX_ErrorNone;
171}
172
173OMX_ERRORTYPE SoftMPEG4Encoder::initEncoder() {
174    CHECK(!mStarted);
175
176    OMX_ERRORTYPE errType = OMX_ErrorNone;
177    if (OMX_ErrorNone != (errType = initEncParams())) {
178        ALOGE("Failed to initialized encoder params");
179        mSignalledError = true;
180        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
181        return errType;
182    }
183
184    if (!PVInitVideoEncoder(mHandle, mEncParams)) {
185        ALOGE("Failed to initialize the encoder");
186        mSignalledError = true;
187        notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
188        return OMX_ErrorUndefined;
189    }
190
191    mNumInputFrames = -1;  // 1st buffer for codec specific data
192    mStarted = true;
193
194    return OMX_ErrorNone;
195}
196
197OMX_ERRORTYPE SoftMPEG4Encoder::releaseEncoder() {
198    if (!mStarted) {
199        return OMX_ErrorNone;
200    }
201
202    PVCleanUpVideoEncoder(mHandle);
203
204    free(mInputFrameData);
205    mInputFrameData = NULL;
206
207    delete mEncParams;
208    mEncParams = NULL;
209
210    delete mHandle;
211    mHandle = NULL;
212
213    mStarted = false;
214
215    return OMX_ErrorNone;
216}
217
218OMX_ERRORTYPE SoftMPEG4Encoder::internalGetParameter(
219        OMX_INDEXTYPE index, OMX_PTR params) {
220    switch (index) {
221        case OMX_IndexParamVideoBitrate:
222        {
223            OMX_VIDEO_PARAM_BITRATETYPE *bitRate =
224                (OMX_VIDEO_PARAM_BITRATETYPE *) params;
225
226            if (bitRate->nPortIndex != 1) {
227                return OMX_ErrorUndefined;
228            }
229
230            bitRate->eControlRate = OMX_Video_ControlRateVariable;
231            bitRate->nTargetBitrate = mBitrate;
232            return OMX_ErrorNone;
233        }
234
235        case OMX_IndexParamVideoH263:
236        {
237            OMX_VIDEO_PARAM_H263TYPE *h263type =
238                (OMX_VIDEO_PARAM_H263TYPE *)params;
239
240            if (h263type->nPortIndex != 1) {
241                return OMX_ErrorUndefined;
242            }
243
244            h263type->nAllowedPictureTypes =
245                (OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP);
246            h263type->eProfile = OMX_VIDEO_H263ProfileBaseline;
247            h263type->eLevel = OMX_VIDEO_H263Level45;
248            h263type->bPLUSPTYPEAllowed = OMX_FALSE;
249            h263type->bForceRoundingTypeToZero = OMX_FALSE;
250            h263type->nPictureHeaderRepetition = 0;
251            h263type->nGOBHeaderInterval = 0;
252
253            return OMX_ErrorNone;
254        }
255
256        case OMX_IndexParamVideoMpeg4:
257        {
258            OMX_VIDEO_PARAM_MPEG4TYPE *mpeg4type =
259                (OMX_VIDEO_PARAM_MPEG4TYPE *)params;
260
261            if (mpeg4type->nPortIndex != 1) {
262                return OMX_ErrorUndefined;
263            }
264
265            mpeg4type->eProfile = OMX_VIDEO_MPEG4ProfileCore;
266            mpeg4type->eLevel = OMX_VIDEO_MPEG4Level2;
267            mpeg4type->nAllowedPictureTypes =
268                (OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP);
269            mpeg4type->nBFrames = 0;
270            mpeg4type->nIDCVLCThreshold = 0;
271            mpeg4type->bACPred = OMX_TRUE;
272            mpeg4type->nMaxPacketSize = 256;
273            mpeg4type->nTimeIncRes = 1000;
274            mpeg4type->nHeaderExtension = 0;
275            mpeg4type->bReversibleVLC = OMX_FALSE;
276
277            return OMX_ErrorNone;
278        }
279
280        default:
281            return SoftVideoEncoderOMXComponent::internalGetParameter(index, params);
282    }
283}
284
285OMX_ERRORTYPE SoftMPEG4Encoder::internalSetParameter(
286        OMX_INDEXTYPE index, const OMX_PTR params) {
287    int32_t indexFull = index;
288
289    switch (indexFull) {
290        case OMX_IndexParamVideoBitrate:
291        {
292            OMX_VIDEO_PARAM_BITRATETYPE *bitRate =
293                (OMX_VIDEO_PARAM_BITRATETYPE *) params;
294
295            if (bitRate->nPortIndex != 1 ||
296                bitRate->eControlRate != OMX_Video_ControlRateVariable) {
297                return OMX_ErrorUndefined;
298            }
299
300            mBitrate = bitRate->nTargetBitrate;
301            return OMX_ErrorNone;
302        }
303
304        case OMX_IndexParamVideoH263:
305        {
306            OMX_VIDEO_PARAM_H263TYPE *h263type =
307                (OMX_VIDEO_PARAM_H263TYPE *)params;
308
309            if (h263type->nPortIndex != 1) {
310                return OMX_ErrorUndefined;
311            }
312
313            if (h263type->eProfile != OMX_VIDEO_H263ProfileBaseline ||
314                h263type->eLevel != OMX_VIDEO_H263Level45 ||
315                (h263type->nAllowedPictureTypes & OMX_VIDEO_PictureTypeB) ||
316                h263type->bPLUSPTYPEAllowed != OMX_FALSE ||
317                h263type->bForceRoundingTypeToZero != OMX_FALSE ||
318                h263type->nPictureHeaderRepetition != 0 ||
319                h263type->nGOBHeaderInterval != 0) {
320                return OMX_ErrorUndefined;
321            }
322
323            return OMX_ErrorNone;
324        }
325
326        case OMX_IndexParamVideoMpeg4:
327        {
328            OMX_VIDEO_PARAM_MPEG4TYPE *mpeg4type =
329                (OMX_VIDEO_PARAM_MPEG4TYPE *)params;
330
331            if (mpeg4type->nPortIndex != 1) {
332                return OMX_ErrorUndefined;
333            }
334
335            if (mpeg4type->eProfile != OMX_VIDEO_MPEG4ProfileCore ||
336                mpeg4type->eLevel != OMX_VIDEO_MPEG4Level2 ||
337                (mpeg4type->nAllowedPictureTypes & OMX_VIDEO_PictureTypeB) ||
338                mpeg4type->nBFrames != 0 ||
339                mpeg4type->nIDCVLCThreshold != 0 ||
340                mpeg4type->bACPred != OMX_TRUE ||
341                mpeg4type->nMaxPacketSize != 256 ||
342                mpeg4type->nTimeIncRes != 1000 ||
343                mpeg4type->nHeaderExtension != 0 ||
344                mpeg4type->bReversibleVLC != OMX_FALSE) {
345                return OMX_ErrorUndefined;
346            }
347
348            return OMX_ErrorNone;
349        }
350
351        default:
352            return SoftVideoEncoderOMXComponent::internalSetParameter(index, params);
353    }
354}
355
356void SoftMPEG4Encoder::onQueueFilled(OMX_U32 /* portIndex */) {
357    if (mSignalledError || mSawInputEOS) {
358        return;
359    }
360
361    if (!mStarted) {
362        if (OMX_ErrorNone != initEncoder()) {
363            return;
364        }
365    }
366
367    List<BufferInfo *> &inQueue = getPortQueue(0);
368    List<BufferInfo *> &outQueue = getPortQueue(1);
369
370    while (!mSawInputEOS && !inQueue.empty() && !outQueue.empty()) {
371        BufferInfo *inInfo = *inQueue.begin();
372        OMX_BUFFERHEADERTYPE *inHeader = inInfo->mHeader;
373        BufferInfo *outInfo = *outQueue.begin();
374        OMX_BUFFERHEADERTYPE *outHeader = outInfo->mHeader;
375
376        outHeader->nTimeStamp = 0;
377        outHeader->nFlags = 0;
378        outHeader->nOffset = 0;
379        outHeader->nFilledLen = 0;
380        outHeader->nOffset = 0;
381
382        uint8_t *outPtr = (uint8_t *) outHeader->pBuffer;
383        int32_t dataLength = outHeader->nAllocLen;
384
385        if (mNumInputFrames < 0) {
386            if (!PVGetVolHeader(mHandle, outPtr, &dataLength, 0)) {
387                ALOGE("Failed to get VOL header");
388                mSignalledError = true;
389                notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
390                return;
391            }
392            ALOGV("Output VOL header: %d bytes", dataLength);
393            ++mNumInputFrames;
394            outHeader->nFlags |= OMX_BUFFERFLAG_CODECCONFIG;
395            outHeader->nFilledLen = dataLength;
396            outQueue.erase(outQueue.begin());
397            outInfo->mOwnedByUs = false;
398            notifyFillBufferDone(outHeader);
399            return;
400        }
401
402        // Save the input buffer info so that it can be
403        // passed to an output buffer
404        InputBufferInfo info;
405        info.mTimeUs = inHeader->nTimeStamp;
406        info.mFlags = inHeader->nFlags;
407        mInputBufferInfoVec.push(info);
408
409        if (inHeader->nFlags & OMX_BUFFERFLAG_EOS) {
410            mSawInputEOS = true;
411        }
412
413        if (inHeader->nFilledLen > 0) {
414            const uint8_t *inputData = NULL;
415            if (mInputDataIsMeta) {
416                if (inHeader->nFilledLen != 8) {
417                    ALOGE("MetaData buffer is wrong size! "
418                            "(got %u bytes, expected 8)", inHeader->nFilledLen);
419                    mSignalledError = true;
420                    notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
421                    return;
422                }
423                inputData =
424                    extractGraphicBuffer(
425                            mInputFrameData, (mWidth * mHeight * 3) >> 1,
426                            inHeader->pBuffer + inHeader->nOffset, inHeader->nFilledLen,
427                            mWidth, mHeight);
428                if (inputData == NULL) {
429                    ALOGE("Unable to extract gralloc buffer in metadata mode");
430                    mSignalledError = true;
431                    notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
432                        return;
433                }
434            } else {
435                inputData = (const uint8_t *)inHeader->pBuffer + inHeader->nOffset;
436                if (mColorFormat != OMX_COLOR_FormatYUV420Planar) {
437                    ConvertYUV420SemiPlanarToYUV420Planar(
438                        inputData, mInputFrameData, mWidth, mHeight);
439                    inputData = mInputFrameData;
440                }
441            }
442
443            CHECK(inputData != NULL);
444
445            VideoEncFrameIO vin, vout;
446            memset(&vin, 0, sizeof(vin));
447            memset(&vout, 0, sizeof(vout));
448            vin.height = align(mHeight, 16);
449            vin.pitch = align(mWidth, 16);
450            vin.timestamp = (inHeader->nTimeStamp + 500) / 1000;  // in ms
451            vin.yChan = (uint8_t *)inputData;
452            vin.uChan = vin.yChan + vin.height * vin.pitch;
453            vin.vChan = vin.uChan + ((vin.height * vin.pitch) >> 2);
454
455            ULong modTimeMs = 0;
456            int32_t nLayer = 0;
457            MP4HintTrack hintTrack;
458            if (!PVEncodeVideoFrame(mHandle, &vin, &vout,
459                    &modTimeMs, outPtr, &dataLength, &nLayer) ||
460                !PVGetHintTrack(mHandle, &hintTrack)) {
461                ALOGE("Failed to encode frame or get hink track at frame %" PRId64,
462                    mNumInputFrames);
463                mSignalledError = true;
464                notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
465            }
466            CHECK(NULL == PVGetOverrunBuffer(mHandle));
467            if (hintTrack.CodeType == 0) {  // I-frame serves as sync frame
468                outHeader->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
469            }
470
471            ++mNumInputFrames;
472        } else {
473            dataLength = 0;
474        }
475
476        inQueue.erase(inQueue.begin());
477        inInfo->mOwnedByUs = false;
478        notifyEmptyBufferDone(inHeader);
479
480        outQueue.erase(outQueue.begin());
481        CHECK(!mInputBufferInfoVec.empty());
482        InputBufferInfo *inputBufInfo = mInputBufferInfoVec.begin();
483        outHeader->nTimeStamp = inputBufInfo->mTimeUs;
484        outHeader->nFlags |= (inputBufInfo->mFlags | OMX_BUFFERFLAG_ENDOFFRAME);
485        outHeader->nFilledLen = dataLength;
486        mInputBufferInfoVec.erase(mInputBufferInfoVec.begin());
487        outInfo->mOwnedByUs = false;
488        notifyFillBufferDone(outHeader);
489    }
490}
491
492}  // namespace android
493
494android::SoftOMXComponent *createSoftOMXComponent(
495        const char *name, const OMX_CALLBACKTYPE *callbacks,
496        OMX_PTR appData, OMX_COMPONENTTYPE **component) {
497    using namespace android;
498    if (!strcmp(name, "OMX.google.h263.encoder")) {
499        return new android::SoftMPEG4Encoder(
500                name, "video_encoder.h263", OMX_VIDEO_CodingH263, MEDIA_MIMETYPE_VIDEO_H263,
501                kH263ProfileLevels, NELEM(kH263ProfileLevels),
502                callbacks, appData, component);
503    } else if (!strcmp(name, "OMX.google.mpeg4.encoder")) {
504        return new android::SoftMPEG4Encoder(
505                name, "video_encoder.mpeg4", OMX_VIDEO_CodingMPEG4, MEDIA_MIMETYPE_VIDEO_MPEG4,
506                kMPEG4ProfileLevels, NELEM(kMPEG4ProfileLevels),
507                callbacks, appData, component);
508    } else {
509        CHECK(!"Unknown component");
510    }
511    return NULL;
512}
513