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 31 PortVideo::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 64 OMX_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 87 const OMX_VIDEO_PARAM_PORTFORMATTYPE *PortVideo::GetPortVideoParam(void) 88 { 89 return &videoparam; 90 } 91 92 OMX_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 113 const OMX_VIDEO_PARAM_BITRATETYPE *PortVideo::GetPortBitrateParam(void) 114 { 115 return &bitrateparam; 116 } 117 118 OMX_ERRORTYPE PortVideo::SetPortBufferSharingInfo(OMX_BOOL isbufsharing) 119 { 120 mbufsharing = isbufsharing; 121 122 return OMX_ErrorNone; 123 } 124 125 const OMX_BOOL *PortVideo::GetPortBufferSharingInfo(void) 126 { 127 return &mbufsharing; 128 } 129 130 131 OMX_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 165 const OMX_VIDEO_CONFIG_PRI_INFOTYPE *PortVideo::GetPortPrivateInfoParam(void) 166 { 167 return &privateinfoparam; 168 } 169 170 /* end of PortVideo */ 171 #if 0 172 PortAvc::PortAvc() 173 { 174 OMX_VIDEO_PARAM_PORTFORMATTYPE videoparam; 175 memcpy(&videoparam, GetPortVideoParam(), sizeof(videoparam)); 176 videoparam.eCompressionFormat = OMX_VIDEO_CodingAVC; 177 videoparam.eColorFormat = OMX_COLOR_FormatUnused; 178 videoparam.xFramerate = 15 << 16; 179 SetPortVideoParam(&videoparam, false); 180 181 memset(&avcparam, 0, sizeof(avcparam)); 182 ComponentBase::SetTypeHeader(&avcparam, sizeof(avcparam)); 183 184 avcparam.eProfile = OMX_VIDEO_AVCProfileVendorStartUnused; //defaul profle for buffer sharing in opencore 185 avcparam.eLevel = OMX_VIDEO_AVCLevelVendorStartUnused; //default level for buffer sharing in opencore 186 187 //set buffer sharing mode 188 #ifdef COMPONENT_SUPPORT_BUFFER_SHARING 189 SetPortBufferSharingInfo(OMX_TRUE); 190 #endif 191 192 } 193 OMX_ERRORTYPE PortAvc::SetPortAvcParam( 194 const OMX_VIDEO_PARAM_AVCTYPE *p, bool overwrite_readonly) 195 { 196 if (!overwrite_readonly) { 197 OMX_ERRORTYPE ret; 198 199 ret = ComponentBase::CheckTypeHeader((void *)p, sizeof(*p)); 200 if (ret != OMX_ErrorNone) 201 return ret; 202 if (avcparam.nPortIndex != p->nPortIndex) 203 return OMX_ErrorBadPortIndex; 204 } 205 else { 206 OMX_VIDEO_PARAM_PORTFORMATTYPE videoparam; 207 208 memcpy(&videoparam, GetPortVideoParam(), sizeof(videoparam)); 209 videoparam.nPortIndex = p->nPortIndex; 210 SetPortVideoParam(&videoparam, true); 211 212 avcparam.nPortIndex = p->nPortIndex; 213 } 214 avcparam.nSliceHeaderSpacing = p->nSliceHeaderSpacing; 215 avcparam.nPFrames = p->nPFrames; 216 avcparam.nBFrames = p->nBFrames; 217 avcparam.bUseHadamard = p->bUseHadamard; 218 avcparam.nRefFrames = p->nRefFrames; 219 avcparam.nRefIdx10ActiveMinus1 = p->nRefIdx10ActiveMinus1; 220 avcparam.nRefIdx11ActiveMinus1 = p->nRefIdx11ActiveMinus1; 221 avcparam.bEnableUEP = p->bEnableUEP; 222 avcparam.bEnableFMO = p->bEnableFMO; 223 avcparam.bEnableASO = p->bEnableASO; 224 avcparam.bEnableRS = p->bEnableRS; 225 avcparam.nAllowedPictureTypes = p->nAllowedPictureTypes; 226 avcparam.bFrameMBsOnly = p->bFrameMBsOnly; 227 avcparam.bMBAFF = p->bMBAFF; 228 avcparam.bEntropyCodingCABAC = p->bEntropyCodingCABAC; 229 avcparam.bWeightedPPrediction = p->bWeightedPPrediction; 230 avcparam.nWeightedBipredicitonMode = p->nWeightedBipredicitonMode; 231 avcparam.bconstIpred = p->bconstIpred; 232 avcparam.bDirect8x8Inference = p->bDirect8x8Inference; 233 avcparam.bDirectSpatialTemporal = p->bDirectSpatialTemporal; 234 avcparam.nCabacInitIdc = p->nCabacInitIdc; 235 avcparam.eLoopFilterMode = p->eLoopFilterMode; 236 237 #ifdef COMPONENT_SUPPORT_OPENCORE 238 #ifdef COMPONENT_SUPPORT_BUFFER_SHARING 239 // sepcial case ,not change default profile and level for opencore buffer sharing. 240 #else 241 avcparam.eProfile = p->eProfile; 242 avcparam.eLevel = p->eLevel; 243 #endif 244 #else 245 avcparam.eProfile = p->eProfile; 246 avcparam.eLevel = p->eLevel; 247 #endif 248 249 return OMX_ErrorNone; 250 } 251 252 const OMX_VIDEO_PARAM_AVCTYPE *PortAvc::GetPortAvcParam(void) 253 { 254 return &avcparam; 255 } 256 257 /* end of PortAvc */ 258 #endif 259 260
