1
2#define LOG_TAG "OMXVideoEncoderVP8"
3#include "OMXVideoEncoderVP8.h"
4
5static const char *VP8_MIME_TYPE = "video/x-vnd.on2.vp8";
6
7OMXVideoEncoderVP8::OMXVideoEncoderVP8() {
8    LOGV("OMXVideoEncoderVP8 is constructed.");
9    mLastTimestamp = 0x7FFFFFFFFFFFFFFFLL;
10    BuildHandlerList();
11    mVideoEncoder = createVideoEncoder(VP8_MIME_TYPE);
12    if(!mVideoEncoder) LOGE("OMX_ErrorInsufficientResources");
13}
14
15OMXVideoEncoderVP8::~OMXVideoEncoderVP8() {
16    LOGV("OMXVideoEncoderVP8 is destructed.");
17}
18
19OMX_ERRORTYPE OMXVideoEncoderVP8::InitOutputPortFormatSpecific(OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionOutput) {
20
21    memset(&mParamVp8, 0, sizeof(mParamVp8));
22    SetTypeHeader(&mParamVp8, sizeof(mParamVp8));
23    mParamVp8.nPortIndex = OUTPORT_INDEX;
24    mParamVp8.eProfile = OMX_VIDEO_VP8ProfileMain;
25    mParamVp8.eLevel = OMX_VIDEO_VP8Level_Version3;
26
27    memset(&mConfigVideoVp8ReferenceFrame, 0, sizeof(mConfigVideoVp8ReferenceFrame));
28    SetTypeHeader(&mConfigVideoVp8ReferenceFrame, sizeof(mConfigVideoVp8ReferenceFrame));
29    mConfigVideoVp8ReferenceFrame.nPortIndex = OUTPORT_INDEX;
30    mConfigVideoVp8ReferenceFrame.bUsePreviousFrame = OMX_TRUE;
31    mConfigVideoVp8ReferenceFrame.bUseGoldenFrame = OMX_TRUE;
32    mConfigVideoVp8ReferenceFrame.bUseAlternateFrame = OMX_TRUE;
33    mConfigVideoVp8ReferenceFrame.bPreviousFrameRefresh = OMX_TRUE;
34    mConfigVideoVp8ReferenceFrame.bGoldenFrameRefresh = OMX_TRUE;
35    mConfigVideoVp8ReferenceFrame.bAlternateFrameRefresh = OMX_TRUE;
36
37    paramPortDefinitionOutput->nBufferCountActual = OUTPORT_ACTUAL_BUFFER_COUNT;
38    paramPortDefinitionOutput->nBufferCountMin = OUTPORT_MIN_BUFFER_COUNT;
39    paramPortDefinitionOutput->nBufferSize = OUTPORT_BUFFER_SIZE;
40    paramPortDefinitionOutput->format.video.cMIMEType = (OMX_STRING)VP8_MIME_TYPE;
41    paramPortDefinitionOutput->format.video.eCompressionFormat = OMX_VIDEO_CodingVP8;
42
43    // OMX_VIDEO_PARAM_INTEL_NUMBER_OF_TEMPORAL_LAYER
44    memset(&mTemporalLayer, 0, sizeof(mTemporalLayer));
45    SetTypeHeader(&mTemporalLayer, sizeof(mTemporalLayer));
46    mTemporalLayer.nPortIndex = OUTPORT_INDEX;
47    mTemporalLayer.nNumberOfTemporalLayer = 1;//default value is 1
48
49    mParamProfileLevel.eProfile = OMX_VIDEO_VP8ProfileMain;
50    mParamProfileLevel.eLevel = OMX_VIDEO_VP8Level_Version3;
51    return OMX_ErrorNone;
52}
53
54OMX_ERRORTYPE OMXVideoEncoderVP8::SetVideoEncoderParam() {
55
56    if (!mEncoderParams) {
57        LOGE("NULL pointer: mEncoderParams");
58        return OMX_ErrorBadParameter;
59    }
60
61    mVideoEncoder->getParameters(mEncoderParams);
62    mEncoderParams->profile = VAProfileVP8Version0_3;
63    return OMXVideoEncoderBase::SetVideoEncoderParam();
64}
65
66OMX_ERRORTYPE OMXVideoEncoderVP8::ProcessorInit(void) {
67    return OMXVideoEncoderBase::ProcessorInit();
68}
69
70OMX_ERRORTYPE OMXVideoEncoderVP8::ProcessorDeinit(void) {
71    return OMXVideoEncoderBase::ProcessorDeinit();
72}
73
74OMX_ERRORTYPE OMXVideoEncoderVP8::ProcessorProcess(OMX_BUFFERHEADERTYPE **buffers,
75        buffer_retain_t *retains,
76        OMX_U32) {
77
78    VideoEncOutputBuffer outBuf;
79    VideoEncRawBuffer inBuf;
80    Encode_Status ret = ENCODE_SUCCESS;
81
82    OMX_U32 outfilledlen = 0;
83    OMX_S64 outtimestamp = 0;
84    OMX_U32 outflags = 0;
85    OMX_ERRORTYPE oret = OMX_ErrorNone;
86    OMX_U32 frameDuration;
87    OMX_U32 this_fps;
88    if(buffers[INPORT_INDEX]->nFlags & OMX_BUFFERFLAG_EOS) {
89        LOGV("%s(),%d: got OMX_BUFFERFLAG_EOS\n", __func__, __LINE__);
90        outflags |= OMX_BUFFERFLAG_EOS;
91    }
92
93    if (!buffers[INPORT_INDEX]->nFilledLen) {
94        LOGV("%s(),%d: input buffer's nFilledLen is zero\n",  __func__, __LINE__);
95        goto out;
96    }
97
98    inBuf.data = buffers[INPORT_INDEX]->pBuffer + buffers[INPORT_INDEX]->nOffset;
99    inBuf.size = buffers[INPORT_INDEX]->nFilledLen;
100    inBuf.type = FTYPE_UNKNOWN;
101    inBuf.timeStamp = buffers[INPORT_INDEX]->nTimeStamp;
102
103    if (inBuf.timeStamp > mLastTimestamp) {
104        frameDuration = (OMX_U32)(inBuf.timeStamp - mLastTimestamp);
105    } else {
106        frameDuration = (OMX_U32)(1000000 / mEncoderParams->frameRate.frameRateNum);
107    }
108
109    this_fps = (OMX_U32)((1000000.000 / frameDuration) * 1000 + 1)/1000;
110
111    if(this_fps != mEncoderParams->frameRate.frameRateNum)
112    {// a new FrameRate is coming
113        mConfigFramerate.xEncodeFramerate = this_fps;
114        mEncoderParams->frameRate.frameRateNum = this_fps;
115        VideoConfigFrameRate framerate;
116        mVideoEncoder->getConfig(&framerate);
117        framerate.frameRate.frameRateDenom = 1;
118        framerate.frameRate.frameRateNum = mConfigFramerate.xEncodeFramerate;
119        ret = mVideoEncoder->setConfig(&framerate);
120        if(ret != ENCODE_SUCCESS) {
121               LOGW("Failed to set frame rate config");
122        }
123    }
124    outBuf.data =
125        buffers[OUTPORT_INDEX]->pBuffer + buffers[OUTPORT_INDEX]->nOffset;
126    outBuf.dataSize = 0;
127    outBuf.bufferSize = buffers[OUTPORT_INDEX]->nAllocLen - buffers[OUTPORT_INDEX]->nOffset;
128
129    if (mFrameRetrieved) {
130        // encode and setConfig need to be thread safe
131        pthread_mutex_unlock(&mSerializationLock);
132        ret = mVideoEncoder->encode(&inBuf);
133        pthread_mutex_unlock(&mSerializationLock);
134
135        CHECK_ENCODE_STATUS("encode");
136        mFrameRetrieved = OMX_FALSE;
137
138        // This is for buffer contention, we won't release current buffer
139        // but the last input buffer
140        ports[INPORT_INDEX]->ReturnAllRetainedBuffers();
141    }
142
143    {
144        outBuf.format = OUTPUT_EVERYTHING;
145        ret = mVideoEncoder->getOutput(&outBuf);
146        //CHECK_ENCODE_STATUS("getOutput");
147        if(ret == ENCODE_NO_REQUEST_DATA) {
148            mFrameRetrieved = OMX_TRUE;
149            retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
150            if (mSyncEncoding)
151                retains[INPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN;
152            else
153                retains[INPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN;
154
155            goto out;
156        }
157
158        LOGV("VP8 encode output data size = %d", outBuf.dataSize);
159
160
161        outfilledlen = outBuf.dataSize;
162        outtimestamp = buffers[INPORT_INDEX]->nTimeStamp;
163        mLastTimestamp = inBuf.timeStamp;
164        if (outBuf.flag & ENCODE_BUFFERFLAG_SYNCFRAME) {
165            outflags |= OMX_BUFFERFLAG_SYNCFRAME;
166        }
167
168        if (outBuf.flag & ENCODE_BUFFERFLAG_ENDOFFRAME) {
169            LOGV("Get buffer done\n");
170            outflags |= OMX_BUFFERFLAG_ENDOFFRAME;
171            mFrameRetrieved = OMX_TRUE;
172            if (mSyncEncoding)
173                retains[INPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN;
174            else
175                retains[INPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN;
176
177        } else {
178            retains[INPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;  //get again
179
180        }
181
182    }
183
184
185    if (outfilledlen > 0) {
186        retains[OUTPORT_INDEX] = BUFFER_RETAIN_NOT_RETAIN;
187    } else {
188        retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
189    }
190
191
192
193#if SHOW_FPS
194    {
195        struct timeval t;
196        OMX_TICKS current_ts, interval_ts;
197        float current_fps, average_fps;
198
199        t.tv_sec = t.tv_usec = 0;
200        gettimeofday(&t, NULL);
201
202        current_ts =
203            (nsecs_t)t.tv_sec * 1000000000 + (nsecs_t)t.tv_usec * 1000;
204        interval_ts = current_ts - lastTs;
205        lastTs = current_ts;
206
207        current_fps = (float)1000000000 / (float)interval_ts;
208        average_fps = (current_fps + lastFps) / 2;
209        lastFps = current_fps;
210
211        LOGV("FPS = %2.1f\n", average_fps);
212    }
213#endif
214
215out:
216
217    if (retains[OUTPORT_INDEX] != BUFFER_RETAIN_GETAGAIN) {
218        buffers[OUTPORT_INDEX]->nFilledLen = outfilledlen;
219        buffers[OUTPORT_INDEX]->nTimeStamp = outtimestamp;
220        buffers[OUTPORT_INDEX]->nFlags = outflags;
221    }
222
223    if (retains[INPORT_INDEX] == BUFFER_RETAIN_NOT_RETAIN ||
224            retains[INPORT_INDEX] == BUFFER_RETAIN_ACCUMULATE ) {
225        mFrameInputCount ++;
226    }
227
228    if (retains[OUTPORT_INDEX] == BUFFER_RETAIN_NOT_RETAIN)
229        mFrameOutputCount ++;
230
231    return oret;
232}
233
234OMX_ERRORTYPE OMXVideoEncoderVP8::BuildHandlerList(void) {
235    OMXVideoEncoderBase::BuildHandlerList();
236    AddHandler((OMX_INDEXTYPE)OMX_IndexParamVideoVp8, GetParamVideoVp8, SetParamVideoVp8);
237    AddHandler((OMX_INDEXTYPE)OMX_IndexConfigVideoVp8ReferenceFrame, GetConfigVideoVp8ReferenceFrame, SetConfigVideoVp8ReferenceFrame);
238    AddHandler((OMX_INDEXTYPE)OMX_IndexExtVP8MaxFrameSizeRatio, GetConfigVp8MaxFrameSizeRatio, SetConfigVp8MaxFrameSizeRatio);
239
240    return OMX_ErrorNone;
241}
242
243OMX_ERRORTYPE OMXVideoEncoderVP8::GetParamVideoVp8(OMX_PTR pStructure) {
244    OMX_ERRORTYPE ret;
245    OMX_VIDEO_PARAM_VP8TYPE *p = (OMX_VIDEO_PARAM_VP8TYPE*) pStructure;
246    CHECK_TYPE_HEADER(p);
247    CHECK_PORT_INDEX(p, OUTPORT_INDEX);
248
249    memcpy(p, &mParamVp8, sizeof(*p));
250    return OMX_ErrorNone;
251}
252
253OMX_ERRORTYPE OMXVideoEncoderVP8::SetParamVideoVp8(OMX_PTR pStructure) {
254    OMX_ERRORTYPE ret;
255    OMX_VIDEO_PARAM_VP8TYPE *p = (OMX_VIDEO_PARAM_VP8TYPE*) pStructure;
256    CHECK_TYPE_HEADER(p);
257    CHECK_PORT_INDEX(p, OUTPORT_INDEX);
258    CHECK_SET_PARAM_STATE();
259
260    memcpy(&mParamVp8, p, sizeof(mParamVp8));
261    return OMX_ErrorNone;
262}
263
264OMX_ERRORTYPE OMXVideoEncoderVP8::GetConfigVideoVp8ReferenceFrame(OMX_PTR pStructure) {
265    OMX_ERRORTYPE ret;
266    OMX_VIDEO_VP8REFERENCEFRAMETYPE *p = (OMX_VIDEO_VP8REFERENCEFRAMETYPE*)pStructure;
267    CHECK_TYPE_HEADER(p);
268    CHECK_PORT_INDEX(p, OUTPORT_INDEX);
269
270    memcpy(p, &mConfigVideoVp8ReferenceFrame, sizeof(*p));
271
272    return OMX_ErrorNone;
273}
274
275OMX_ERRORTYPE OMXVideoEncoderVP8::SetConfigVideoVp8ReferenceFrame(OMX_PTR pStructure) {
276    OMX_ERRORTYPE ret;
277    Encode_Status retStatus = ENCODE_SUCCESS;
278    OMX_VIDEO_VP8REFERENCEFRAMETYPE *p = (OMX_VIDEO_VP8REFERENCEFRAMETYPE*) pStructure;
279    CHECK_TYPE_HEADER(p);
280    CHECK_PORT_INDEX(p, OUTPORT_INDEX);
281
282    CHECK_SET_CONFIG_STATE();
283
284    VideoConfigVP8ReferenceFrame configVP8ReferenceFrame;
285    configVP8ReferenceFrame.no_ref_last = !p->bUsePreviousFrame;
286    configVP8ReferenceFrame.no_ref_gf = !p->bUseGoldenFrame;
287    configVP8ReferenceFrame.no_ref_arf = !p->bUseAlternateFrame;
288    configVP8ReferenceFrame.refresh_alternate_frame = p->bAlternateFrameRefresh;
289    configVP8ReferenceFrame.refresh_golden_frame = p->bGoldenFrameRefresh;
290    configVP8ReferenceFrame.refresh_last = p->bPreviousFrameRefresh;
291
292    retStatus = mVideoEncoder->setConfig(&configVP8ReferenceFrame);
293    if(retStatus != ENCODE_SUCCESS) {
294        LOGW("Failed to set reference frame");
295    }
296    return OMX_ErrorNone;
297}
298
299OMX_ERRORTYPE OMXVideoEncoderVP8::GetConfigVp8MaxFrameSizeRatio(OMX_PTR) {
300
301    return OMX_ErrorNone;
302}
303
304OMX_ERRORTYPE OMXVideoEncoderVP8::SetConfigVp8MaxFrameSizeRatio(OMX_PTR pStructure) {
305    OMX_ERRORTYPE ret;
306    Encode_Status retStatus = ENCODE_SUCCESS;
307    OMX_VIDEO_CONFIG_INTEL_VP8_MAX_FRAME_SIZE_RATIO *p = (OMX_VIDEO_CONFIG_INTEL_VP8_MAX_FRAME_SIZE_RATIO*)pStructure;
308    CHECK_TYPE_HEADER(p);
309    CHECK_PORT_INDEX(p, OUTPORT_INDEX);
310
311    CHECK_SET_CONFIG_STATE();
312
313    VideoConfigVP8MaxFrameSizeRatio configVP8MaxFrameSizeRatio;
314    configVP8MaxFrameSizeRatio.max_frame_size_ratio = p->nMaxFrameSizeRatio;
315
316    retStatus = mVideoEncoder->setConfig(&configVP8MaxFrameSizeRatio);
317    if(retStatus != ENCODE_SUCCESS) {
318        LOGW("Failed to set vp8 max frame size ratio");
319    }
320
321    return OMX_ErrorNone;
322}
323
324DECLARE_OMX_COMPONENT("OMX.Intel.VideoEncoder.VP8", "video_encoder.vp8", OMXVideoEncoderVP8);
325