1 /*
2 *
3 * Copyright 2013-2023 Rockchip Electronics Co., LTD.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 /*
19 * @file Rkon2_OMX_VdecControl.c
20 * @brief
21 * @author csy (csy@rock-chips.com)
22 * @version 1.0.0
23 * @history
24 * 2013.11.28 : Create
25 */
26 #undef ROCKCHIP_LOG_TAG
27 #define ROCKCHIP_LOG_TAG "omx_venc_ctl"
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <fcntl.h>
33 #include <poll.h>
34 #include "Rockchip_OMX_Macros.h"
35 #include "Rockchip_OSAL_Event.h"
36 #include "Rockchip_OMX_Basecomponent.h"
37 #include "Rockchip_OSAL_Thread.h"
38 #include "Rockchip_OSAL_Semaphore.h"
39 #include "Rockchip_OSAL_Mutex.h"
40 #include "Rockchip_OSAL_ETC.h"
41 #include "Rockchip_OSAL_SharedMemory.h"
42 #include "Rockchip_OSAL_Queue.h"
43 #ifdef OHOS_BUFFER_HANDLE
44 #include <buffer_handle.h>
45 #include <display_type.h>
46 #include <codec_omx_ext.h>
47 #endif
48 #include "Rockchip_OSAL_OHOS.h"
49 #include "Rkvpu_OMX_Venc.h"
50 #include "Rkvpu_OMX_VencControl.h"
51
52 #ifdef USE_ANB
53
54 #endif
55
56 #include "Rockchip_OSAL_Log.h"
57 #include "IVCommonExt.h"
58 #include "IndexExt.h"
59
60 typedef struct {
61 OMX_U32 mProfile;
62 OMX_U32 mLevel;
63 } CodecProfileLevel;
64
65 static const CodecProfileLevel kProfileLevels[] = {
66 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1 },
67 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b },
68 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11 },
69 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12 },
70 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13 },
71 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2 },
72 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21 },
73 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22 },
74 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3 },
75 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31 },
76 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel32 },
77 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel4 },
78 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel41 },
79 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel42 },
80 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel5 },
81 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel51 },
82 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1},
83 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1b},
84 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel11},
85 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel12},
86 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel13},
87 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel2},
88 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel21},
89 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel22},
90 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel3},
91 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel31},
92 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel32},
93 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel4},
94 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel41},
95 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel42},
96 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel5},
97 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel51},
98 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1},
99 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1b},
100 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel11},
101 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel12},
102 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel13},
103 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel2},
104 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel21},
105 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel22},
106 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel3},
107 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel31},
108 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel32},
109 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel4},
110 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel41},
111 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel42},
112 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel5},
113 { OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel51},
114 };
115
116 static const CodecProfileLevel kH265ProfileLevels[] = {
117 { CODEC_HEVC_PROFILE_MAIN, CODEC_HEVC_MAIN_TIER_LEVEL1 },
118 { CODEC_HEVC_PROFILE_MAIN, CODEC_HEVC_MAIN_TIER_LEVEL2 },
119 { CODEC_HEVC_PROFILE_MAIN, CODEC_HEVC_MAIN_TIER_LEVEL21 },
120 { CODEC_HEVC_PROFILE_MAIN, CODEC_HEVC_MAIN_TIER_LEVEL3 },
121 { CODEC_HEVC_PROFILE_MAIN, CODEC_HEVC_MAIN_TIER_LEVEL31 },
122 { CODEC_HEVC_PROFILE_MAIN, CODEC_HEVC_MAIN_TIER_LEVEL4 },
123 { CODEC_HEVC_PROFILE_MAIN, CODEC_HEVC_MAIN_TIER_LEVEL41 },
124 { CODEC_HEVC_PROFILE_MAIN, CODEC_HEVC_MAIN_TIER_LEVEL5 },
125 { CODEC_HEVC_PROFILE_MAIN, CODEC_HEVC_MAIN_TIER_LEVEL51 },
126 };
127
Rkvpu_OMX_ComponentTunnelRequest(OMX_IN OMX_HANDLETYPE hComp,OMX_IN OMX_U32 nPort,OMX_IN OMX_HANDLETYPE hTunneledComp,OMX_IN OMX_U32 nTunneledPort,OMX_INOUT OMX_TUNNELSETUPTYPE * pTunnelSetup)128 OMX_ERRORTYPE Rkvpu_OMX_ComponentTunnelRequest(OMX_IN OMX_HANDLETYPE hComp, OMX_IN OMX_U32 nPort,
129 OMX_IN OMX_HANDLETYPE hTunneledComp, OMX_IN OMX_U32 nTunneledPort,
130 OMX_INOUT OMX_TUNNELSETUPTYPE *pTunnelSetup)
131 {
132 OMX_ERRORTYPE ret = OMX_ErrorNone;
133 omx_err_f("This is not implemented");
134 ret = OMX_ErrorTunnelingUnsupported;
135 goto EXIT;
136 EXIT:
137 return ret;
138 }
139
Rkvpu_OMX_FreeTunnelBuffer(ROCKCHIP_OMX_BASEPORT * pOMXBasePort,OMX_U32 nPortIndex)140 OMX_ERRORTYPE Rkvpu_OMX_FreeTunnelBuffer(ROCKCHIP_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex)
141 {
142 OMX_ERRORTYPE ret = OMX_ErrorNone;
143 omx_err_f("This is not implemented");
144 ret = OMX_ErrorTunnelingUnsupported;
145 goto EXIT;
146 EXIT:
147 return ret;
148 }
149
Rkvpu_OMX_AllocateTunnelBuffer(ROCKCHIP_OMX_BASEPORT * pOMXBasePort,OMX_U32 nPortIndex)150 OMX_ERRORTYPE Rkvpu_OMX_AllocateTunnelBuffer(ROCKCHIP_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex)
151 {
152 OMX_ERRORTYPE ret = OMX_ErrorNone;
153 omx_err_f("This is not implemented");
154 ret = OMX_ErrorTunnelingUnsupported;
155 goto EXIT;
156 EXIT:
157 return ret;
158 }
159
Rkvpu_OMX_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes,OMX_IN OMX_U8 * pBuffer)160 OMX_ERRORTYPE Rkvpu_OMX_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,
161 OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr, OMX_IN OMX_U32 nPortIndex,
162 OMX_IN OMX_PTR pAppPrivate, OMX_IN OMX_U32 nSizeBytes, OMX_IN OMX_U8 *pBuffer)
163 {
164 FunctionIn();
165 OMX_U32 i = 0;
166 OMX_BUFFERHEADERTYPE *temp_bufferHeader = NULL;
167 OMX_ERRORTYPE ret = OMX_ErrorNone;
168 OMX_COMPONENTTYPE *pOMXComponent = NULL;
169 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
170 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
171
172 if (hComponent == NULL) {
173 omx_err_f("hComponent is null");
174 ret = OMX_ErrorBadParameter;
175 goto EXIT;
176 }
177 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
178 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
179 if (ret != OMX_ErrorNone) {
180 omx_err_f("check version ret err");
181 goto EXIT;
182 }
183
184 if (pOMXComponent->pComponentPrivate == NULL) {
185 omx_err_f("pComponentPrivate is null");
186 ret = OMX_ErrorBadParameter;
187 goto EXIT;
188 }
189 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
190
191 pRockchipPort = &pRockchipComponent->pRockchipPort[nPortIndex];
192 if (nPortIndex >= pRockchipComponent->portParam.nPorts) {
193 omx_err_f("nPortIndex is %d", nPortIndex);
194 ret = OMX_ErrorBadPortIndex;
195 goto EXIT;
196 }
197 if (pRockchipPort->portState != OMX_StateIdle) {
198 omx_err_f("portState is %d", pRockchipPort->portState);
199 ret = OMX_ErrorIncorrectStateOperation;
200 goto EXIT;
201 }
202
203 if (CHECK_PORT_TUNNELED(pRockchipPort) && CHECK_PORT_BUFFER_SUPPLIER(pRockchipPort)) {
204 omx_err_f("port status is incorrect");
205 ret = OMX_ErrorBadPortIndex;
206 goto EXIT;
207 }
208
209 temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)Rockchip_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
210 if (temp_bufferHeader == NULL) {
211 omx_err_f("temp_bufferHeader is null");
212 ret = OMX_ErrorInsufficientResources;
213 goto EXIT;
214 }
215 Rockchip_OSAL_Memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
216
217 for (i = 0; i < pRockchipPort->portDefinition.nBufferCountActual; i++) {
218 if (pRockchipPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
219 pRockchipPort->extendBufferHeader[i].OMXBufferHeader = temp_bufferHeader;
220 pRockchipPort->bufferStateAllocate[i] = (BUFFER_STATE_ASSIGNED | HEADER_STATE_ALLOCATED);
221 INIT_SET_SIZE_VERSION(temp_bufferHeader, OMX_BUFFERHEADERTYPE);
222 temp_bufferHeader->pBuffer = pBuffer;
223 temp_bufferHeader->nAllocLen = nSizeBytes;
224 temp_bufferHeader->pAppPrivate = pAppPrivate;
225 if (nPortIndex == INPUT_PORT_INDEX) {
226 temp_bufferHeader->nInputPortIndex = INPUT_PORT_INDEX;
227 } else {
228 temp_bufferHeader->nOutputPortIndex = OUTPUT_PORT_INDEX;
229 }
230 pRockchipPort->assignedBufferNum++;
231 if (pRockchipPort->assignedBufferNum == pRockchipPort->portDefinition.nBufferCountActual) {
232 pRockchipPort->portDefinition.bPopulated = OMX_TRUE;
233 Rockchip_OSAL_SemaphorePost(pRockchipPort->loadedResource);
234 }
235 *ppBufferHdr = temp_bufferHeader;
236 ret = OMX_ErrorNone;
237 goto EXIT;
238 }
239 }
240
241 Rockchip_OSAL_Free(temp_bufferHeader);
242 ret = OMX_ErrorInsufficientResources;
243
244 EXIT:
245 FunctionOut();
246 return ret;
247 }
248
Rkvpu_OMX_AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBuffer,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes)249 OMX_ERRORTYPE Rkvpu_OMX_AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,
250 OMX_INOUT OMX_BUFFERHEADERTYPE **ppBuffer, OMX_IN OMX_U32 nPortIndex,
251 OMX_IN OMX_PTR pAppPrivate, OMX_IN OMX_U32 nSizeBytes)
252 {
253 FunctionIn();
254 OMX_ERRORTYPE ret = OMX_ErrorNone;
255 OMX_COMPONENTTYPE *pOMXComponent = NULL;
256 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
257 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
258 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
259 OMX_BUFFERHEADERTYPE *temp_bufferHeader = NULL;
260 OMX_U8 *temp_buffer = NULL;
261 int temp_buffer_fd = -1;
262 OMX_U32 i = 0;
263 MEMORY_TYPE mem_type = NORMAL_MEMORY;
264 if (hComponent == NULL) {
265 ret = OMX_ErrorBadParameter;
266 omx_err_f("hComponent is null");
267 goto EXIT;
268 }
269 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
270 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
271 if (ret != OMX_ErrorNone) {
272 omx_err_f("check version ret err");
273 goto EXIT;
274 }
275
276 if (pOMXComponent->pComponentPrivate == NULL) {
277 omx_err_f("pComponentPrivate is null");
278 ret = OMX_ErrorBadParameter;
279 goto EXIT;
280 }
281 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
282 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
283
284 pRockchipPort = &pRockchipComponent->pRockchipPort[nPortIndex];
285 if (nPortIndex >= pRockchipComponent->portParam.nPorts) {
286 omx_err_f("nPortIndex is %d", nPortIndex);
287 ret = OMX_ErrorBadPortIndex;
288 goto EXIT;
289 }
290 if (CHECK_PORT_TUNNELED(pRockchipPort) && CHECK_PORT_BUFFER_SUPPLIER(pRockchipPort)) {
291 omx_err_f("port status is incorrect");
292 ret = OMX_ErrorBadPortIndex;
293 goto EXIT;
294 }
295
296 temp_buffer = (OMX_U8 *)Rockchip_OSAL_Malloc(nSizeBytes);
297 if (temp_buffer == NULL) {
298 omx_err_f("temp_buffer is null");
299 ret = OMX_ErrorInsufficientResources;
300 goto EXIT;
301 }
302
303 temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)Rockchip_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
304 if (temp_bufferHeader == NULL) {
305 omx_err_f("temp_bufferHeader is null");
306 Rockchip_OSAL_Free(temp_buffer);
307 ret = OMX_ErrorInsufficientResources;
308 goto EXIT;
309 }
310 Rockchip_OSAL_Memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
311
312 for (i = 0; i < pRockchipPort->portDefinition.nBufferCountActual; i++) {
313 if (pRockchipPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
314 pRockchipPort->extendBufferHeader[i].OMXBufferHeader = temp_bufferHeader;
315 pRockchipPort->extendBufferHeader[i].buf_fd[0] = temp_buffer_fd;
316 pRockchipPort->bufferStateAllocate[i] = (BUFFER_STATE_ALLOCATED | HEADER_STATE_ALLOCATED);
317 INIT_SET_SIZE_VERSION(temp_bufferHeader, OMX_BUFFERHEADERTYPE);
318 if (mem_type != SECURE_MEMORY) {
319 temp_bufferHeader->pBuffer = temp_buffer;
320 }
321 temp_bufferHeader->nAllocLen = nSizeBytes;
322 temp_bufferHeader->pAppPrivate = pAppPrivate;
323 if (nPortIndex == INPUT_PORT_INDEX) {
324 temp_bufferHeader->nInputPortIndex = INPUT_PORT_INDEX;
325 } else {
326 temp_bufferHeader->nOutputPortIndex = OUTPUT_PORT_INDEX;
327 }
328 pRockchipPort->assignedBufferNum++;
329 if (pRockchipPort->assignedBufferNum == pRockchipPort->portDefinition.nBufferCountActual) {
330 pRockchipPort->portDefinition.bPopulated = OMX_TRUE;
331 Rockchip_OSAL_SemaphorePost(pRockchipPort->loadedResource);
332 }
333 *ppBuffer = temp_bufferHeader;
334 ret = OMX_ErrorNone;
335 goto EXIT;
336 }
337 }
338 Rockchip_OSAL_Free(temp_bufferHeader);
339 Rockchip_OSAL_Free(temp_buffer);
340 ret = OMX_ErrorInsufficientResources;
341 EXIT:
342 FunctionOut();
343 return ret;
344 }
345
Rkvpu_OMX_FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_BUFFERHEADERTYPE * pBufferHdr)346 OMX_ERRORTYPE Rkvpu_OMX_FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,
347 OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr)
348 {
349 FunctionIn();
350 OMX_ERRORTYPE ret = OMX_ErrorNone;
351 OMX_COMPONENTTYPE *pOMXComponent = NULL;
352 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
353 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
354 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
355 OMX_U32 i = 0;
356 if (hComponent == NULL) {
357 omx_err_f("hComponent is null");
358 ret = OMX_ErrorBadParameter;
359 goto EXIT;
360 }
361 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
362 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
363 if (ret != OMX_ErrorNone) {
364 omx_err_f("check version ret err");
365 goto EXIT;
366 }
367
368 if (pOMXComponent->pComponentPrivate == NULL) {
369 omx_err_f("pComponentPrivate is null");
370 ret = OMX_ErrorBadParameter;
371 goto EXIT;
372 }
373 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
374 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
375 pRockchipPort = &pRockchipComponent->pRockchipPort[nPortIndex];
376
377 if (CHECK_PORT_TUNNELED(pRockchipPort) && CHECK_PORT_BUFFER_SUPPLIER(pRockchipPort)) {
378 omx_err_f("port status is incorrect");
379 ret = OMX_ErrorBadPortIndex;
380 goto EXIT;
381 }
382
383 if ((pRockchipPort->portState != OMX_StateLoaded) && (pRockchipPort->portState != OMX_StateInvalid)) {
384 (*(pRockchipComponent->pCallbacks->EventHandler)) (pOMXComponent, pRockchipComponent->callbackData,
385 (OMX_U32)OMX_EventError, (OMX_U32)OMX_ErrorPortUnpopulated,
386 nPortIndex, NULL);
387 }
388 for (i = 0; i < MAX_BUFFER_NUM; i++) {
389 if (((pRockchipPort->bufferStateAllocate[i] | BUFFER_STATE_FREE) != 0) &&
390 (pRockchipPort->extendBufferHeader[i].OMXBufferHeader != NULL)) {
391 if (pRockchipPort->extendBufferHeader[i].OMXBufferHeader->pBuffer == pBufferHdr->pBuffer) {
392 if (pRockchipPort->bufferStateAllocate[i] & BUFFER_STATE_ALLOCATED) {
393 Rockchip_OSAL_Free(pRockchipPort->extendBufferHeader[i].OMXBufferHeader->pBuffer);
394 pRockchipPort->extendBufferHeader[i].OMXBufferHeader->pBuffer = NULL;
395 pBufferHdr->pBuffer = NULL;
396 omx_trace("pBufferHdr->pBuffer == pRockchipPort->extendBufferHeader[i].OMXBufferHeader->pBuffer");
397 } else if (pRockchipPort->bufferStateAllocate[i] & BUFFER_STATE_ASSIGNED) {
398 omx_trace("donothing");
399 }
400 pRockchipPort->assignedBufferNum--;
401 if (pRockchipPort->bufferStateAllocate[i] & HEADER_STATE_ALLOCATED) {
402 Rockchip_OSAL_Free(pRockchipPort->extendBufferHeader[i].OMXBufferHeader);
403 pRockchipPort->extendBufferHeader[i].OMXBufferHeader = NULL;
404 pBufferHdr = NULL;
405 }
406 pRockchipPort->bufferStateAllocate[i] = BUFFER_STATE_FREE;
407 ret = OMX_ErrorNone;
408 goto EXIT;
409 }
410 }
411 }
412 omx_trace("pRockchipPort->assignedBufferNum = %d", pRockchipPort->assignedBufferNum);
413 EXIT:
414 if (ret == OMX_ErrorNone) {
415 if (pRockchipPort->assignedBufferNum == 0) {
416 omx_trace("pRockchipPort->unloadedResource signal set");
417 Rockchip_OSAL_SemaphorePost(pRockchipPort->unloadedResource);
418 pRockchipPort->portDefinition.bPopulated = OMX_FALSE;
419 }
420 }
421 FunctionOut();
422 return ret;
423 }
424
Rkvpu_OMX_GetFlushBuffer(ROCKCHIP_OMX_BASEPORT * pRockchipPort,ROCKCHIP_OMX_DATABUFFER * pDataBuffer[])425 OMX_ERRORTYPE Rkvpu_OMX_GetFlushBuffer(ROCKCHIP_OMX_BASEPORT *pRockchipPort, ROCKCHIP_OMX_DATABUFFER *pDataBuffer[])
426 {
427 OMX_ERRORTYPE ret = OMX_ErrorNone;
428 FunctionIn();
429 *pDataBuffer = NULL;
430 if (pRockchipPort->portWayType == WAY1_PORT) {
431 omx_trace("portWayType == WAY1_PORT");
432 *pDataBuffer = &pRockchipPort->way.port1WayDataBuffer.dataBuffer;
433 } else if (pRockchipPort->portWayType == WAY2_PORT) {
434 omx_trace("portWayType == WAY2_PORT");
435 pDataBuffer[0] = &(pRockchipPort->way.port2WayDataBuffer.inputDataBuffer);
436 pDataBuffer[1] = &(pRockchipPort->way.port2WayDataBuffer.outputDataBuffer);
437 }
438 goto EXIT;
439 EXIT:
440 FunctionOut();
441 return ret;
442 }
443
Rkvpu_OMX_FlushPort(OMX_COMPONENTTYPE * pOMXComponent,OMX_S32 portIndex)444 OMX_ERRORTYPE Rkvpu_OMX_FlushPort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
445 {
446 FunctionIn();
447 OMX_ERRORTYPE ret = OMX_ErrorNone;
448 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
449 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
450 OMX_BUFFERHEADERTYPE *bufferHeader = NULL;
451 ROCKCHIP_OMX_DATABUFFER *pDataPortBuffer[2] = {NULL, NULL};
452 ROCKCHIP_OMX_MESSAGE *message = NULL;
453 OMX_S32 semValue = 0;
454 int i = 0, maxBufferNum = 0;
455 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
456 while (Rockchip_OSAL_GetElemNum(&pRockchipPort->bufferQ) > 0) {
457 Rockchip_OSAL_Get_SemaphoreCount(pRockchipComponent->pRockchipPort[portIndex].bufferSemID, &semValue);
458 if (semValue == 0) {
459 Rockchip_OSAL_SemaphorePost(pRockchipComponent->pRockchipPort[portIndex].bufferSemID);
460 }
461 Rockchip_OSAL_SemaphoreWait(pRockchipComponent->pRockchipPort[portIndex].bufferSemID);
462 message = (ROCKCHIP_OMX_MESSAGE *)Rockchip_OSAL_Dequeue(&pRockchipPort->bufferQ);
463 if ((message != NULL) && (message->messageType != ROCKCHIP_OMX_CommandFakeBuffer)) {
464 bufferHeader = (OMX_BUFFERHEADERTYPE *)message->pCmdData;
465 bufferHeader->nFilledLen = 0;
466 if (portIndex == OUTPUT_PORT_INDEX) {
467 Rockchip_OMX_OutputBufferReturn(pOMXComponent, bufferHeader);
468 } else if (portIndex == INPUT_PORT_INDEX) {
469 Rkvpu_OMX_InputBufferReturn(pOMXComponent, bufferHeader);
470 }
471 }
472 Rockchip_OSAL_Free(message);
473 message = NULL;
474 }
475
476 Rkvpu_OMX_GetFlushBuffer(pRockchipPort, pDataPortBuffer);
477 if (portIndex == INPUT_PORT_INDEX) {
478 if (pDataPortBuffer[0]->dataValid == OMX_TRUE)
479 Rkvpu_InputBufferReturn(pOMXComponent, pDataPortBuffer[0]);
480 if (pDataPortBuffer[1]->dataValid == OMX_TRUE)
481 Rkvpu_InputBufferReturn(pOMXComponent, pDataPortBuffer[1]);
482 } else if (portIndex == OUTPUT_PORT_INDEX) {
483 if (pDataPortBuffer[0]->dataValid == OMX_TRUE)
484 Rkvpu_OutputBufferReturn(pOMXComponent, pDataPortBuffer[0]);
485 if (pDataPortBuffer[1]->dataValid == OMX_TRUE)
486 Rkvpu_OutputBufferReturn(pOMXComponent, pDataPortBuffer[1]);
487 }
488
489 if (pRockchipComponent->bMultiThreadProcess == OMX_TRUE) {
490 if (pRockchipPort->bufferProcessType == BUFFER_SHARE) {
491 omx_trace("pRockchipPort->bufferProcessType is BUFFER_SHARE");
492 if (pRockchipPort->processData.bufferHeader != NULL) {
493 if (portIndex == INPUT_PORT_INDEX) {
494 Rkvpu_OMX_InputBufferReturn(pOMXComponent, pRockchipPort->processData.bufferHeader);
495 } else if (portIndex == OUTPUT_PORT_INDEX) {
496 Rockchip_OMX_OutputBufferReturn(pOMXComponent, pRockchipPort->processData.bufferHeader);
497 }
498 }
499 Rockchip_ResetCodecData(&pRockchipPort->processData);
500 maxBufferNum = pRockchipPort->portDefinition.nBufferCountActual;
501 omx_trace("maxBufferNum is %d", maxBufferNum);
502 for (i = 0; i < maxBufferNum; i++) {
503 if (pRockchipPort->extendBufferHeader[i].bBufferInOMX == OMX_TRUE) {
504 if (portIndex == OUTPUT_PORT_INDEX) {
505 Rockchip_OMX_OutputBufferReturn(pOMXComponent,
506 pRockchipPort->extendBufferHeader[i].OMXBufferHeader);
507 } else if (portIndex == INPUT_PORT_INDEX) {
508 Rkvpu_OMX_InputBufferReturn(pOMXComponent,
509 pRockchipPort->extendBufferHeader[i].OMXBufferHeader);
510 }
511 }
512 }
513 }
514 } else {
515 Rockchip_ResetCodecData(&pRockchipPort->processData);
516 }
517
518 if ((pRockchipPort->bufferProcessType == BUFFER_SHARE) &&
519 (portIndex == OUTPUT_PORT_INDEX)) {
520 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
521
522 if (pOMXComponent->pComponentPrivate == NULL) {
523 omx_err_f("pComponentPrivate is null");
524 ret = OMX_ErrorBadParameter;
525 goto EXIT;
526 }
527 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
528 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
529 }
530
531 while (1) {
532 OMX_S32 cnt = 0;
533 Rockchip_OSAL_Get_SemaphoreCount(pRockchipComponent->pRockchipPort[portIndex].bufferSemID, &cnt);
534 if (cnt <= 0) {
535 omx_trace("cnt <= 0, don't wait");
536 break;
537 }
538 Rockchip_OSAL_SemaphoreWait(pRockchipComponent->pRockchipPort[portIndex].bufferSemID);
539 }
540 Rockchip_OSAL_ResetQueue(&pRockchipPort->bufferQ);
541 EXIT:
542 FunctionOut();
543 return ret;
544 }
545
Rkvpu_OMX_BufferFlush(OMX_COMPONENTTYPE * pOMXComponent,OMX_S32 nPortIndex,OMX_BOOL bEvent)546 OMX_ERRORTYPE Rkvpu_OMX_BufferFlush(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex, OMX_BOOL bEvent)
547 {
548 FunctionIn();
549 OMX_ERRORTYPE ret = OMX_ErrorNone;
550 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
551 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
552 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
553 ROCKCHIP_OMX_DATABUFFER *flushPortBuffer[2] = {NULL, NULL};
554 if (pOMXComponent == NULL) {
555 omx_err_f("pOMXComponent is null");
556 ret = OMX_ErrorBadParameter;
557 goto EXIT;
558 }
559 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
560 if (ret != OMX_ErrorNone) {
561 omx_err_f("version check err");
562 goto EXIT;
563 }
564
565 if (pOMXComponent->pComponentPrivate == NULL) {
566 omx_err_f("pComponentPrivate is null");
567 ret = OMX_ErrorBadParameter;
568 goto EXIT;
569 }
570 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
571 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
572
573 omx_trace("OMX_CommandFlush start, port:%ld", nPortIndex);
574
575 pRockchipComponent->pRockchipPort[nPortIndex].bIsPortFlushed = OMX_TRUE;
576
577 if (pRockchipComponent->bMultiThreadProcess == OMX_FALSE) {
578 Rockchip_OSAL_SignalSet(pRockchipComponent->pauseEvent);
579 } else {
580 Rockchip_OSAL_SignalSet(pRockchipComponent->pRockchipPort[nPortIndex].pauseEvent);
581 }
582
583 pRockchipPort = &pRockchipComponent->pRockchipPort[nPortIndex];
584 Rkvpu_OMX_GetFlushBuffer(pRockchipPort, flushPortBuffer);
585
586 Rockchip_OSAL_SemaphorePost(pRockchipPort->bufferSemID);
587
588 Rockchip_OSAL_MutexLock(flushPortBuffer[0]->bufferMutex);
589 Rockchip_OSAL_MutexLock(flushPortBuffer[1]->bufferMutex);
590
591 ret = Rkvpu_OMX_FlushPort(pOMXComponent, nPortIndex);
592 VpuCodecContext_t *p_vpu_ctx = pVideoEnc->vpu_ctx;
593 if (pRockchipComponent->nRkFlags & RK_VPU_NEED_FLUSH_ON_SEEK) {
594 p_vpu_ctx->flush(p_vpu_ctx);
595 pRockchipComponent->nRkFlags &= ~RK_VPU_NEED_FLUSH_ON_SEEK;
596 }
597 Rockchip_ResetCodecData(&pRockchipPort->processData);
598
599 if (ret == OMX_ErrorNone) {
600 if (nPortIndex == INPUT_PORT_INDEX) {
601 pRockchipComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
602 pRockchipComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
603 Rockchip_OSAL_Memset(pRockchipComponent->timeStamp, -19771003, // -19771003:byte alignment
604 sizeof(OMX_TICKS) * MAX_TIMESTAMP);
605 Rockchip_OSAL_Memset(pRockchipComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
606 pRockchipComponent->getAllDelayBuffer = OMX_FALSE;
607 pRockchipComponent->bSaveFlagEOS = OMX_FALSE;
608 pRockchipComponent->bBehaviorEOS = OMX_FALSE;
609 pRockchipComponent->reInputData = OMX_FALSE;
610 if (pVideoEnc) {
611 pVideoEnc->bEncSendEos = OMX_FALSE;
612 }
613 }
614
615 pRockchipComponent->pRockchipPort[nPortIndex].bIsPortFlushed = OMX_FALSE;
616 omx_trace("OMX_CommandFlush EventCmdComplete, port:%ld", nPortIndex);
617 if (bEvent == OMX_TRUE)
618 pRockchipComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
619 pRockchipComponent->callbackData,
620 OMX_EventCmdComplete,
621 OMX_CommandFlush, nPortIndex, NULL);
622 }
623 Rockchip_OSAL_MutexUnlock(flushPortBuffer[1]->bufferMutex);
624 Rockchip_OSAL_MutexUnlock(flushPortBuffer[0]->bufferMutex);
625
626 EXIT:
627 if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pRockchipComponent != NULL)) {
628 omx_err("ERROR");
629 pRockchipComponent->pCallbacks->EventHandler(pOMXComponent,
630 pRockchipComponent->callbackData,
631 OMX_EventError,
632 ret, 0, NULL);
633 }
634
635 FunctionOut();
636 return ret;
637 }
638
Rkvpu_RectSet(OMX_CONFIG_RECTTYPE * dstRect,OMX_CONFIG_RECTTYPE * src)639 void Rkvpu_RectSet(OMX_CONFIG_RECTTYPE* dstRect, OMX_CONFIG_RECTTYPE* src)
640 {
641 if (dstRect == NULL || src == NULL) {
642 omx_err_f("dstRect or sr is null");
643 return;
644 }
645
646 dstRect->nTop = src->nTop;
647 dstRect->nLeft = src->nLeft;
648 dstRect->nWidth = src->nWidth;
649 dstRect->nHeight = src->nHeight;
650 }
651
Rkvpu_PortFormatSet(OMX_PARAM_PORTDEFINITIONTYPE * dst,OMX_PARAM_PORTDEFINITIONTYPE * src)652 void Rkvpu_PortFormatSet(OMX_PARAM_PORTDEFINITIONTYPE* dst, OMX_PARAM_PORTDEFINITIONTYPE* src)
653 {
654 if (dst == NULL || src == NULL) {
655 omx_err_f("dstRect or sr is null");
656 return;
657 }
658 dst->format.video.nFrameWidth = src->format.video.nFrameWidth;
659 dst->format.video.nFrameHeight = src->format.video.nFrameHeight;
660 dst->format.video.nStride = src->format.video.nStride;
661 dst->format.video.nSliceHeight = src->format.video.nSliceHeight;
662 }
Rkvpu_ResolutionUpdate(OMX_COMPONENTTYPE * pOMXComponent)663 OMX_ERRORTYPE Rkvpu_ResolutionUpdate(OMX_COMPONENTTYPE *pOMXComponent)
664 {
665 OMX_ERRORTYPE ret = OMX_ErrorNone;
666 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
667 ROCKCHIP_OMX_BASEPORT *pInputPort = &pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX];
668 ROCKCHIP_OMX_BASEPORT *pOutputPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
669 // reset output crop rect
670 Rkvpu_RectSet(&pOutputPort->cropRectangle, &pOutputPort->newCropRectangle);
671
672 // reset input port video
673 Rkvpu_PortFormatSet(&pInputPort->portDefinition, &pInputPort->newPortDefinition);
674
675 pOutputPort->portDefinition.nBufferCountActual = pOutputPort->newPortDefinition.nBufferCountActual;
676 pOutputPort->portDefinition.nBufferCountMin = pOutputPort->newPortDefinition.nBufferCountMin;
677
678 UpdateFrameSize(pOMXComponent);
679 return ret;
680 }
681
Rkvpu_OutputBufferReturn(OMX_COMPONENTTYPE * pOMXComponent,ROCKCHIP_OMX_DATABUFFER * dataBuffer)682 OMX_ERRORTYPE Rkvpu_OutputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent, ROCKCHIP_OMX_DATABUFFER *dataBuffer)
683 {
684 OMX_ERRORTYPE ret = OMX_ErrorNone;
685 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
686 ROCKCHIP_OMX_BASEPORT *rockchipOMXOutputPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
687 OMX_BUFFERHEADERTYPE *bufferHeader = NULL;
688 FunctionIn();
689 bufferHeader = dataBuffer->bufferHeader;
690 if (bufferHeader != NULL) {
691 bufferHeader->nFilledLen = dataBuffer->remainDataLen;
692 bufferHeader->nOffset = 0;
693 bufferHeader->nFlags = dataBuffer->nFlags;
694 bufferHeader->nTimeStamp = dataBuffer->timeStamp;
695
696 if ((rockchipOMXOutputPort->bStoreMetaData == OMX_TRUE) && (bufferHeader->nFilledLen > 0))
697 bufferHeader->nFilledLen = bufferHeader->nAllocLen;
698
699 if (pRockchipComponent->propagateMarkType.hMarkTargetComponent != NULL) {
700 bufferHeader->hMarkTargetComponent = pRockchipComponent->propagateMarkType.hMarkTargetComponent;
701 bufferHeader->pMarkData = pRockchipComponent->propagateMarkType.pMarkData;
702 pRockchipComponent->propagateMarkType.hMarkTargetComponent = NULL;
703 pRockchipComponent->propagateMarkType.pMarkData = NULL;
704 }
705
706 if ((bufferHeader->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
707 omx_info("event OMX_BUFFERFLAG_EOS!!!");
708 pRockchipComponent->pCallbacks->EventHandler(pOMXComponent,
709 pRockchipComponent->callbackData,
710 OMX_EventBufferFlag,
711 OUTPUT_PORT_INDEX,
712 bufferHeader->nFlags, NULL);
713 }
714
715 Rockchip_OMX_OutputBufferReturn(pOMXComponent, bufferHeader);
716 }
717
718 /* reset dataBuffer */
719 Rockchip_ResetDataBuffer(dataBuffer);
720
721 goto EXIT;
722 EXIT:
723 FunctionOut();
724 return ret;
725 }
726
Rkvpu_InputBufferReturn(OMX_COMPONENTTYPE * pOMXComponent,ROCKCHIP_OMX_DATABUFFER * dataBuffer)727 OMX_ERRORTYPE Rkvpu_InputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent, ROCKCHIP_OMX_DATABUFFER *dataBuffer)
728 {
729 FunctionIn();
730 OMX_ERRORTYPE ret = OMX_ErrorNone;
731 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
732 ROCKCHIP_OMX_BASEPORT *rockchipOMXInputPort = &pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX];
733 OMX_BUFFERHEADERTYPE *bufferHeader = NULL;
734 bufferHeader = dataBuffer->bufferHeader;
735 if (bufferHeader != NULL) {
736 omx_trace_f("bufferHeader is not null");
737 if (rockchipOMXInputPort->markType.hMarkTargetComponent != NULL) {
738 omx_trace_f("hMarkTargetComponent is not null");
739 bufferHeader->hMarkTargetComponent = rockchipOMXInputPort->markType.hMarkTargetComponent;
740 bufferHeader->pMarkData = rockchipOMXInputPort->markType.pMarkData;
741 rockchipOMXInputPort->markType.hMarkTargetComponent = NULL;
742 rockchipOMXInputPort->markType.pMarkData = NULL;
743 }
744 if (bufferHeader->hMarkTargetComponent != NULL) {
745 omx_trace_f("bufferHeader->hMarkTargetComponent is not null");
746 if (bufferHeader->hMarkTargetComponent == pOMXComponent) {
747 omx_trace("hMarkTargetComponent == pOMXComponent, send OMX_EventMark");
748 pRockchipComponent->pCallbacks->EventHandler(pOMXComponent, pRockchipComponent->callbackData,
749 OMX_EventMark, 0, 0, bufferHeader->pMarkData);
750 } else {
751 pRockchipComponent->propagateMarkType.hMarkTargetComponent = bufferHeader->hMarkTargetComponent;
752 pRockchipComponent->propagateMarkType.pMarkData = bufferHeader->pMarkData;
753 }
754 }
755 bufferHeader->nFilledLen = 0;
756 bufferHeader->nOffset = 0;
757 omx_trace("input buffer return");
758 Rkvpu_OMX_InputBufferReturn(pOMXComponent, bufferHeader);
759 }
760 /* reset dataBuffer */
761 Rockchip_ResetDataBuffer(dataBuffer);
762 goto EXIT;
763 EXIT:
764 FunctionOut();
765 return ret;
766 }
767
Rkvpu_OutputBufferGetQueue(ROCKCHIP_OMX_BASECOMPONENT * pRockchipComponent)768 OMX_ERRORTYPE Rkvpu_OutputBufferGetQueue(ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent)
769 {
770 OMX_U32 ret = OMX_ErrorUndefined;
771 ROCKCHIP_OMX_BASEPORT *pRockchipPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
772 ROCKCHIP_OMX_MESSAGE *message = NULL;
773 ROCKCHIP_OMX_DATABUFFER *outputUseBuffer = NULL;
774 FunctionIn();
775 outputUseBuffer = &(pRockchipPort->way.port2WayDataBuffer.outputDataBuffer);
776
777 if (pRockchipComponent->currentState != OMX_StateExecuting) {
778 omx_err_f("currentState is %d", pRockchipComponent->currentState);
779 ret = OMX_ErrorUndefined;
780 goto EXIT;
781 } else if ((pRockchipComponent->transientState != ROCKCHIP_OMX_TransStateExecutingToIdle) &&
782 (!CHECK_PORT_BEING_FLUSHED(pRockchipPort))) {
783 Rockchip_OSAL_SemaphoreWait(pRockchipPort->bufferSemID);
784 if (outputUseBuffer->dataValid != OMX_TRUE) {
785 message = (ROCKCHIP_OMX_MESSAGE *)Rockchip_OSAL_Dequeue(&pRockchipPort->bufferQ);
786 if (message == NULL) {
787 omx_err_f("message is null");
788 ret = OMX_ErrorUndefined;
789 goto EXIT;
790 }
791 if (message->messageType == ROCKCHIP_OMX_CommandFakeBuffer) {
792 Rockchip_OSAL_Free(message);
793 ret = OMX_ErrorCodecFlush;
794 omx_err_f("messageType == ROCKCHIP_OMX_CommandFakeBuffer");
795 goto EXIT;
796 }
797 outputUseBuffer->dataLen = 0;
798 outputUseBuffer->usedDataLen = 0;
799 outputUseBuffer->dataValid = OMX_TRUE;
800 outputUseBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
801 outputUseBuffer->allocSize = outputUseBuffer->bufferHeader->nAllocLen;
802 outputUseBuffer->remainDataLen = outputUseBuffer->dataLen;
803 Rockchip_OSAL_Free(message);
804 }
805 ret = OMX_ErrorNone;
806 }
807 EXIT:
808 FunctionOut();
809 return ret;
810 }
811
Rkvpu_InputBufferGetQueue(ROCKCHIP_OMX_BASECOMPONENT * pRockchipComponent)812 OMX_ERRORTYPE Rkvpu_InputBufferGetQueue(ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent)
813 {
814 OMX_U32 ret = OMX_ErrorUndefined;
815 ROCKCHIP_OMX_BASEPORT *pRockchipPort = &pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX];
816 ROCKCHIP_OMX_MESSAGE *message = NULL;
817 ROCKCHIP_OMX_DATABUFFER *inputUseBuffer = NULL;
818
819 FunctionIn();
820 inputUseBuffer = &(pRockchipPort->way.port2WayDataBuffer.inputDataBuffer);
821 if (pRockchipComponent->currentState != OMX_StateExecuting) {
822 omx_err_f("currentState is %d", pRockchipComponent->currentState);
823 ret = OMX_ErrorUndefined;
824 goto EXIT;
825 } else if ((pRockchipComponent->transientState != ROCKCHIP_OMX_TransStateExecutingToIdle) &&
826 (!CHECK_PORT_BEING_FLUSHED(pRockchipPort))) {
827 Rockchip_OSAL_SemaphoreWait(pRockchipPort->bufferSemID);
828 if (inputUseBuffer->dataValid != OMX_TRUE) {
829 message = (ROCKCHIP_OMX_MESSAGE *)Rockchip_OSAL_Dequeue(&pRockchipPort->bufferQ);
830 if (message == NULL) {
831 omx_err_f("messageType is null");
832 ret = OMX_ErrorUndefined;
833 goto EXIT;
834 }
835 if (message->messageType == ROCKCHIP_OMX_CommandFakeBuffer) {
836 Rockchip_OSAL_Free(message);
837 ret = OMX_ErrorCodecFlush;
838 omx_err_f("messageType is ROCKCHIP_OMX_CommandFakeBuffer");
839 goto EXIT;
840 }
841 inputUseBuffer->usedDataLen = 0;
842 inputUseBuffer->dataValid = OMX_TRUE;
843 inputUseBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
844 OMX_BUFFERHEADERTYPE* bufferHead = inputUseBuffer->bufferHeader;
845 if (bufferHead != NULL) {
846 inputUseBuffer->allocSize = bufferHead->nAllocLen;
847 inputUseBuffer->dataLen = bufferHead->nFilledLen;
848 inputUseBuffer->nFlags = bufferHead->nFlags;
849 inputUseBuffer->timeStamp = bufferHead->nTimeStamp;
850 }
851 inputUseBuffer->remainDataLen = inputUseBuffer->dataLen;
852 Rockchip_OSAL_Free(message);
853 if (inputUseBuffer->allocSize <= inputUseBuffer->dataLen)
854 omx_trace("Input Buffer Full, Check input buffer size! allocSize:%lu, dataLen:%lu",
855 inputUseBuffer->allocSize, inputUseBuffer->dataLen);
856 }
857 ret = OMX_ErrorNone;
858 }
859 EXIT:
860 FunctionOut();
861 return ret;
862 }
863
Rkvpu_OutputBufferGetQueue_Direct(ROCKCHIP_OMX_BASECOMPONENT * pRockchipComponent)864 OMX_BUFFERHEADERTYPE *Rkvpu_OutputBufferGetQueue_Direct(ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent)
865 {
866 OMX_BUFFERHEADERTYPE *retBuffer = NULL;
867 ROCKCHIP_OMX_BASEPORT *pRockchipPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
868 ROCKCHIP_OMX_MESSAGE *message = NULL;
869
870 FunctionIn();
871
872 if (pRockchipComponent->currentState != OMX_StateExecuting) {
873 omx_err_f("currentState is %d", pRockchipComponent->currentState);
874 retBuffer = NULL;
875 goto EXIT;
876 } else if ((pRockchipComponent->transientState != ROCKCHIP_OMX_TransStateExecutingToIdle) &&
877 (!CHECK_PORT_BEING_FLUSHED(pRockchipPort))) {
878 Rockchip_OSAL_SemaphoreWait(pRockchipPort->bufferSemID);
879
880 message = (ROCKCHIP_OMX_MESSAGE *)Rockchip_OSAL_Dequeue(&pRockchipPort->bufferQ);
881 if (message == NULL) {
882 retBuffer = NULL;
883 goto EXIT;
884 }
885 if (message->messageType == ROCKCHIP_OMX_CommandFakeBuffer) {
886 omx_err_f("messageType == ROCKCHIP_OMX_CommandFakeBuffer");
887 Rockchip_OSAL_Free(message);
888 retBuffer = NULL;
889 goto EXIT;
890 }
891
892 retBuffer = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
893 Rockchip_OSAL_Free(message);
894 }
895
896 EXIT:
897 FunctionOut();
898
899 return retBuffer;
900 }
901
Rkvpu_CodecBufferReset(ROCKCHIP_OMX_BASECOMPONENT * pRockchipComponent,OMX_U32 PortIndex)902 OMX_ERRORTYPE Rkvpu_CodecBufferReset(ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent, OMX_U32 PortIndex)
903 {
904 OMX_ERRORTYPE ret = OMX_ErrorNone;
905 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
906 FunctionIn();
907 pRockchipPort = &pRockchipComponent->pRockchipPort[PortIndex];
908 ret = Rockchip_OSAL_ResetQueue(&pRockchipPort->codecBufferQ);
909 if (ret != 0) {
910 omx_err_f("Rockchip_OSAL_ResetQueue ret err");
911 ret = OMX_ErrorUndefined;
912 goto EXIT;
913 }
914 while (1) {
915 OMX_S32 cnt = 0;
916 Rockchip_OSAL_Get_SemaphoreCount(pRockchipPort->codecSemID, &cnt);
917 if (cnt > 0) {
918 omx_info_f("cnt > 0, need wait");
919 Rockchip_OSAL_SemaphoreWait(pRockchipPort->codecSemID);
920 } else {
921 break;
922 }
923 }
924 ret = OMX_ErrorNone;
925 EXIT:
926 FunctionOut();
927 return ret;
928 }
929
Rkvpu_OMX_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_INOUT OMX_PTR ComponentParameterStructure)930 OMX_ERRORTYPE Rkvpu_OMX_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,
931 OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR ComponentParameterStructure)
932 {
933 OMX_ERRORTYPE ret = OMX_ErrorNone;
934 OMX_COMPONENTTYPE *pOMXComponent = NULL;
935 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
936 FunctionIn();
937
938 if (hComponent == NULL) {
939 omx_err_f("hComponent is null");
940 ret = OMX_ErrorBadParameter;
941 goto EXIT;
942 }
943 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
944 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
945 if (ret != OMX_ErrorNone) {
946 omx_err_f("check size err OMX_COMPONENTTYPE ");
947 goto EXIT;
948 }
949
950 if (pOMXComponent->pComponentPrivate == NULL) {
951 omx_err_f("pComponentPrivate is null");
952 ret = OMX_ErrorBadParameter;
953 goto EXIT;
954 }
955 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
956 if (pRockchipComponent->currentState == OMX_StateInvalid) {
957 omx_err_f("currentState == OMX_StateInvalid");
958 ret = OMX_ErrorInvalidState;
959 goto EXIT;
960 }
961
962 if (ComponentParameterStructure == NULL) {
963 omx_err_f("ComponentParameterStructure is null");
964 ret = OMX_ErrorBadParameter;
965 goto EXIT;
966 }
967
968 switch ((OMX_U32)nParamIndex) {
969 case OMX_IndexParamVideoInit: {
970 OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
971 ret = Rockchip_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
972 if (ret != OMX_ErrorNone) {
973 omx_err_f("size check err");
974 goto EXIT;
975 }
976 portParam->nPorts = pRockchipComponent->portParam.nPorts;
977 portParam->nStartPortNumber = pRockchipComponent->portParam.nStartPortNumber;
978 ret = OMX_ErrorNone;
979 break;
980 }
981 case OMX_IndexParamVideoPortFormat: {
982 OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
983 OMX_U32 portIndex = portFormat->nPortIndex, index = portFormat->nIndex, supportFormatNum = 0;
984 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
985 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
986 ret = Rockchip_OMX_Check_SizeVersion(portFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
987 if (ret != OMX_ErrorNone) {
988 omx_err_f("size check err");
989 goto EXIT;
990 }
991 if ((portIndex >= pRockchipComponent->portParam.nPorts)) {
992 ret = OMX_ErrorBadPortIndex;
993 omx_err_f("portIndex is %d", portIndex);
994 goto EXIT;
995 }
996 if (portIndex == INPUT_PORT_INDEX) {
997 pRockchipPort = &pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX];
998 portDefinition = &pRockchipPort->portDefinition;
999 switch (index) {
1000 case supportFormat_0: {
1001 portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1002 portFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
1003 portFormat->xFramerate = portDefinition->format.video.xFramerate;
1004 break;
1005 }
1006 case supportFormat_1: {
1007 portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1008 portFormat->eColorFormat = (OMX_COLOR_FORMATTYPE)CODEC_COLOR_FORMAT_RGBA8888;
1009 portFormat->xFramerate = portDefinition->format.video.xFramerate;
1010 break;
1011 }
1012 case supportFormat_2: {
1013 portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1014 portFormat->eColorFormat = OMX_COLOR_Format32bitBGRA8888;
1015 portFormat->xFramerate = portDefinition->format.video.xFramerate;
1016 break;
1017 }
1018 default: {
1019 omx_err_f("index is large than supportFormat_0");
1020 ret = OMX_ErrorNoMore;
1021 goto EXIT;
1022 }
1023 }
1024 } else if (portIndex == OUTPUT_PORT_INDEX) {
1025 supportFormatNum = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
1026 if (index > supportFormatNum) {
1027 omx_err_f("index is too large");
1028 ret = OMX_ErrorNoMore;
1029 goto EXIT;
1030 }
1031
1032 pRockchipPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
1033 portDefinition = &pRockchipPort->portDefinition;
1034
1035 portFormat->eCompressionFormat = portDefinition->format.video.eCompressionFormat;
1036 portFormat->eColorFormat = portDefinition->format.video.eColorFormat;
1037 portFormat->xFramerate = portDefinition->format.video.xFramerate;
1038 }
1039 ret = OMX_ErrorNone;
1040 }
1041 break;
1042 #ifdef OHOS_BUFFER_HANDLE
1043 case OMX_IndexParamSupportBufferType: {
1044 struct SupportBufferType *bufferTyps = (struct SupportBufferType *)ComponentParameterStructure;
1045 if (bufferTyps == NULL) {
1046 omx_err_f("bufferTyps is null");
1047 ret = OMX_ErrorBadParameter;
1048 goto EXIT;
1049 }
1050 OMX_U32 portIndex = bufferTyps->portIndex;
1051 if (portIndex >= pRockchipComponent->portParam.nPorts) {
1052 ret = OMX_ErrorBadPortIndex;
1053 goto EXIT;
1054 }
1055 ret = Rockchip_OMX_Check_SizeVersion(bufferTyps, sizeof(struct SupportBufferType));
1056 if (ret != OMX_ErrorNone) {
1057 goto EXIT;
1058 }
1059 bufferTyps->bufferTypes = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
1060 if (portIndex == INPUT_PORT_INDEX) {
1061 bufferTyps->bufferTypes |= CODEC_BUFFER_TYPE_DYNAMIC_HANDLE;
1062 }
1063 break;
1064 }
1065 case OMX_IndexParamGetBufferHandleUsage: {
1066 struct GetBufferHandleUsageParams *usage = (struct GetBufferHandleUsageParams *)ComponentParameterStructure;
1067 if (usage == NULL) {
1068 omx_err_f("usage is null");
1069 ret = OMX_ErrorBadParameter;
1070 goto EXIT;
1071 }
1072 OMX_U32 portIndex = usage->portIndex;
1073
1074 if (portIndex >= pRockchipComponent->portParam.nPorts || portIndex == OUTPUT_PORT_INDEX) {
1075 ret = OMX_ErrorBadPortIndex;
1076 goto EXIT;
1077 }
1078
1079 ret = Rockchip_OMX_Check_SizeVersion(usage, sizeof(struct GetBufferHandleUsageParams));
1080 if (ret != OMX_ErrorNone) {
1081 goto EXIT;
1082 }
1083 usage->usage = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA;
1084 break;
1085 }
1086 case OMX_IndexCodecVideoPortFormat: {
1087 struct CodecVideoPortFormatParam *videoFormat =
1088 (struct CodecVideoPortFormatParam *)ComponentParameterStructure;
1089 if (videoFormat == NULL) {
1090 omx_err_f("videoFormat is null");
1091 ret = OMX_ErrorBadParameter;
1092 goto EXIT;
1093 }
1094 OMX_U32 portIndex = videoFormat->portIndex;
1095 if (portIndex >= pRockchipComponent->portParam.nPorts) {
1096 ret = OMX_ErrorBadPortIndex;
1097 goto EXIT;
1098 }
1099
1100 ret = Rockchip_OMX_Check_SizeVersion(videoFormat, sizeof(struct CodecVideoPortFormatParam));
1101 if (ret != OMX_ErrorNone) {
1102 goto EXIT;
1103 }
1104 ROCKCHIP_OMX_BASEPORT *pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1105 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = &pRockchipPort->portDefinition;
1106 uint32_t index = videoFormat->codecColorIndex;
1107 if (portIndex == INPUT_PORT_INDEX) {
1108 switch (index) {
1109 case supportFormat_0: {
1110 videoFormat->codecColorFormat =
1111 Rockchip_OSAL_OmxColorFormat2CodecFormat(OMX_COLOR_FormatYUV420SemiPlanar);
1112 break;
1113 }
1114 case supportFormat_1: {
1115 videoFormat->codecColorFormat =
1116 Rockchip_OSAL_OmxColorFormat2CodecFormat((OMX_COLOR_FORMATTYPE)CODEC_COLOR_FORMAT_RGBA8888);
1117 break;
1118 }
1119 case supportFormat_2: {
1120 videoFormat->codecColorFormat =
1121 Rockchip_OSAL_OmxColorFormat2CodecFormat(OMX_COLOR_Format32bitBGRA8888);
1122 break;
1123 }
1124 default: {
1125 omx_err_f("index is large than supportFormat_0");
1126 ret = OMX_ErrorNoMore;
1127 goto EXIT;
1128 }
1129 }
1130 videoFormat->codecCompressFormat = OMX_VIDEO_CodingUnused;
1131 videoFormat->framerate = portDefinition->format.video.xFramerate;
1132 } else {
1133 if (index > supportFormat_0) {
1134 omx_err_f("index is too large");
1135 ret = OMX_ErrorNoMore;
1136 goto EXIT;
1137 }
1138 videoFormat->codecColorFormat =
1139 Rockchip_OSAL_OmxColorFormat2CodecFormat(portDefinition->format.video.eColorFormat);
1140 videoFormat->framerate = portDefinition->format.video.xFramerate;
1141 videoFormat->codecCompressFormat = portDefinition->format.video.eCompressionFormat;
1142 }
1143 ret = OMX_ErrorNone;
1144 } break;
1145 #endif // OHOS_BUFFER_HANDLE
1146 case OMX_IndexParamVideoBitrate: {
1147 OMX_VIDEO_PARAM_BITRATETYPE *videoRateControl = (OMX_VIDEO_PARAM_BITRATETYPE *)ComponentParameterStructure;
1148 OMX_U32 portIndex = videoRateControl->nPortIndex;
1149 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1150 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1151 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
1152
1153 if ((portIndex != OUTPUT_PORT_INDEX)) {
1154 ret = OMX_ErrorBadPortIndex;
1155 goto EXIT;
1156 } else {
1157 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1158 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1159 portDefinition = &pRockchipPort->portDefinition;
1160 videoRateControl->eControlRate = pVideoEnc->eControlRate[portIndex];
1161 videoRateControl->nTargetBitrate = portDefinition->format.video.nBitrate;
1162 }
1163 ret = OMX_ErrorNone;
1164 break;
1165 }
1166 case OMX_IndexParamVideoQuantization: {
1167 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *videoQuantizationControl =
1168 (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)ComponentParameterStructure;
1169 OMX_U32 portIndex = videoQuantizationControl->nPortIndex;
1170 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1171 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1172 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
1173
1174 if ((portIndex != OUTPUT_PORT_INDEX)) {
1175 omx_err_f("portIndex is %d", portIndex);
1176 ret = OMX_ErrorBadPortIndex;
1177 goto EXIT;
1178 } else {
1179 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1180 if (pVideoEnc != NULL) {
1181 videoQuantizationControl->nQpI = pVideoEnc->quantization.nQpI;
1182 videoQuantizationControl->nQpP = pVideoEnc->quantization.nQpP;
1183 videoQuantizationControl->nQpB = pVideoEnc->quantization.nQpB;
1184 }
1185 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1186 portDefinition = &pRockchipPort->portDefinition;
1187 }
1188 ret = OMX_ErrorNone;
1189 break;
1190 }
1191 case OMX_IndexParamPortDefinition: {
1192 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
1193 OMX_U32 portIndex = portDefinition->nPortIndex;
1194 ROCKCHIP_OMX_BASEPORT *pRockchipPort;
1195 if (portIndex >= pRockchipComponent->portParam.nPorts) {
1196 omx_err_f("portIndex is %d", portIndex);
1197 ret = OMX_ErrorBadPortIndex;
1198 goto EXIT;
1199 }
1200 ret = Rockchip_OMX_Check_SizeVersion(portDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1201 if (ret != OMX_ErrorNone) {
1202 omx_err_f("check version ret err");
1203 goto EXIT;
1204 }
1205
1206 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1207 Rockchip_OSAL_Memcpy(portDefinition, &pRockchipPort->portDefinition, portDefinition->nSize);
1208 break;
1209 }
1210 case OMX_IndexParamVideoIntraRefresh: {
1211 OMX_VIDEO_PARAM_INTRAREFRESHTYPE *pIntraRefresh =
1212 (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)ComponentParameterStructure;
1213 OMX_U32 portIndex = pIntraRefresh->nPortIndex;
1214 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1215
1216 if (portIndex != OUTPUT_PORT_INDEX) {
1217 omx_err_f("portIndex is %d", portIndex);
1218 ret = OMX_ErrorBadPortIndex;
1219 goto EXIT;
1220 } else {
1221 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1222 pIntraRefresh->eRefreshMode = pVideoEnc->intraRefresh.eRefreshMode;
1223 pIntraRefresh->nAirMBs = pVideoEnc->intraRefresh.nAirMBs;
1224 pIntraRefresh->nAirRef = pVideoEnc->intraRefresh.nAirRef;
1225 pIntraRefresh->nCirMBs = pVideoEnc->intraRefresh.nCirMBs;
1226 }
1227 ret = OMX_ErrorNone;
1228 break;
1229 }
1230 case OMX_IndexParamStandardComponentRole: {
1231 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)ComponentParameterStructure;
1232 ret = Rockchip_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1233 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc =
1234 (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1235 if (ret != OMX_ErrorNone) {
1236 omx_err_f("check version ret err");
1237 goto EXIT;
1238 }
1239 if (pVideoEnc->codecId == OMX_VIDEO_CodingAVC) {
1240 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_H264_ENC_ROLE);
1241 } else if (pVideoEnc->codecId == OMX_VIDEO_CodingVP8EXT) {
1242 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_VP8_ENC_ROLE);
1243 } else if (pVideoEnc->codecId == CODEC_OMX_VIDEO_CodingHEVC) {
1244 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_HEVC_ENC_ROLE);
1245 }
1246 }
1247 break;
1248 case OMX_IndexParamVideoAvc: {
1249 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)ComponentParameterStructure;
1250 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
1251 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc =
1252 (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1253
1254 ret = Rockchip_OMX_Check_SizeVersion(pDstAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1255 if (ret != OMX_ErrorNone) {
1256 goto EXIT;
1257 }
1258
1259 if (pDstAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1260 ret = OMX_ErrorBadPortIndex;
1261 goto EXIT;
1262 }
1263
1264 pSrcAVCComponent = &pVideoEnc->AVCComponent[pDstAVCComponent->nPortIndex];
1265 Rockchip_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1266 }
1267 break;
1268 case OMX_IndexParamVideoHevc: {
1269 struct CodecVideoParamHevc *pDstHEVCComponent = (struct CodecVideoParamHevc *)ComponentParameterStructure;
1270 struct CodecVideoParamHevc *pSrcHEVCComponent = NULL;
1271 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc =
1272 (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1273
1274 ret = Rockchip_OMX_Check_SizeVersion(pDstHEVCComponent, sizeof(struct CodecVideoParamHevc));
1275 if (ret != OMX_ErrorNone) {
1276 goto EXIT;
1277 }
1278
1279 if (pDstHEVCComponent->portIndex >= ALL_PORT_NUM) {
1280 ret = OMX_ErrorBadPortIndex;
1281 goto EXIT;
1282 }
1283
1284 pSrcHEVCComponent = &pVideoEnc->HEVCComponent[pDstHEVCComponent->portIndex];
1285 Rockchip_OSAL_Memcpy(pDstHEVCComponent, pSrcHEVCComponent, sizeof(struct CodecVideoParamHevc));
1286 }
1287 break;
1288 case OMX_IndexParamVideoProfileLevelQuerySupported: {
1289 OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevel =
1290 (OMX_VIDEO_PARAM_PROFILELEVELTYPE *) ComponentParameterStructure;
1291 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc =
1292 (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1293
1294 OMX_U32 index = profileLevel->nProfileIndex;
1295 OMX_U32 nProfileLevels = 0;
1296 if (profileLevel->nPortIndex >= ALL_PORT_NUM) {
1297 omx_err("Invalid port index: %ld", profileLevel->nPortIndex);
1298 ret = OMX_ErrorUnsupportedIndex;
1299 goto EXIT;
1300 }
1301 if (pVideoEnc->codecId == OMX_VIDEO_CodingAVC) {
1302 nProfileLevels = ARRAY_SIZE(kProfileLevels);
1303 if (index >= nProfileLevels) {
1304 ret = OMX_ErrorNoMore;
1305 goto EXIT;
1306 }
1307 profileLevel->eProfile = kProfileLevels[index].mProfile;
1308 profileLevel->eLevel = kProfileLevels[index].mLevel;
1309 } else if (pVideoEnc->codecId == CODEC_OMX_VIDEO_CodingHEVC) {
1310 nProfileLevels = ARRAY_SIZE(kH265ProfileLevels);
1311 if (index >= nProfileLevels) {
1312 ret = OMX_ErrorNoMore;
1313 goto EXIT;
1314 }
1315 profileLevel->eProfile = kH265ProfileLevels[index].mProfile;
1316 profileLevel->eLevel = kH265ProfileLevels[index].mLevel;
1317 } else {
1318 ret = OMX_ErrorNoMore;
1319 goto EXIT;
1320 }
1321 ret = OMX_ErrorNone;
1322 }
1323 break;
1324 case OMX_IndexParamRkEncExtendedVideo: {
1325 OMX_VIDEO_PARAMS_EXTENDED *params_extend = (OMX_VIDEO_PARAMS_EXTENDED *)ComponentParameterStructure;
1326 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc =
1327 (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1328 omx_trace("get OMX_IndexParamRkEncExtendedVideo in ");
1329 Rockchip_OSAL_MutexLock(pVideoEnc->bScale_Mutex);
1330 Rockchip_OSAL_Memcpy(params_extend, &pVideoEnc->params_extend, sizeof(OMX_VIDEO_PARAMS_EXTENDED));
1331 Rockchip_OSAL_MutexUnlock(pVideoEnc->bScale_Mutex);
1332 }
1333 break;
1334 default: {
1335 ret = Rockchip_OMX_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
1336 break;
1337 }
1338 }
1339 EXIT:
1340 FunctionOut();
1341 return ret;
1342 }
Rkvpu_OMX_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nIndex,OMX_IN OMX_PTR ComponentParameterStructure)1343 OMX_ERRORTYPE Rkvpu_OMX_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,
1344 OMX_IN OMX_INDEXTYPE nIndex, OMX_IN OMX_PTR ComponentParameterStructure)
1345 {
1346 OMX_ERRORTYPE ret = OMX_ErrorNone;
1347 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1348 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
1349 FunctionIn();
1350 if (hComponent == NULL) {
1351 omx_err_f("hComponent is null");
1352 ret = OMX_ErrorBadParameter;
1353 goto EXIT;
1354 }
1355 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1356 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1357 if (ret != OMX_ErrorNone) {
1358 omx_err_f("check version ret err");
1359 goto EXIT;
1360 }
1361
1362 if (pOMXComponent->pComponentPrivate == NULL) {
1363 omx_err_f("pComponentPrivate is null");
1364 ret = OMX_ErrorBadParameter;
1365 goto EXIT;
1366 }
1367 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1368
1369 if (pRockchipComponent->currentState == OMX_StateInvalid) {
1370 omx_err_f("currentState == OMX_StateInvalid");
1371 ret = OMX_ErrorInvalidState;
1372 goto EXIT;
1373 }
1374
1375 if (ComponentParameterStructure == NULL) {
1376 omx_err_f("ComponentParameterStructure is null");
1377 ret = OMX_ErrorBadParameter;
1378 goto EXIT;
1379 }
1380
1381 switch ((OMX_U32)nIndex) {
1382 case OMX_IndexParamVideoPortFormat: {
1383 OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
1384 OMX_U32 portIndex = portFormat->nPortIndex;
1385 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1386 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
1387
1388 ret = Rockchip_OMX_Check_SizeVersion(portFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1389 if (ret != OMX_ErrorNone) {
1390 omx_err_f("check version ret err");
1391 goto EXIT;
1392 }
1393
1394 if ((portIndex >= pRockchipComponent->portParam.nPorts)) {
1395 omx_err_f("portIndex is %d", portIndex);
1396 ret = OMX_ErrorBadPortIndex;
1397 goto EXIT;
1398 } else {
1399 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1400 portDefinition = &pRockchipPort->portDefinition;
1401 portDefinition->format.video.eColorFormat = portFormat->eColorFormat;
1402 portDefinition->format.video.eCompressionFormat = portFormat->eCompressionFormat;
1403 portDefinition->format.video.xFramerate = portFormat->xFramerate;
1404 }
1405 ret = OMX_ErrorNone;
1406 break;
1407 }
1408 case OMX_IndexParamVideoBitrate: {
1409 OMX_VIDEO_PARAM_BITRATETYPE *videoRateControl =
1410 (OMX_VIDEO_PARAM_BITRATETYPE *)ComponentParameterStructure;
1411 OMX_U32 portIndex = videoRateControl->nPortIndex;
1412 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1413 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1414 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
1415 if ((portIndex != OUTPUT_PORT_INDEX)) {
1416 omx_err_f("portIndex is %d", portIndex);
1417 ret = OMX_ErrorBadPortIndex;
1418 goto EXIT;
1419 } else {
1420 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1421 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1422 portDefinition = &pRockchipPort->portDefinition;
1423 pVideoEnc->eControlRate[portIndex] = videoRateControl->eControlRate;
1424 portDefinition->format.video.nBitrate = videoRateControl->nTargetBitrate;
1425 }
1426 ret = OMX_ErrorNone;
1427 break;
1428 }
1429 case OMX_IndexParamVideoQuantization: {
1430 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *videoQuantizationControl =
1431 (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)ComponentParameterStructure;
1432 OMX_U32 portIndex = videoQuantizationControl->nPortIndex;
1433 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1434 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1435 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
1436
1437 if ((portIndex != OUTPUT_PORT_INDEX)) {
1438 omx_err_f("portIndex is %d", portIndex);
1439 ret = OMX_ErrorBadPortIndex;
1440 goto EXIT;
1441 } else {
1442 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1443 if (pVideoEnc != NULL) {
1444 pVideoEnc->quantization.nQpI = videoQuantizationControl->nQpI;
1445 pVideoEnc->quantization.nQpP = videoQuantizationControl->nQpP;
1446 pVideoEnc->quantization.nQpB = videoQuantizationControl->nQpB;
1447 }
1448 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1449 portDefinition = &pRockchipPort->portDefinition;
1450 }
1451 ret = OMX_ErrorNone;
1452 break;
1453 }
1454 case OMX_IndexParamPortDefinition: {
1455 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition =
1456 (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
1457 OMX_U32 portIndex = pPortDefinition->nPortIndex;
1458 ROCKCHIP_OMX_BASEPORT *pRockchipPort;
1459 if (portIndex >= pRockchipComponent->portParam.nPorts) {
1460 omx_err_f("portIndex is %d", portIndex);
1461 ret = OMX_ErrorBadPortIndex;
1462 goto EXIT;
1463 }
1464 ret = Rockchip_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1465 if (ret != OMX_ErrorNone) {
1466 omx_err_f("check version ret err");
1467 goto EXIT;
1468 }
1469
1470 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1471
1472 if ((pRockchipComponent->currentState != OMX_StateLoaded) &&
1473 (pRockchipComponent->currentState != OMX_StateWaitForResources)) {
1474 if (pRockchipPort->portDefinition.bEnabled == OMX_TRUE) {
1475 omx_err_f("portDefinition.bEnabled is OMX_TRUE");
1476 ret = OMX_ErrorIncorrectStateOperation;
1477 goto EXIT;
1478 }
1479 }
1480 if (pPortDefinition->nBufferCountActual < pRockchipPort->portDefinition.nBufferCountMin) {
1481 omx_err_f("nBufferCountActual < nBufferCountMin");
1482 ret = OMX_ErrorBadParameter;
1483 goto EXIT;
1484 }
1485
1486 Rockchip_OSAL_Memcpy(&pRockchipPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1487 if (portIndex == INPUT_PORT_INDEX) {
1488 ROCKCHIP_OMX_BASEPORT *pRockchipOutputPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
1489 UpdateFrameSize(pOMXComponent);
1490 omx_trace("pRockchipOutputPort->portDefinition.nBufferSize: %lu",
1491 pRockchipOutputPort->portDefinition.nBufferSize);
1492 }
1493 ret = OMX_ErrorNone;
1494 break;
1495 }
1496 case OMX_IndexParamVideoIntraRefresh: {
1497 OMX_VIDEO_PARAM_INTRAREFRESHTYPE *pIntraRefresh =
1498 (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)ComponentParameterStructure;
1499 OMX_U32 portIndex = pIntraRefresh->nPortIndex;
1500 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1501
1502 if (portIndex != OUTPUT_PORT_INDEX) {
1503 ret = OMX_ErrorBadPortIndex;
1504 goto EXIT;
1505 } else {
1506 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1507 if (pIntraRefresh->eRefreshMode == OMX_VIDEO_IntraRefreshCyclic) {
1508 pVideoEnc->intraRefresh.eRefreshMode = pIntraRefresh->eRefreshMode;
1509 pVideoEnc->intraRefresh.nCirMBs = pIntraRefresh->nCirMBs;
1510 omx_trace("OMX_VIDEO_IntraRefreshCyclic Enable, nCirMBs: %lu",
1511 pVideoEnc->intraRefresh.nCirMBs);
1512 } else {
1513 ret = OMX_ErrorUnsupportedSetting;
1514 goto EXIT;
1515 }
1516 }
1517 ret = OMX_ErrorNone;
1518 break;
1519 }
1520 #ifdef OHOS_BUFFER_HANDLE
1521 case OMX_IndexParamUseBufferType: {
1522 omx_info("OMX_IndexParamUseBufferType");
1523 struct UseBufferType *bufferType = (struct UseBufferType *)ComponentParameterStructure;
1524 if (bufferType == NULL) {
1525 omx_err_f("bufferType is null");
1526 ret = OMX_ErrorBadParameter;
1527 goto EXIT;
1528 }
1529 OMX_U32 portIndex = bufferType->portIndex;
1530 if (portIndex >= pRockchipComponent->portParam.nPorts) {
1531 ret = OMX_ErrorBadPortIndex;
1532 goto EXIT;
1533 }
1534 ret = Rockchip_OMX_Check_SizeVersion(bufferType, sizeof(struct UseBufferType));
1535 if (ret != OMX_ErrorNone) {
1536 goto EXIT;
1537 }
1538 if (((bufferType->bufferType & CODEC_BUFFER_TYPE_DYNAMIC_HANDLE) == CODEC_BUFFER_TYPE_DYNAMIC_HANDLE) &&
1539 portIndex == INPUT_PORT_INDEX) {
1540 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc =
1541 (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1542 pVideoEnc->bOhosDynamicBuffer = OMX_TRUE;
1543 }
1544 break;
1545 }
1546 case OMX_IndexCodecVideoPortFormat: {
1547 struct CodecVideoPortFormatParam *videoFormat =
1548 (struct CodecVideoPortFormatParam *)ComponentParameterStructure;
1549 if (videoFormat == NULL) {
1550 omx_err_f("videoFormat is null");
1551 ret = OMX_ErrorBadParameter;
1552 goto EXIT;
1553 }
1554 OMX_U32 portIndex = videoFormat->portIndex;
1555 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1556 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
1557
1558 ret = Rockchip_OMX_Check_SizeVersion(videoFormat, sizeof(struct CodecVideoPortFormatParam));
1559 if (ret != OMX_ErrorNone) {
1560 goto EXIT;
1561 }
1562
1563 if ((portIndex >= pRockchipComponent->portParam.nPorts)) {
1564 ret = OMX_ErrorBadPortIndex;
1565 goto EXIT;
1566 } else {
1567 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1568 portDefinition = &pRockchipPort->portDefinition;
1569 portDefinition->format.video.eColorFormat =
1570 Rochip_OSAL_CodecFormat2OmxColorFormat(videoFormat->codecColorFormat);
1571 portDefinition->format.video.eCompressionFormat = videoFormat->codecCompressFormat;
1572 portDefinition->format.video.xFramerate = videoFormat->framerate;
1573 }
1574 ret = OMX_ErrorNone;
1575 break;
1576 }
1577 #endif
1578 #ifdef USE_STOREMETADATA
1579 case OMX_IndexParamStoreANWBuffer:
1580 case OMX_IndexParamStoreMetaDataBuffer: {
1581 ret = Rockchip_OSAL_SetANBParameter(hComponent, nIndex, ComponentParameterStructure);
1582 }
1583 break;
1584 #endif
1585 case OMX_IndexParamPrependSPSPPSToIDR: {
1586 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1587 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1588 ret = Rockchip_OSAL_SetPrependSPSPPSToIDR(ComponentParameterStructure, &pVideoEnc->bPrependSpsPpsToIdr);
1589 break;
1590 }
1591 case OMX_IndexRkEncExtendedWfdState: {
1592 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1593 pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1594 ROCKCHIP_OMX_WFD *pRkWFD = (ROCKCHIP_OMX_WFD*)ComponentParameterStructure;
1595 pVideoEnc->bRkWFD = pRkWFD->bEnable;
1596 omx_trace("OMX_IndexRkEncExtendedWfdState set as:%d", pRkWFD->bEnable);
1597 ret = OMX_ErrorNone;
1598 break;
1599 }
1600 case OMX_IndexParamStandardComponentRole: {
1601 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)ComponentParameterStructure;
1602
1603 ret = Rockchip_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1604 if (ret != OMX_ErrorNone) {
1605 goto EXIT;
1606 }
1607
1608 if ((pRockchipComponent->currentState != OMX_StateLoaded) && (pRockchipComponent->currentState !=
1609 OMX_StateWaitForResources)) {
1610 ret = OMX_ErrorIncorrectStateOperation;
1611 goto EXIT;
1612 }
1613
1614 if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_H264_ENC_ROLE)) {
1615 pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1616 OMX_VIDEO_CodingAVC;
1617 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_VP8_ENC_ROLE)) {
1618 pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1619 (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingVP8EXT;
1620 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_HEVC_ENC_ROLE)) {
1621 pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1622 (OMX_VIDEO_CODINGTYPE)CODEC_OMX_VIDEO_CodingHEVC;
1623 } else {
1624 ret = OMX_ErrorInvalidComponentName;
1625 goto EXIT;
1626 }
1627 break;
1628 }
1629 case OMX_IndexParamVideoAvc: {
1630 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
1631 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)ComponentParameterStructure;
1632 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc =
1633 (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1634 ret = Rockchip_OMX_Check_SizeVersion(pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1635 if (ret != OMX_ErrorNone) {
1636 goto EXIT;
1637 }
1638 if (pSrcAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1639 ret = OMX_ErrorBadPortIndex;
1640 goto EXIT;
1641 }
1642
1643 pDstAVCComponent = &pVideoEnc->AVCComponent[pSrcAVCComponent->nPortIndex];
1644
1645 Rockchip_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1646 break;
1647 }
1648 case OMX_IndexParamVideoHevc: {
1649 struct CodecVideoParamHevc *pDstHEVCComponent = NULL;
1650 struct CodecVideoParamHevc *pSrcHEVCComponent = (struct CodecVideoParamHevc *)ComponentParameterStructure;
1651 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc =
1652 (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1653 ret = Rockchip_OMX_Check_SizeVersion(pSrcHEVCComponent, sizeof(struct CodecVideoParamHevc));
1654 if (ret != OMX_ErrorNone) {
1655 goto EXIT;
1656 }
1657 if (pSrcHEVCComponent->portIndex >= ALL_PORT_NUM) {
1658 ret = OMX_ErrorBadPortIndex;
1659 goto EXIT;
1660 }
1661
1662 pDstHEVCComponent = &pVideoEnc->HEVCComponent[pSrcHEVCComponent->portIndex];
1663 Rockchip_OSAL_Memcpy(pDstHEVCComponent, pSrcHEVCComponent, sizeof(struct CodecVideoParamHevc));
1664 break;
1665 }
1666 case OMX_IndexParamRkEncExtendedVideo: {
1667 OMX_VIDEO_PARAMS_EXTENDED *params_extend = (OMX_VIDEO_PARAMS_EXTENDED *)ComponentParameterStructure;
1668 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc =
1669 (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1670
1671 omx_trace("OMX_IndexParamRkEncExtendedVideo in ");
1672 if (ret != OMX_ErrorNone) {
1673 goto EXIT;
1674 }
1675 Rockchip_OSAL_MutexLock(pVideoEnc->bScale_Mutex);
1676 Rockchip_OSAL_Memcpy(&pVideoEnc->params_extend, params_extend, sizeof(OMX_VIDEO_PARAMS_EXTENDED));
1677 omx_trace("OMX_IndexParamRkEncExtendedVideo in flags %lu bEableCrop %d,cl %d cr %d ct %d cb %d, \
1678 bScaling %d ScaleW %d ScaleH %d",
1679 pVideoEnc->params_extend.ui32Flags, pVideoEnc->params_extend.bEnableCropping,
1680 pVideoEnc->params_extend.ui16CropLeft, pVideoEnc->params_extend.ui16CropRight,
1681 pVideoEnc->params_extend.ui16CropTop, pVideoEnc->params_extend.ui16CropBottom,
1682 pVideoEnc->params_extend.bEnableScaling,
1683 pVideoEnc->params_extend.ui16ScaledWidth, pVideoEnc->params_extend.ui16ScaledHeight);
1684 Rockchip_OSAL_MutexUnlock(pVideoEnc->bScale_Mutex);
1685 break;
1686 }
1687 default: {
1688 ret = Rockchip_OMX_SetParameter(hComponent, nIndex, ComponentParameterStructure);
1689 break;
1690 }
1691 }
1692 EXIT:
1693 FunctionOut();
1694 return ret;
1695 }
Rkvpu_OMX_GetExConfig(RKVPU_OMX_VIDEOENC_COMPONENT * pVideoEnc,OMX_HANDLETYPE hComponent,OMX_INDEXEXEXTTYPE nIndex,OMX_PTR pComponentConfigStructure)1696 static OMX_ERRORTYPE Rkvpu_OMX_GetExConfig(RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc, OMX_HANDLETYPE hComponent,
1697 OMX_INDEXEXEXTTYPE nIndex, OMX_PTR pComponentConfigStructure)
1698 {
1699 OMX_ERRORTYPE ret = OMX_ErrorNone;
1700 switch (nIndex) {
1701 #ifdef AVS80
1702 case OMX_IndexParamRkDescribeColorAspects: {
1703 OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS *pParam =
1704 (OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS *)pComponentConfigStructure;
1705 if (pParam->bRequestingDataSpace) {
1706 pParam->sAspects.mPrimaries = PrimariesUnspecified;
1707 pParam->sAspects.mRange = RangeUnspecified;
1708 pParam->sAspects.mTransfer = TransferUnspecified;
1709 pParam->sAspects.mMatrixCoeffs = MatrixUnspecified;
1710 return ret; // OMX_ErrorUnsupportedSetting;
1711 }
1712 if (pParam->bDataSpaceChanged == OMX_TRUE) {
1713 // If the dataspace says RGB, recommend 601-limited;
1714 // since that is the destination colorspace that C2D or Venus will convert to.
1715 if (pParam->nPixelFormat == HAL_PIXEL_FORMAT_RGBA_8888) {
1716 Rockchip_OSAL_Memcpy(pParam, &pVideoEnc->ConfigColorAspects,
1717 sizeof(OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS));
1718 pParam->sAspects.mPrimaries = PrimariesUnspecified;
1719 pParam->sAspects.mRange = RangeUnspecified;
1720 pParam->sAspects.mTransfer = TransferUnspecified;
1721 pParam->sAspects.mMatrixCoeffs = MatrixUnspecified;
1722 } else {
1723 Rockchip_OSAL_Memcpy(pParam,
1724 &pVideoEnc->ConfigColorAspects, sizeof(OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS));
1725 }
1726 } else {
1727 Rockchip_OSAL_Memcpy(pParam,
1728 &pVideoEnc->ConfigColorAspects, sizeof(OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS));
1729 }
1730 break;
1731 }
1732 #endif
1733 default:
1734 ret = Rockchip_OMX_GetConfig(hComponent, (OMX_INDEXTYPE)nIndex, pComponentConfigStructure);
1735 break;
1736 }
1737 return ret;
1738 }
1739
Rkvpu_OMX_GetConfig(OMX_HANDLETYPE hComponent,OMX_INDEXTYPE nIndex,OMX_PTR pComponentConfigStructure)1740 OMX_ERRORTYPE Rkvpu_OMX_GetConfig(
1741 OMX_HANDLETYPE hComponent,
1742 OMX_INDEXTYPE nIndex,
1743 OMX_PTR pComponentConfigStructure)
1744 {
1745 OMX_ERRORTYPE ret = OMX_ErrorNone;
1746 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1747 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
1748 FunctionIn();
1749 if (hComponent == NULL) {
1750 omx_err_f("hComponent is null");
1751 ret = OMX_ErrorBadParameter;
1752 goto EXIT;
1753 }
1754 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1755 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1756 if (ret != OMX_ErrorNone) {
1757 omx_err_f("check version ret err");
1758 goto EXIT;
1759 }
1760 if (pOMXComponent->pComponentPrivate == NULL) {
1761 omx_err_f("pComponentPrivate is null");
1762 ret = OMX_ErrorBadParameter;
1763 goto EXIT;
1764 }
1765 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1766 if (pComponentConfigStructure == NULL) {
1767 omx_err_f("pComponentConfigStructure is null");
1768 ret = OMX_ErrorBadParameter;
1769 goto EXIT;
1770 }
1771 if (pRockchipComponent->currentState == OMX_StateInvalid) {
1772 omx_err_f("currentState is OMX_StateInvalid");
1773 ret = OMX_ErrorInvalidState;
1774 goto EXIT;
1775 }
1776 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1777
1778 switch (nIndex) {
1779 case OMX_IndexConfigVideoAVCIntraPeriod: {
1780 OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pAVCIntraPeriod =
1781 (OMX_VIDEO_CONFIG_AVCINTRAPERIOD *)pComponentConfigStructure;
1782 OMX_U32 portIndex = pAVCIntraPeriod->nPortIndex;
1783
1784 if ((portIndex != OUTPUT_PORT_INDEX)) {
1785 ret = OMX_ErrorBadPortIndex;
1786 goto EXIT;
1787 } else {
1788 pAVCIntraPeriod->nIDRPeriod = pVideoEnc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames + 1;
1789 pAVCIntraPeriod->nPFrames = pVideoEnc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames;
1790 }
1791 }
1792 break;
1793 case OMX_IndexConfigVideoBitrate: {
1794 OMX_VIDEO_CONFIG_BITRATETYPE *pEncodeBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1795 OMX_U32 portIndex = pEncodeBitrate->nPortIndex;
1796 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1797
1798 if ((portIndex != OUTPUT_PORT_INDEX)) {
1799 ret = OMX_ErrorBadPortIndex;
1800 goto EXIT;
1801 } else {
1802 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1803 pEncodeBitrate->nEncodeBitrate = pRockchipPort->portDefinition.format.video.nBitrate;
1804 }
1805 }
1806 break;
1807 case OMX_IndexConfigVideoFramerate: {
1808 OMX_CONFIG_FRAMERATETYPE *pFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1809 OMX_U32 portIndex = pFramerate->nPortIndex;
1810 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1811
1812 if ((portIndex != OUTPUT_PORT_INDEX)) {
1813 ret = OMX_ErrorBadPortIndex;
1814 goto EXIT;
1815 } else {
1816 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1817 pFramerate->xEncodeFramerate = pRockchipPort->portDefinition.format.video.xFramerate;
1818 }
1819 break;
1820 }
1821 default:
1822 ret = Rkvpu_OMX_GetExConfig(pVideoEnc, hComponent, (OMX_INDEXEXEXTTYPE)nIndex, pComponentConfigStructure);
1823 break;
1824 }
1825 EXIT:
1826 FunctionOut();
1827 return ret;
1828 }
1829
Rkvpu_OMX_SetConfig(OMX_HANDLETYPE hComponent,OMX_INDEXTYPE nIndex,OMX_PTR pComponentConfigStructure)1830 OMX_ERRORTYPE Rkvpu_OMX_SetConfig(OMX_HANDLETYPE hComponent, OMX_INDEXTYPE nIndex,
1831 OMX_PTR pComponentConfigStructure)
1832 {
1833 OMX_ERRORTYPE ret = OMX_ErrorNone;
1834 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1835 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
1836 FunctionIn();
1837 if (hComponent == NULL) {
1838 omx_err_f("hComponent is null");
1839 ret = OMX_ErrorBadParameter;
1840 goto EXIT;
1841 }
1842 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1843 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1844 if (ret != OMX_ErrorNone) {
1845 omx_err_f("check size ret err");
1846 goto EXIT;
1847 }
1848 if (pOMXComponent->pComponentPrivate == NULL) {
1849 omx_err_f("pComponentPrivate is null");
1850 ret = OMX_ErrorBadParameter;
1851 goto EXIT;
1852 }
1853 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1854 if (pComponentConfigStructure == NULL) {
1855 omx_err_f("pComponentConfigStructure is null");
1856 ret = OMX_ErrorBadParameter;
1857 goto EXIT;
1858 }
1859 if (pRockchipComponent->currentState == OMX_StateInvalid) {
1860 omx_err_f("currentState is OMX_StateInvalid");
1861 ret = OMX_ErrorInvalidState;
1862 goto EXIT;
1863 }
1864
1865 RKVPU_OMX_VIDEOENC_COMPONENT *pVideoEnc = (RKVPU_OMX_VIDEOENC_COMPONENT *)pRockchipComponent->hComponentHandle;
1866
1867 switch ((OMX_U32)nIndex) {
1868 case OMX_IndexConfigVideoIntraPeriod: {
1869 OMX_U32 nPFrames = (*((OMX_U32 *)pComponentConfigStructure)) - 1;
1870
1871 pVideoEnc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames = nPFrames;
1872
1873 ret = OMX_ErrorNone;
1874 }
1875 break;
1876 case OMX_IndexConfigVideoAVCIntraPeriod: {
1877 OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pAVCIntraPeriod =
1878 (OMX_VIDEO_CONFIG_AVCINTRAPERIOD *)pComponentConfigStructure;
1879 OMX_U32 portIndex = pAVCIntraPeriod->nPortIndex;
1880
1881 if ((portIndex != OUTPUT_PORT_INDEX)) {
1882 ret = OMX_ErrorBadPortIndex;
1883 goto EXIT;
1884 } else {
1885 if (pAVCIntraPeriod->nIDRPeriod == (pAVCIntraPeriod->nPFrames + 1))
1886 pVideoEnc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames = pAVCIntraPeriod->nPFrames;
1887 else {
1888 ret = OMX_ErrorBadParameter;
1889 goto EXIT;
1890 }
1891 }
1892 }
1893 break;
1894 case OMX_IndexConfigVideoBitrate: {
1895 OMX_VIDEO_CONFIG_BITRATETYPE *pEncodeBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1896 OMX_U32 portIndex = pEncodeBitrate->nPortIndex;
1897 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1898 VpuCodecContext_t *p_vpu_ctx = pVideoEnc->vpu_ctx;
1899
1900 if ((portIndex != OUTPUT_PORT_INDEX)) {
1901 ret = OMX_ErrorBadPortIndex;
1902 goto EXIT;
1903 } else {
1904 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1905 pRockchipPort->portDefinition.format.video.nBitrate = pEncodeBitrate->nEncodeBitrate;
1906 if (p_vpu_ctx != NULL) {
1907 EncParameter_t vpug;
1908 p_vpu_ctx->control(p_vpu_ctx, VPU_API_ENC_GETCFG, (void*)&vpug);
1909 vpug.bitRate = pEncodeBitrate->nEncodeBitrate;
1910 omx_err("set bitRate %lu", pEncodeBitrate->nEncodeBitrate);
1911 p_vpu_ctx->control(p_vpu_ctx, VPU_API_ENC_SETCFG, (void*)&vpug);
1912 }
1913 }
1914 }
1915 break;
1916 case OMX_IndexConfigVideoFramerate: {
1917 OMX_CONFIG_FRAMERATETYPE *pFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1918 OMX_U32 portIndex = pFramerate->nPortIndex;
1919 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1920 VpuCodecContext_t *p_vpu_ctx = pVideoEnc->vpu_ctx;
1921
1922 if ((portIndex != OUTPUT_PORT_INDEX)) {
1923 ret = OMX_ErrorBadPortIndex;
1924 goto EXIT;
1925 } else {
1926 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1927 pRockchipPort->portDefinition.format.video.xFramerate = pFramerate->xEncodeFramerate;
1928 }
1929
1930 if (p_vpu_ctx != NULL) {
1931 EncParameter_t vpug;
1932 p_vpu_ctx->control(p_vpu_ctx, VPU_API_ENC_GETCFG, (void*)&vpug);
1933 vpug.framerate = (pFramerate->xEncodeFramerate >> 16); // 16:byte alignment
1934 p_vpu_ctx->control(p_vpu_ctx, VPU_API_ENC_SETCFG, (void*)&vpug);
1935 }
1936 }
1937 break;
1938 case OMX_IndexConfigVideoIntraVOPRefresh: {
1939 OMX_CONFIG_INTRAREFRESHVOPTYPE *pIntraRefreshVOP =
1940 (OMX_CONFIG_INTRAREFRESHVOPTYPE *)pComponentConfigStructure;
1941 OMX_U32 portIndex = pIntraRefreshVOP->nPortIndex;
1942
1943 VpuCodecContext_t *p_vpu_ctx = pVideoEnc->vpu_ctx;
1944
1945 if ((portIndex != OUTPUT_PORT_INDEX)) {
1946 ret = OMX_ErrorBadPortIndex;
1947 goto EXIT;
1948 } else {
1949 pVideoEnc->IntraRefreshVOP = pIntraRefreshVOP->IntraRefreshVOP;
1950 }
1951
1952 if (p_vpu_ctx != NULL && pVideoEnc->IntraRefreshVOP) {
1953 p_vpu_ctx->control(p_vpu_ctx, VPU_API_ENC_SETIDRFRAME, NULL);
1954 }
1955 }
1956 break;
1957 #ifdef AVS80
1958 case OMX_IndexParamRkDescribeColorAspects: {
1959 Rockchip_OSAL_Memcpy(&pVideoEnc->ConfigColorAspects,
1960 pComponentConfigStructure, sizeof(OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS));
1961 pVideoEnc->bIsCfgColorAsp = OMX_TRUE;
1962 }
1963 break;
1964 #endif
1965 default:
1966 ret = Rockchip_OMX_SetConfig(hComponent, nIndex, pComponentConfigStructure);
1967 break;
1968 }
1969
1970 EXIT:
1971 FunctionOut();
1972
1973 return ret;
1974 }
1975
Rkvpu_OMX_ComponentRoleEnum(OMX_HANDLETYPE hComponent,OMX_U8 * cRole,OMX_U32 nIndex)1976 OMX_ERRORTYPE Rkvpu_OMX_ComponentRoleEnum(
1977 OMX_HANDLETYPE hComponent,
1978 OMX_U8 *cRole,
1979 OMX_U32 nIndex)
1980 {
1981 OMX_ERRORTYPE ret = OMX_ErrorNone;
1982
1983 FunctionIn();
1984
1985 if ((hComponent == NULL) || (cRole == NULL)) {
1986 ret = OMX_ErrorBadParameter;
1987 goto EXIT;
1988 }
1989
1990 if (nIndex == 0) {
1991 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_H264_ENC_ROLE);
1992 ret = OMX_ErrorNone;
1993 } else if (nIndex == 1) {
1994 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_VP8_ENC_ROLE);
1995 ret = OMX_ErrorNone;
1996 } else {
1997 ret = OMX_ErrorNoMore;
1998 }
1999 EXIT:
2000 FunctionOut();
2001
2002 return ret;
2003 }
2004
2005
Rkvpu_OMX_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_STRING cParameterName,OMX_OUT OMX_INDEXTYPE * pIndexType)2006 OMX_ERRORTYPE Rkvpu_OMX_GetExtensionIndex(
2007 OMX_IN OMX_HANDLETYPE hComponent,
2008 OMX_IN OMX_STRING cParameterName,
2009 OMX_OUT OMX_INDEXTYPE *pIndexType)
2010 {
2011 OMX_ERRORTYPE ret = OMX_ErrorNone;
2012 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2013 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
2014
2015 FunctionIn();
2016 omx_trace("cParameterName:%s", cParameterName);
2017
2018 if (hComponent == NULL) {
2019 ret = OMX_ErrorBadParameter;
2020 goto EXIT;
2021 }
2022 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2023 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
2024 if (ret != OMX_ErrorNone) {
2025 goto EXIT;
2026 }
2027
2028 if (pOMXComponent->pComponentPrivate == NULL) {
2029 ret = OMX_ErrorBadParameter;
2030 goto EXIT;
2031 }
2032 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2033
2034 if ((cParameterName == NULL) || (pIndexType == NULL)) {
2035 ret = OMX_ErrorBadParameter;
2036 goto EXIT;
2037 }
2038 if (pRockchipComponent->currentState == OMX_StateInvalid) {
2039 ret = OMX_ErrorInvalidState;
2040 goto EXIT;
2041 }
2042
2043 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_CONFIG_VIDEO_INTRAPERIOD) == 0) {
2044 *pIndexType = (OMX_INDEXTYPE)OMX_IndexConfigVideoIntraPeriod;
2045 ret = OMX_ErrorNone;
2046 goto EXIT;
2047 } else if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_PREPEND_SPSPPS_TO_IDR) == 0) {
2048 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamPrependSPSPPSToIDR;
2049 ret = OMX_ErrorNone;
2050 goto EXIT;
2051 } else if (!Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_RKWFD)) {
2052 *pIndexType = (OMX_INDEXTYPE)OMX_IndexRkEncExtendedWfdState;
2053 ret = OMX_ErrorNone;
2054 goto EXIT;
2055 } else if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_EXTENDED_VIDEO) == 0) {
2056
2057 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamRkEncExtendedVideo;
2058 ret = OMX_ErrorNone;
2059 }
2060 #ifdef AVS80
2061 else if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_DSECRIBECOLORASPECTS) == 0) {
2062 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamRkDescribeColorAspects;
2063 goto EXIT;
2064 }
2065 #endif
2066 #ifdef USE_STOREMETADATA
2067 else if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_STORE_ANW_BUFFER) == 0) {
2068 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamStoreANWBuffer;
2069 ret = OMX_ErrorNone;
2070 } else if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
2071 *pIndexType = (OMX_INDEXTYPE) OMX_IndexParamStoreMetaDataBuffer;
2072 goto EXIT;
2073 } else {
2074 ret = Rockchip_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
2075 }
2076 #else
2077 else {
2078 ret = Rockchip_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
2079 }
2080 #endif
2081
2082 EXIT:
2083 FunctionOut();
2084 return ret;
2085 }