portvideo.cpp revision aa3d0c8c33608e6718546186096f2eed53980593 
1/*
2 * portvideo.cpp, port class for video
3 *
4 * Copyright (c) 2009-2010 Wind River Systems, Inc.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19#include <stdlib.h>
20#include <string.h>
21
22#include <OMX_Core.h>
23#include <OMX_Component.h>
24
25#include <componentbase.h>
26#include <portvideo.h>
27
28#define LOG_TAG "portvideo"
29#include <log.h>
30
31PortVideo::PortVideo()
32{
33    memset(&videoparam, 0, sizeof(videoparam));
34    ComponentBase::SetTypeHeader(&videoparam, sizeof(videoparam));
35
36    videoparam.nIndex = 0;
37    videoparam.eCompressionFormat = OMX_VIDEO_CodingUnused;
38    videoparam.eColorFormat = OMX_COLOR_FormatYUV420Planar;
39    videoparam.xFramerate = 15 << 16;
40
41    memset(&bitrateparam, 0, sizeof(bitrateparam));
42    ComponentBase::SetTypeHeader(&bitrateparam, sizeof(bitrateparam));
43
44    bitrateparam.eControlRate = OMX_Video_ControlRateConstant;
45    bitrateparam.nTargetBitrate = 64000;
46
47    memset(&privateinfoparam, 0, sizeof(privateinfoparam));
48    ComponentBase::SetTypeHeader(&privateinfoparam, sizeof(privateinfoparam));
49
50    privateinfoparam.nCapacity = 0;
51    privateinfoparam.nHolder = NULL;
52
53    mbufsharing = OMX_FALSE;
54}
55
56//PortVideo::~PortVideo()
57//{
58//    if(privateinfoparam.nHolder != NULL) {
59//        free(privateinfoparam.nHolder);
60//        privateinfoparam.nHolder = NULL;
61//    }
62//}
63
64OMX_ERRORTYPE PortVideo::SetPortVideoParam(
65    const OMX_VIDEO_PARAM_PORTFORMATTYPE *p, bool internal)
66{
67    if (!internal) {
68        OMX_ERRORTYPE ret;
69
70        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
71        if (ret != OMX_ErrorNone)
72            return ret;
73        if (videoparam.nPortIndex != p->nPortIndex)
74            return OMX_ErrorBadPortIndex;
75    }
76    else
77        videoparam.nPortIndex = p->nPortIndex;
78
79    videoparam.nIndex = p->nIndex;
80    videoparam.eCompressionFormat = p->eCompressionFormat;
81    videoparam.eColorFormat = p->eColorFormat;
82    videoparam.xFramerate = p->xFramerate;
83
84    return OMX_ErrorNone;
85}
86
87const OMX_VIDEO_PARAM_PORTFORMATTYPE *PortVideo::GetPortVideoParam(void)
88{
89    return &videoparam;
90}
91
92OMX_ERRORTYPE PortVideo::SetPortBitrateParam(
93    const OMX_VIDEO_PARAM_BITRATETYPE *p, bool internal)
94{
95    if (!internal) {
96        OMX_ERRORTYPE ret;
97
98        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
99        if (ret != OMX_ErrorNone)
100            return ret;
101        if (bitrateparam.nPortIndex != p->nPortIndex)
102            return OMX_ErrorBadPortIndex;
103    }
104    else
105        bitrateparam.nPortIndex = p->nPortIndex;
106
107    bitrateparam.eControlRate = p->eControlRate;
108    bitrateparam.nTargetBitrate = p->nTargetBitrate;
109
110    return OMX_ErrorNone;
111}
112
113const OMX_VIDEO_PARAM_BITRATETYPE *PortVideo::GetPortBitrateParam(void)
114{
115    return &bitrateparam;
116}
117
118OMX_ERRORTYPE PortVideo::SetPortBufferSharingInfo(OMX_BOOL isbufsharing)
119{
120    mbufsharing = isbufsharing;
121
122    return OMX_ErrorNone;
123}
124
125const OMX_BOOL *PortVideo::GetPortBufferSharingInfo(void)
126{
127    return &mbufsharing;
128}
129
130
131OMX_ERRORTYPE PortVideo::SetPortPrivateInfoParam(
132    const OMX_VIDEO_CONFIG_PRI_INFOTYPE *p, bool internal)
133{
134    if (!internal) {
135        OMX_ERRORTYPE ret;
136
137        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
138        if (ret != OMX_ErrorNone)
139            return ret;
140        if (privateinfoparam.nPortIndex != p->nPortIndex)
141            return OMX_ErrorBadPortIndex;
142    }
143    else
144        privateinfoparam.nPortIndex = p->nPortIndex;
145
146    const OMX_BOOL *isbufsharing = GetPortBufferSharingInfo();
147    if(*isbufsharing) {
148        //if(privateinfoparam.nHolder != NULL) {
149        //    free(privateinfoparam.nHolder);
150        //    privateinfoparam.nHolder = NULL;
151        //}
152        if(p->nHolder != NULL) {
153            privateinfoparam.nCapacity = p->nCapacity;
154            privateinfoparam.nHolder = (OMX_PTR)malloc(sizeof(OMX_U32) * (p->nCapacity));
155            memcpy(privateinfoparam.nHolder, p->nHolder, sizeof(OMX_U32) * (p->nCapacity));
156        } else {
157            privateinfoparam.nCapacity = 0;
158            privateinfoparam.nHolder = NULL;
159        }
160    }
161
162    return OMX_ErrorNone;
163}
164
165const OMX_VIDEO_CONFIG_PRI_INFOTYPE *PortVideo::GetPortPrivateInfoParam(void)
166{
167    return &privateinfoparam;
168}
169
170
171/* end of PortVideo */
172
173PortAvc::PortAvc()
174{
175    OMX_VIDEO_PARAM_PORTFORMATTYPE videoparam;
176
177    memcpy(&videoparam, GetPortVideoParam(), sizeof(videoparam));
178    videoparam.eCompressionFormat = OMX_VIDEO_CodingAVC;
179    videoparam.eColorFormat = OMX_COLOR_FormatUnused;
180    videoparam.xFramerate = 15 << 16;
181    SetPortVideoParam(&videoparam, false);
182
183    memset(&avcparam, 0, sizeof(avcparam));
184
185    //set buffer sharing mode
186#ifdef COMPONENT_SUPPORT_BUFFER_SHARING
187#ifdef COMPONENT_SUPPORT_OPENCORE
188    SetPortBufferSharingInfo(OMX_TRUE);
189    avcparam.eProfile = OMX_VIDEO_AVCProfileVendorStartUnused;
190    avcparam.eLevel = OMX_VIDEO_AVCLevelVendorStartUnused;
191#endif
192#else
193    SetPortBufferSharingInfo(OMX_FALSE);
194//    avcparam.eProfile = OMX_VIDEO_AVCProfileVendorStartUnused;
195//    avcparam.eLevel = OMX_VIDEO_AVCLevelVendorStartUnused;
196#endif
197
198    ComponentBase::SetTypeHeader(&avcparam, sizeof(avcparam));
199}
200
201OMX_ERRORTYPE PortAvc::SetPortAvcParam(
202    const OMX_VIDEO_PARAM_AVCTYPE *p, bool overwrite_readonly)
203{
204    if (!overwrite_readonly) {
205        OMX_ERRORTYPE ret;
206
207        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
208        if (ret != OMX_ErrorNone)
209            return ret;
210        if (avcparam.nPortIndex != p->nPortIndex)
211            return OMX_ErrorBadPortIndex;
212    }
213    else {
214        OMX_VIDEO_PARAM_PORTFORMATTYPE videoparam;
215
216        memcpy(&videoparam, GetPortVideoParam(), sizeof(videoparam));
217        videoparam.nPortIndex = p->nPortIndex;
218        SetPortVideoParam(&videoparam, true);
219
220        avcparam.nPortIndex = p->nPortIndex;
221    }
222
223    avcparam.nSliceHeaderSpacing = p->nSliceHeaderSpacing;
224    avcparam.nPFrames = p->nPFrames;
225    avcparam.nBFrames = p->nBFrames;
226    avcparam.bUseHadamard = p->bUseHadamard;
227    avcparam.nRefFrames = p->nRefFrames;
228    avcparam.nRefIdx10ActiveMinus1 = p->nRefIdx10ActiveMinus1;
229    avcparam.nRefIdx11ActiveMinus1 = p->nRefIdx11ActiveMinus1;
230    avcparam.bEnableUEP = p->bEnableUEP;
231    avcparam.bEnableFMO = p->bEnableFMO;
232    avcparam.bEnableASO = p->bEnableASO;
233    avcparam.bEnableRS = p->bEnableRS;
234    avcparam.nAllowedPictureTypes = p->nAllowedPictureTypes;
235    avcparam.bFrameMBsOnly = p->bFrameMBsOnly;
236    avcparam.bMBAFF = p->bMBAFF;
237    avcparam.bEntropyCodingCABAC = p->bEntropyCodingCABAC;
238    avcparam.bWeightedPPrediction = p->bWeightedPPrediction;
239    avcparam.nWeightedBipredicitonMode = p->nWeightedBipredicitonMode;
240    avcparam.bconstIpred = p->bconstIpred;
241    avcparam.bDirect8x8Inference = p->bDirect8x8Inference;
242    avcparam.bDirectSpatialTemporal = p->bDirectSpatialTemporal;
243    avcparam.nCabacInitIdc = p->nCabacInitIdc;
244    avcparam.eLoopFilterMode = p->eLoopFilterMode;
245
246    return OMX_ErrorNone;
247}
248
249const OMX_VIDEO_PARAM_AVCTYPE *PortAvc::GetPortAvcParam(void)
250{
251    return &avcparam;
252}
253
254/* end of PortAvc */
255
256PortMpeg4::PortMpeg4()
257{
258    OMX_VIDEO_PARAM_PORTFORMATTYPE videoparam;
259
260    memcpy(&videoparam, GetPortVideoParam(), sizeof(videoparam));
261    videoparam.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
262    videoparam.eColorFormat = OMX_COLOR_FormatUnused;
263    videoparam.xFramerate = 15 << 16;
264    SetPortVideoParam(&videoparam, false);
265
266    memset(&mpeg4param, 0, sizeof(mpeg4param));
267    ComponentBase::SetTypeHeader(&mpeg4param, sizeof(mpeg4param));
268
269#ifdef COMPONENT_SUPPORT_BUFFER_SHARING
270#ifdef COMPONENT_SUPPORT_OPENCORE
271    SetPortBufferSharingInfo(OMX_TRUE);
272    mpeg4param.eProfile = OMX_VIDEO_MPEG4ProfileVendorStartUnused;
273    mpeg4param.eLevel = OMX_VIDEO_MPEG4LevelVendorStartUnused;
274#endif
275#else
276    SetPortBufferSharingInfo(OMX_FALSE);
277//  mpeg4param.eProfile = OMX_VIDEO_MPEG4ProfileVendorStartUnused;
278//  mpeg4param.eLevel = OMX_VIDEO_MPEG4LevelVendorStartUnused;
279#endif
280}
281
282OMX_ERRORTYPE PortMpeg4::SetPortMpeg4Param(
283    const OMX_VIDEO_PARAM_MPEG4TYPE *p, bool overwrite_readonly)
284{
285    if (!overwrite_readonly) {
286        OMX_ERRORTYPE ret;
287
288        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
289        if (ret != OMX_ErrorNone)
290            return ret;
291        if (mpeg4param.nPortIndex != p->nPortIndex)
292            return OMX_ErrorBadPortIndex;
293    }
294    else {
295        OMX_VIDEO_PARAM_PORTFORMATTYPE videoparam;
296
297        memcpy(&videoparam, GetPortVideoParam(), sizeof(videoparam));
298        videoparam.nPortIndex = p->nPortIndex;
299        SetPortVideoParam(&videoparam, true);
300
301        mpeg4param.nPortIndex = p->nPortIndex;
302    }
303
304    mpeg4param.nSliceHeaderSpacing = p->nSliceHeaderSpacing;
305    mpeg4param.bSVH = p->bSVH;
306    mpeg4param.bGov = p->bGov;
307    mpeg4param.nPFrames = p->nPFrames;
308    mpeg4param.nBFrames = p->nBFrames;
309    mpeg4param.nIDCVLCThreshold = p->nIDCVLCThreshold;
310    mpeg4param.bACPred = p->bACPred;
311    mpeg4param.nMaxPacketSize = p->nMaxPacketSize;
312    mpeg4param.nTimeIncRes = p->nTimeIncRes;
313    mpeg4param.eProfile = p->eProfile;
314    mpeg4param.eLevel = p->eLevel;
315    mpeg4param.nAllowedPictureTypes = p->nAllowedPictureTypes;
316    mpeg4param.nHeaderExtension = p->nHeaderExtension;
317    mpeg4param.bReversibleVLC = p->bReversibleVLC;
318
319    return OMX_ErrorNone;
320}
321
322const OMX_VIDEO_PARAM_MPEG4TYPE *PortMpeg4::GetPortMpeg4Param(void)
323{
324    return &mpeg4param;
325}
326
327/* end of PortMpeg4 */
328
329PortH263::PortH263()
330{
331    OMX_VIDEO_PARAM_PORTFORMATTYPE videoparam;
332
333    memcpy(&videoparam, GetPortVideoParam(), sizeof(videoparam));
334    videoparam.eCompressionFormat = OMX_VIDEO_CodingH263;
335    videoparam.eColorFormat = OMX_COLOR_FormatUnused;
336    videoparam.xFramerate = 15 << 16;
337    SetPortVideoParam(&videoparam, false);
338
339    memset(&h263param, 0, sizeof(h263param));
340
341    //set buffer sharing mode
342#ifdef COMPONENT_SUPPORT_BUFFER_SHARING
343#ifdef COMPONENT_SUPPORT_OPENCORE
344    SetPortBufferSharingInfo(OMX_TRUE);
345    h263param.eProfile = OMX_VIDEO_H263ProfileVendorStartUnused;
346    h263param.eLevel = OMX_VIDEO_H263LevelVendorStartUnused;
347#endif
348#else
349    SetPortBufferSharingInfo(OMX_FALSE);
350//    h263param.eProfile = OMX_VIDEO_H263ProfileVendorStartUnused;
351//    h263param.eLevel = OMX_VIDEO_H263LevelVendorStartUnused;
352#endif
353
354    ComponentBase::SetTypeHeader(&h263param, sizeof(h263param));
355}
356
357OMX_ERRORTYPE PortH263::SetPortH263Param(
358    const OMX_VIDEO_PARAM_H263TYPE *p, bool overwrite_readonly)
359{
360    if (!overwrite_readonly) {
361        OMX_ERRORTYPE ret;
362
363        ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p));
364        if (ret != OMX_ErrorNone)
365            return ret;
366        if (h263param.nPortIndex != p->nPortIndex)
367            return OMX_ErrorBadPortIndex;
368    }
369    else {
370        OMX_VIDEO_PARAM_PORTFORMATTYPE videoparam;
371
372        memcpy(&videoparam, GetPortVideoParam(), sizeof(videoparam));
373        videoparam.nPortIndex = p->nPortIndex;
374        SetPortVideoParam(&videoparam, true);
375
376        h263param.nPortIndex = p->nPortIndex;
377    }
378
379    h263param.nPFrames = p->nPFrames;
380    h263param.nBFrames = p->nBFrames;
381//    h263param.eProfile = p->eProfile;
382//    h263param.eLevel   = p->eLevel;
383    h263param.bPLUSPTYPEAllowed        = p->bPLUSPTYPEAllowed;
384    h263param.nAllowedPictureTypes     = p->nAllowedPictureTypes;
385    h263param.bForceRoundingTypeToZero = p->bForceRoundingTypeToZero;
386    h263param.nPictureHeaderRepetition = p->nPictureHeaderRepetition;
387    h263param.nGOBHeaderInterval       = p->nGOBHeaderInterval;
388
389    return OMX_ErrorNone;
390}
391
392const OMX_VIDEO_PARAM_H263TYPE *PortH263::GetPortH263Param(void)
393{
394    return &h263param;
395}
396
397/* end of PortH263 */
398
399
400