1 /*
2 *
3 * Copyright 2013 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 Rkvpu_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_vdec_ctl"
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <fcntl.h>
33 #include <poll.h>
34 #include <sys/ioctl.h>
35 #include <unistd.h>
36
37 #include "Rockchip_OMX_Macros.h"
38 #include "Rockchip_OSAL_Event.h"
39 #include "Rkvpu_OMX_Vdec.h"
40 #include "Rockchip_OSAL_RGA_Process.h"
41 #include "Rockchip_OMX_Basecomponent.h"
42 #include "Rockchip_OSAL_Thread.h"
43 #include "Rockchip_OSAL_Semaphore.h"
44 #include "Rockchip_OSAL_Mutex.h"
45 #include "Rockchip_OSAL_ETC.h"
46 #include "Rockchip_OSAL_Queue.h"
47 #include "Rockchip_OSAL_SharedMemory.h"
48 #include "Rockchip_OSAL_ColorUtils.h"
49 #include "Rockchip_OSAL_OHOS.h"
50 #include "Rkvpu_OMX_VdecControl.h"
51 #ifdef OHOS_BUFFER_HANDLE
52 #include <buffer_handle.h>
53 #include <display_type.h>
54 #include <codec_omx_ext.h>
55 #endif
56 #include "vpu.h"
57 #include "vpu_mem_pool.h"
58 #include "vpu_mem.h"
59 #include "omx_video_global.h"
60 #if AVS100
61 #include <errno.h>
62 #include "drmrga.h"
63 #include "RgaApi.h"
64 #endif
65 #ifdef USE_ANB
66
67 #endif
68
69 #include "Rockchip_OSAL_Log.h"
70 #include "im2d.h"
71 #include "rga.h"
72 #include "IVCommonExt.h"
73 #include "VideoExt.h"
74 #include "IndexExt.h"
75
76 #define ALIGN_UP(x, a) ((((x) + ((a)-1)) / (a)) * (a))
77 #define WIDTH_720P 1080
78 #define HEIGHT_720P 720
79
80 typedef struct {
81 OMX_U32 mProfile;
82 OMX_U32 mLevel;
83 } CodecProfileLevel;
84
85 static const CodecProfileLevel kM2VProfileLevels[] = {
86 { OMX_VIDEO_MPEG2ProfileSimple, OMX_VIDEO_MPEG2LevelHL },
87 { OMX_VIDEO_MPEG2ProfileMain, OMX_VIDEO_MPEG2LevelHL},
88 };
89
90 static const CodecProfileLevel kM4VProfileLevels[] = {
91 { OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0 },
92 { OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0b},
93 { OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1 },
94 { OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level2 },
95 { OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level3 },
96 };
97
98 static const CodecProfileLevel kH263ProfileLevels[] = {
99 { OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10 },
100 { OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level20 },
101 { OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level30 },
102 { OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45 },
103 { OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level10 },
104 { OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level20 },
105 { OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level30 },
106 { OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level45 },
107 };
108
109 // only report echo profile highest level, Reference soft avc dec
110 static const CodecProfileLevel kH264ProfileLevelsMax[] = {
111 { OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel51 },
112 { OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel51},
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 { CODEC_HEVC_PROFILE_MAIN10, CODEC_HEVC_MAIN_TIER_LEVEL51 },
127 };
128
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)129 OMX_ERRORTYPE Rkvpu_OMX_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,
130 OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr, OMX_IN OMX_U32 nPortIndex,
131 OMX_IN OMX_PTR pAppPrivate, OMX_IN OMX_U32 nSizeBytes, OMX_IN OMX_U8 *pBuffer)
132 {
133 OMX_ERRORTYPE ret = OMX_ErrorNone;
134 OMX_COMPONENTTYPE *pOMXComponent = NULL;
135 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
136 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
137 OMX_BUFFERHEADERTYPE *temp_bufferHeader = NULL;
138 OMX_U32 i = 0;
139
140 FunctionIn();
141
142 if (hComponent == NULL) {
143 omx_err_f("hComponent is null");
144 ret = OMX_ErrorBadParameter;
145 goto EXIT;
146 }
147 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
148 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
149 if (ret != OMX_ErrorNone) {
150 omx_err_f("check version ret err");
151 goto EXIT;
152 }
153
154 if (pOMXComponent->pComponentPrivate == NULL) {
155 omx_err_f("pComponentPrivate is null");
156 ret = OMX_ErrorBadParameter;
157 goto EXIT;
158 }
159 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
160
161 pRockchipPort = &pRockchipComponent->pRockchipPort[nPortIndex];
162 if (nPortIndex >= pRockchipComponent->portParam.nPorts) {
163 omx_err_f("nPortIndex is %d", nPortIndex);
164 ret = OMX_ErrorBadPortIndex;
165 goto EXIT;
166 }
167 if (pRockchipPort->portState != OMX_StateIdle) {
168 omx_err_f("portState is %d", pRockchipPort->portState);
169 ret = OMX_ErrorIncorrectStateOperation;
170 goto EXIT;
171 }
172
173 if (CHECK_PORT_TUNNELED(pRockchipPort) && CHECK_PORT_BUFFER_SUPPLIER(pRockchipPort)) {
174 omx_err_f("port is tunneled or suffer");
175 ret = OMX_ErrorBadPortIndex;
176 goto EXIT;
177 }
178
179 temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)Rockchip_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
180 if (temp_bufferHeader == NULL) {
181 omx_err_f("temp_bufferHeader is null");
182 ret = OMX_ErrorInsufficientResources;
183 goto EXIT;
184 }
185 Rockchip_OSAL_Memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
186
187 for (i = 0; i < pRockchipPort->portDefinition.nBufferCountActual; i++) {
188 if (pRockchipPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
189 pRockchipPort->extendBufferHeader[i].OMXBufferHeader = temp_bufferHeader;
190 pRockchipPort->extendBufferHeader[i].pRegisterFlag = 0;
191 pRockchipPort->extendBufferHeader[i].pPrivate = NULL;
192 pRockchipPort->bufferStateAllocate[i] = (BUFFER_STATE_ASSIGNED | HEADER_STATE_ALLOCATED);
193 INIT_SET_SIZE_VERSION(temp_bufferHeader, OMX_BUFFERHEADERTYPE);
194 temp_bufferHeader->pBuffer = pBuffer;
195 temp_bufferHeader->nAllocLen = nSizeBytes;
196 temp_bufferHeader->pAppPrivate = pAppPrivate;
197 if (nPortIndex == INPUT_PORT_INDEX)
198 temp_bufferHeader->nInputPortIndex = INPUT_PORT_INDEX;
199 else {
200 temp_bufferHeader->nOutputPortIndex = OUTPUT_PORT_INDEX;
201 }
202 VIDEO_DBG(VIDEO_DBG_LOG_BUFFER,
203 "[%s]: Using %s buffer from OMX AL, count: %ld, index: %ld, buffer: %p, size: %ld",
204 pRockchipComponent->componentName,
205 nPortIndex == INPUT_PORT_INDEX ? "input" : "output",
206 pRockchipPort->portDefinition.nBufferCountActual,
207 i,
208 pBuffer,
209 nSizeBytes);
210
211 pRockchipPort->assignedBufferNum++;
212 if (pRockchipPort->assignedBufferNum == pRockchipPort->portDefinition.nBufferCountActual) {
213 pRockchipPort->portDefinition.bPopulated = OMX_TRUE;
214 Rockchip_OSAL_SemaphorePost(pRockchipPort->loadedResource);
215 }
216 *ppBufferHdr = temp_bufferHeader;
217 ret = OMX_ErrorNone;
218 goto EXIT;
219 }
220 }
221 omx_err_f("buffer is enough");
222 Rockchip_OSAL_Free(temp_bufferHeader);
223 ret = OMX_ErrorInsufficientResources;
224
225 EXIT:
226 FunctionOut();
227 return ret;
228 }
229
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)230 OMX_ERRORTYPE Rkvpu_OMX_AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,
231 OMX_INOUT OMX_BUFFERHEADERTYPE **ppBuffer, OMX_IN OMX_U32 nPortIndex,
232 OMX_IN OMX_PTR pAppPrivate, OMX_IN OMX_U32 nSizeBytes)
233 {
234 OMX_ERRORTYPE ret = OMX_ErrorNone;
235 OMX_COMPONENTTYPE *pOMXComponent = NULL;
236 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
237 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
238 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
239 OMX_BUFFERHEADERTYPE *temp_bufferHeader = NULL;
240 OMX_U8 *temp_buffer = NULL;
241 int temp_buffer_fd = -1;
242 OMX_U32 i = 0;
243 MEMORY_TYPE mem_type = NORMAL_MEMORY;
244 FunctionIn();
245 if (hComponent == NULL) {
246 omx_err_f("hComponent is null");
247 ret = OMX_ErrorBadParameter;
248 goto EXIT;
249 }
250 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
251 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
252 if (ret != OMX_ErrorNone) {
253 omx_err_f("hComponent is null");
254 goto EXIT;
255 }
256 if (pOMXComponent->pComponentPrivate == NULL) {
257 omx_err_f("pComponentPrivate is null");
258 ret = OMX_ErrorBadParameter;
259 goto EXIT;
260 }
261 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
262 pVideoDec = (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
263 pRockchipPort = &pRockchipComponent->pRockchipPort[nPortIndex];
264 if (nPortIndex >= pRockchipComponent->portParam.nPorts) {
265 omx_err_f("nPortIndex is %d", nPortIndex);
266 ret = OMX_ErrorBadPortIndex;
267 goto EXIT;
268 }
269 if (CHECK_PORT_TUNNELED(pRockchipPort) && CHECK_PORT_BUFFER_SUPPLIER(pRockchipPort)) {
270 omx_err_f("port check err");
271 ret = OMX_ErrorBadPortIndex;
272 goto EXIT;
273 }
274 #if 1
275 if ((pVideoDec->bDRMPlayerMode == OMX_TRUE) && (nPortIndex == INPUT_PORT_INDEX)) {
276 mem_type = SECURE_MEMORY;
277 } else if (pRockchipPort->bufferProcessType == BUFFER_SHARE) {
278 mem_type = NORMAL_MEMORY;
279 } else {
280 mem_type = SYSTEM_MEMORY;
281 }
282 #endif
283 if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
284 omx_trace("Rkvpu_OMX_AllocateBuffer bDRMPlayerMode");
285 temp_buffer = (OMX_U8 *)Rockchip_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, nSizeBytes, mem_type);
286 if (temp_buffer == NULL) {
287 omx_err("Rkvpu_OMX_AllocateBuffer bDRMPlayerMode error");
288 ret = OMX_ErrorInsufficientResources;
289 goto EXIT;
290 }
291 } else {
292 temp_buffer = (OMX_U8 *)Rockchip_OSAL_Malloc(nSizeBytes);
293 if (temp_buffer == NULL) {
294 omx_err_f("temp_buffer is null");
295 ret = OMX_ErrorInsufficientResources;
296 goto EXIT;
297 }
298 }
299 temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)Rockchip_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
300 if (temp_bufferHeader == NULL) {
301 omx_err_f("temp_bufferHeader is null");
302 Rockchip_OSAL_Free(temp_buffer);
303 ret = OMX_ErrorInsufficientResources;
304 goto EXIT;
305 }
306 Rockchip_OSAL_Memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
307 for (i = 0; i < pRockchipPort->portDefinition.nBufferCountActual; i++) {
308 if (pRockchipPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
309 pRockchipPort->extendBufferHeader[i].OMXBufferHeader = temp_bufferHeader;
310 pRockchipPort->extendBufferHeader[i].buf_fd[0] = temp_buffer_fd;
311 pRockchipPort->bufferStateAllocate[i] = (BUFFER_STATE_ALLOCATED | HEADER_STATE_ALLOCATED);
312 INIT_SET_SIZE_VERSION(temp_bufferHeader, OMX_BUFFERHEADERTYPE);
313 omx_info_f("buf_fd: 0x%x, OMXBufferHeader:%p", temp_buffer_fd, temp_bufferHeader);
314 temp_bufferHeader->pBuffer = temp_buffer;
315 temp_bufferHeader->nAllocLen = nSizeBytes;
316 temp_bufferHeader->pAppPrivate = pAppPrivate;
317 omx_info_f("nPortIndex is %d", nPortIndex);
318 if (nPortIndex == INPUT_PORT_INDEX) {
319 temp_bufferHeader->nInputPortIndex = INPUT_PORT_INDEX;
320 } else {
321 temp_bufferHeader->nOutputPortIndex = OUTPUT_PORT_INDEX;
322 }
323 pRockchipPort->assignedBufferNum++;
324 if (pRockchipPort->assignedBufferNum == pRockchipPort->portDefinition.nBufferCountActual) {
325 omx_info_f("bPopulated is OMX_TRUE");
326 pRockchipPort->portDefinition.bPopulated = OMX_TRUE;
327 Rockchip_OSAL_SemaphorePost(pRockchipPort->loadedResource);
328 }
329 *ppBuffer = temp_bufferHeader;
330 ret = OMX_ErrorNone;
331 goto EXIT;
332 }
333 }
334 omx_err_f("buffer is enough");
335 Rockchip_OSAL_Free(temp_bufferHeader);
336 Rockchip_OSAL_Free(temp_buffer);
337 ret = OMX_ErrorInsufficientResources;
338
339 EXIT:
340 FunctionOut();
341 return ret;
342 }
343
Rkvpu_OMX_FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_BUFFERHEADERTYPE * pBufferHdr)344 OMX_ERRORTYPE Rkvpu_OMX_FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,
345 OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr)
346 {
347 OMX_ERRORTYPE ret = OMX_ErrorNone;
348 OMX_COMPONENTTYPE *pOMXComponent = NULL;
349 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
350 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
351 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
352 OMX_U32 i = 0;
353 FunctionIn();
354 if (hComponent == NULL) {
355 omx_err_f("hComponent is null");
356 ret = OMX_ErrorBadParameter;
357 goto EXIT;
358 }
359 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
360 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
361 if (ret != OMX_ErrorNone) {
362 omx_err_f("size version check err");
363 goto EXIT;
364 }
365 if (pOMXComponent->pComponentPrivate == NULL) {
366 omx_err_f("pComponentPrivate is null");
367 ret = OMX_ErrorBadParameter;
368 goto EXIT;
369 }
370 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
371 pVideoDec = (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
372 pRockchipPort = &pRockchipComponent->pRockchipPort[nPortIndex];
373 if (CHECK_PORT_TUNNELED(pRockchipPort) && CHECK_PORT_BUFFER_SUPPLIER(pRockchipPort)) {
374 omx_err_f("port check error");
375 ret = OMX_ErrorBadPortIndex;
376 goto EXIT;
377 }
378
379 if ((pRockchipPort->portState != OMX_StateLoaded) && (pRockchipPort->portState != OMX_StateInvalid)) {
380 omx_err_f("portState is %d", pRockchipPort->portState);
381 (*(pRockchipComponent->pCallbacks->EventHandler)) (pOMXComponent,
382 pRockchipComponent->callbackData,
383 (OMX_U32)OMX_EventError,
384 (OMX_U32)OMX_ErrorPortUnpopulated,
385 nPortIndex, NULL);
386 }
387
388 for (i = 0; i < MAX_BUFFER_NUM; i++) { /* pRockchipPort->portDefinition.nBufferCountActual */
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 if (pVideoDec->bDRMPlayerMode != 1)
394 Rockchip_OSAL_Free(pRockchipPort->extendBufferHeader[i].OMXBufferHeader->pBuffer);
395 pRockchipPort->extendBufferHeader[i].OMXBufferHeader->pBuffer = NULL;
396 pBufferHdr->pBuffer = NULL;
397 } else if (pRockchipPort->bufferStateAllocate[i] & BUFFER_STATE_ASSIGNED) {
398 ; /* None */
399 }
400 VIDEO_DBG(VIDEO_DBG_LOG_BUFFER, "[%s]: free %s buffer, count: %d, index: %d, buffer: %p, size: %d",
401 pRockchipComponent->componentName,
402 nPortIndex == INPUT_PORT_INDEX ? "input" : "output",
403 (int)pRockchipPort->portDefinition.nBufferCountActual,
404 (int)i,
405 pBufferHdr->pBuffer,
406 (int)pBufferHdr->nAllocLen);
407
408 pRockchipPort->assignedBufferNum--;
409 if (pRockchipPort->bufferStateAllocate[i] & HEADER_STATE_ALLOCATED) {
410 Rockchip_OSAL_Free(pRockchipPort->extendBufferHeader[i].OMXBufferHeader);
411 pRockchipPort->extendBufferHeader[i].OMXBufferHeader = NULL;
412 pBufferHdr = NULL;
413 omx_info_f("free buffer %d", i);
414 }
415 pRockchipPort->bufferStateAllocate[i] = BUFFER_STATE_FREE;
416 ret = OMX_ErrorNone;
417 goto EXIT;
418 }
419 }
420 }
421 EXIT:
422 if (ret == OMX_ErrorNone) {
423 omx_trace_f("ret is OMX_ErrorNone");
424 if (pRockchipPort->assignedBufferNum == 0) {
425 omx_trace("pRockchipPort->unloadedResource signal set");
426 Rockchip_OSAL_SemaphorePost(pRockchipPort->unloadedResource);
427 pRockchipPort->portDefinition.bPopulated = OMX_FALSE;
428 }
429 }
430 FunctionOut();
431 return ret;
432 }
433
Rkvpu_OMX_AllocateTunnelBuffer(ROCKCHIP_OMX_BASEPORT * pOMXBasePort,OMX_U32 nPortIndex)434 OMX_ERRORTYPE Rkvpu_OMX_AllocateTunnelBuffer(ROCKCHIP_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex)
435 {
436 OMX_ERRORTYPE ret = OMX_ErrorNone;
437 (void) pOMXBasePort;
438 (void) nPortIndex;
439
440 ret = OMX_ErrorTunnelingUnsupported;
441 goto EXIT;
442 EXIT:
443 return ret;
444 }
445
Rkvpu_OMX_FreeTunnelBuffer(ROCKCHIP_OMX_BASEPORT * pOMXBasePort,OMX_U32 nPortIndex)446 OMX_ERRORTYPE Rkvpu_OMX_FreeTunnelBuffer(ROCKCHIP_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex)
447 {
448 OMX_ERRORTYPE ret = OMX_ErrorNone;
449 omx_err_f("This is not implemented");
450 ret = OMX_ErrorTunnelingUnsupported;
451 goto EXIT;
452 EXIT:
453 return ret;
454 }
455
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)456 OMX_ERRORTYPE Rkvpu_OMX_ComponentTunnelRequest(OMX_IN OMX_HANDLETYPE hComp, OMX_IN OMX_U32 nPort,
457 OMX_IN OMX_HANDLETYPE hTunneledComp, OMX_IN OMX_U32 nTunneledPort, OMX_INOUT OMX_TUNNELSETUPTYPE *pTunnelSetup)
458 {
459 OMX_ERRORTYPE ret = OMX_ErrorNone;
460 omx_err_f("This is not implemented");
461 ret = OMX_ErrorTunnelingUnsupported;
462 goto EXIT;
463 EXIT:
464 return ret;
465 }
466
Rkvpu_OMX_GetFlushBuffer(ROCKCHIP_OMX_BASEPORT * pRockchipPort,ROCKCHIP_OMX_DATABUFFER * pDataBuffer[])467 OMX_ERRORTYPE Rkvpu_OMX_GetFlushBuffer(ROCKCHIP_OMX_BASEPORT *pRockchipPort, ROCKCHIP_OMX_DATABUFFER *pDataBuffer[])
468 {
469 OMX_ERRORTYPE ret = OMX_ErrorNone;
470 FunctionIn();
471 *pDataBuffer = NULL;
472 if (pRockchipPort->portWayType == WAY1_PORT) {
473 omx_trace("pRockchipPort->portWayType is WAY1_PORT");
474 *pDataBuffer = &pRockchipPort->way.port1WayDataBuffer.dataBuffer;
475 } else if (pRockchipPort->portWayType == WAY2_PORT) {
476 omx_trace("pRockchipPort->portWayType is WAY2_PORT");
477 pDataBuffer[0] = &(pRockchipPort->way.port2WayDataBuffer.inputDataBuffer);
478 pDataBuffer[1] = &(pRockchipPort->way.port2WayDataBuffer.outputDataBuffer);
479 }
480 goto EXIT;
481 EXIT:
482 FunctionOut();
483 return ret;
484 }
485
Rkvpu_OMX_FlushPort(OMX_COMPONENTTYPE * pOMXComponent,OMX_S32 portIndex)486 OMX_ERRORTYPE Rkvpu_OMX_FlushPort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
487 {
488 FunctionIn();
489 OMX_ERRORTYPE ret = OMX_ErrorNone;
490 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
491 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
492 OMX_BUFFERHEADERTYPE *bufferHeader = NULL;
493 ROCKCHIP_OMX_DATABUFFER *pDataPortBuffer[2] = {NULL, NULL};
494 ROCKCHIP_OMX_MESSAGE *message = NULL;
495 OMX_S32 semValue = 0;
496 int i = 0, maxBufferNum = 0;
497 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
498 while (Rockchip_OSAL_GetElemNum(&pRockchipPort->bufferQ) > 0) {
499 Rockchip_OSAL_Get_SemaphoreCount(pRockchipComponent->pRockchipPort[portIndex].bufferSemID, &semValue);
500 if (semValue == 0) {
501 Rockchip_OSAL_SemaphorePost(pRockchipComponent->pRockchipPort[portIndex].bufferSemID);
502 }
503 Rockchip_OSAL_SemaphoreWait(pRockchipComponent->pRockchipPort[portIndex].bufferSemID);
504 message = (ROCKCHIP_OMX_MESSAGE *)Rockchip_OSAL_Dequeue(&pRockchipPort->bufferQ);
505 if ((message != NULL) && (message->messageType != ROCKCHIP_OMX_CommandFakeBuffer)) {
506 bufferHeader = (OMX_BUFFERHEADERTYPE *)message->pCmdData;
507 bufferHeader->nFilledLen = 0;
508
509 if (portIndex == OUTPUT_PORT_INDEX) {
510 Rockchip_OMX_OutputBufferReturn(pOMXComponent, bufferHeader);
511 } else if (portIndex == INPUT_PORT_INDEX) {
512 Rkvpu_OMX_InputBufferReturn(pOMXComponent, bufferHeader);
513 }
514 }
515 Rockchip_OSAL_Free(message);
516 message = NULL;
517 }
518
519 Rkvpu_OMX_GetFlushBuffer(pRockchipPort, pDataPortBuffer);
520 if (portIndex == INPUT_PORT_INDEX) {
521 if (pDataPortBuffer[0]->dataValid == OMX_TRUE)
522 Rkvpu_InputBufferReturn(pOMXComponent, pDataPortBuffer[0]);
523 if (pDataPortBuffer[1]->dataValid == OMX_TRUE)
524 Rkvpu_InputBufferReturn(pOMXComponent, pDataPortBuffer[1]);
525 } else if (portIndex == OUTPUT_PORT_INDEX) {
526 if (pDataPortBuffer[0]->dataValid == OMX_TRUE)
527 Rkvpu_OutputBufferReturn(pOMXComponent, pDataPortBuffer[0]);
528 if (pDataPortBuffer[1]->dataValid == OMX_TRUE)
529 Rkvpu_OutputBufferReturn(pOMXComponent, pDataPortBuffer[1]);
530 }
531
532 if (pRockchipComponent->bMultiThreadProcess == OMX_TRUE) {
533 if (pRockchipPort->bufferProcessType == BUFFER_SHARE) {
534 if (pRockchipPort->processData.bufferHeader != NULL) {
535 if (portIndex == INPUT_PORT_INDEX) {
536 Rkvpu_OMX_InputBufferReturn(pOMXComponent, pRockchipPort->processData.bufferHeader);
537 } else if (portIndex == OUTPUT_PORT_INDEX) {
538 Rockchip_OMX_OutputBufferReturn(pOMXComponent, pRockchipPort->processData.bufferHeader);
539 }
540 }
541 Rockchip_ResetCodecData(&pRockchipPort->processData);
542
543 maxBufferNum = pRockchipPort->portDefinition.nBufferCountActual;
544 for (i = 0; i < maxBufferNum; i++) {
545 pRockchipPort->extendBufferHeader[i].pRegisterFlag = 0;
546 pRockchipPort->extendBufferHeader[i].buf_fd[0] = 0;
547 if (pRockchipPort->extendBufferHeader[i].pPrivate != NULL) {
548 Rockchip_OSAL_FreeVpumem(pRockchipPort->extendBufferHeader[i].pPrivate);
549 pRockchipPort->extendBufferHeader[i].pPrivate = NULL;
550 }
551
552 if (pRockchipPort->extendBufferHeader[i].bBufferInOMX == OMX_TRUE) {
553 if (portIndex == OUTPUT_PORT_INDEX) {
554 Rockchip_OMX_OutputBufferReturn(pOMXComponent,
555 pRockchipPort->extendBufferHeader[i].OMXBufferHeader);
556 } else if (portIndex == INPUT_PORT_INDEX) {
557 Rkvpu_OMX_InputBufferReturn(pOMXComponent,
558 pRockchipPort->extendBufferHeader[i].OMXBufferHeader);
559 }
560 }
561 }
562 Rockchip_OSAL_resetVpumemPool(pRockchipComponent);
563 }
564 } else {
565 Rockchip_ResetCodecData(&pRockchipPort->processData);
566 }
567
568 if ((pRockchipPort->bufferProcessType == BUFFER_SHARE) &&
569 (portIndex == OUTPUT_PORT_INDEX)) {
570 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
571 if (pOMXComponent->pComponentPrivate == NULL) {
572 ret = OMX_ErrorBadParameter;
573 goto EXIT;
574 }
575 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
576 pVideoDec = (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
577 }
578
579 while (1) {
580 OMX_S32 cnt = 0;
581 Rockchip_OSAL_Get_SemaphoreCount(pRockchipComponent->pRockchipPort[portIndex].bufferSemID, &cnt);
582 if (cnt <= 0)
583 break;
584 Rockchip_OSAL_SemaphoreWait(pRockchipComponent->pRockchipPort[portIndex].bufferSemID);
585 }
586 Rockchip_OSAL_ResetQueue(&pRockchipPort->bufferQ);
587
588 EXIT:
589 FunctionOut();
590
591 return ret;
592 }
593
Rkvpu_OMX_BufferFlush(OMX_COMPONENTTYPE * pOMXComponent,OMX_S32 nPortIndex,OMX_BOOL bEvent)594 OMX_ERRORTYPE Rkvpu_OMX_BufferFlush(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex, OMX_BOOL bEvent)
595 {
596 OMX_ERRORTYPE ret = OMX_ErrorNone;
597 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
598 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
599 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
600 ROCKCHIP_OMX_DATABUFFER *flushPortBuffer[2] = {NULL, NULL};
601 ROCKCHIP_OMX_BASEPORT *pInputPort = NULL;
602
603 FunctionIn();
604 if (pOMXComponent == NULL) {
605 omx_err_f("pOMXComponent is null");
606 ret = OMX_ErrorBadParameter;
607 goto EXIT;
608 }
609 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
610 if (ret != OMX_ErrorNone) {
611 omx_err_f("check version ret err");
612 goto EXIT;
613 }
614
615 if (pOMXComponent->pComponentPrivate == NULL) {
616 omx_err_f("pComponentPrivate is null");
617 ret = OMX_ErrorBadParameter;
618 goto EXIT;
619 }
620 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
621 pVideoDec = (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
622 pInputPort = &pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX];
623
624 pRockchipComponent->pRockchipPort[nPortIndex].bIsPortFlushed = OMX_TRUE;
625
626 if (pRockchipComponent->bMultiThreadProcess == OMX_FALSE) {
627 Rockchip_OSAL_SignalSet(pRockchipComponent->pauseEvent);
628 } else {
629 Rockchip_OSAL_SignalSet(pRockchipComponent->pRockchipPort[nPortIndex].pauseEvent);
630 }
631
632 pRockchipPort = &pRockchipComponent->pRockchipPort[nPortIndex];
633 Rkvpu_OMX_GetFlushBuffer(pRockchipPort, flushPortBuffer);
634
635 Rockchip_OSAL_SemaphorePost(pRockchipPort->bufferSemID);
636 Rockchip_OSAL_MutexLock(flushPortBuffer[0]->bufferMutex);
637 Rockchip_OSAL_MutexLock(flushPortBuffer[1]->bufferMutex);
638 ret = Rkvpu_OMX_FlushPort(pOMXComponent, nPortIndex);
639
640 VpuCodecContext_t *p_vpu_ctx = pVideoDec->vpu_ctx;
641 if (pRockchipComponent->nRkFlags & RK_VPU_NEED_FLUSH_ON_SEEK) {
642 p_vpu_ctx->flush(p_vpu_ctx);
643 pRockchipComponent->nRkFlags &= ~RK_VPU_NEED_FLUSH_ON_SEEK;
644 Rockchip_OSAL_MutexLock(pInputPort->secureBufferMutex);
645 pVideoDec->invalidCount = 0;
646 Rockchip_OSAL_MutexUnlock(pInputPort->secureBufferMutex);
647 }
648
649 omx_trace("OMX_CommandFlush start, port:%d", (int)nPortIndex);
650 Rockchip_ResetCodecData(&pRockchipPort->processData);
651
652 Rockchip_OSAL_MutexLock(pInputPort->secureBufferMutex);
653 if (pVideoDec->bDRMPlayerMode == OMX_TRUE && pVideoDec->bInfoChange == OMX_FALSE) {
654 int securebufferNum = Rockchip_OSAL_GetElemNum(&pInputPort->securebufferQ);
655 omx_trace("Rkvpu_OMX_BufferFlush in securebufferNum = %d", securebufferNum);
656 while (securebufferNum != 0) {
657 ROCKCHIP_OMX_DATABUFFER *securebuffer =
658 (ROCKCHIP_OMX_DATABUFFER *)Rockchip_OSAL_Dequeue(&pInputPort->securebufferQ);
659 Rkvpu_InputBufferReturn(pOMXComponent, securebuffer);
660 Rockchip_OSAL_Free(securebuffer);
661 securebufferNum = Rockchip_OSAL_GetElemNum(&pInputPort->securebufferQ);
662 }
663 omx_trace("Rkvpu_OMX_BufferFlush out securebufferNum = %d", securebufferNum);
664 }
665 Rockchip_OSAL_MutexUnlock(pInputPort->secureBufferMutex);
666
667 if (ret == OMX_ErrorNone) {
668 if (nPortIndex == INPUT_PORT_INDEX) {
669 pRockchipComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
670 pRockchipComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
671 Rockchip_OSAL_Memset(pRockchipComponent->timeStamp,
672 -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP); /* -19771003:byte alignment */
673 Rockchip_OSAL_Memset(pRockchipComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
674 pRockchipComponent->getAllDelayBuffer = OMX_FALSE;
675 pRockchipComponent->bSaveFlagEOS = OMX_FALSE;
676 pRockchipComponent->bBehaviorEOS = OMX_FALSE;
677 pVideoDec->bDecSendEOS = OMX_FALSE;
678 pRockchipComponent->reInputData = OMX_FALSE;
679 }
680
681 pRockchipComponent->pRockchipPort[nPortIndex].bIsPortFlushed = OMX_FALSE;
682 omx_trace("OMX_CommandFlush EventCmdComplete, port:%d", (int)nPortIndex);
683 if (bEvent == OMX_TRUE)
684 pRockchipComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
685 pRockchipComponent->callbackData,
686 OMX_EventCmdComplete,
687 OMX_CommandFlush, nPortIndex, NULL);
688 }
689 if (pVideoDec->bInfoChange == OMX_TRUE)
690 pVideoDec->bInfoChange = OMX_FALSE;
691 Rockchip_OSAL_MutexUnlock(flushPortBuffer[1]->bufferMutex);
692 Rockchip_OSAL_MutexUnlock(flushPortBuffer[0]->bufferMutex);
693
694 EXIT:
695 if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pRockchipComponent != NULL)) {
696 omx_err("ERROR");
697 pRockchipComponent->pCallbacks->EventHandler(pOMXComponent,
698 pRockchipComponent->callbackData,
699 OMX_EventError,
700 ret, 0, NULL);
701 }
702
703 FunctionOut();
704
705 return ret;
706 }
707
Rkvpu_ResolutionUpdate(OMX_COMPONENTTYPE * pOMXComponent)708 OMX_ERRORTYPE Rkvpu_ResolutionUpdate(OMX_COMPONENTTYPE *pOMXComponent)
709 {
710 OMX_ERRORTYPE ret = OMX_ErrorNone;
711 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
712 ROCKCHIP_OMX_BASEPORT *pInputPort = &pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX];
713 ROCKCHIP_OMX_BASEPORT *pOutputPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
714 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
715
716 pOutputPort->cropRectangle.nTop = pOutputPort->newCropRectangle.nTop;
717 pOutputPort->cropRectangle.nLeft = pOutputPort->newCropRectangle.nLeft;
718 pOutputPort->cropRectangle.nWidth = pOutputPort->newCropRectangle.nWidth;
719 pOutputPort->cropRectangle.nHeight = pOutputPort->newCropRectangle.nHeight;
720
721 pVideoDec = (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
722
723 pInputPort->portDefinition.format.video.nFrameWidth = pInputPort->newPortDefinition.format.video.nFrameWidth;
724 pInputPort->portDefinition.format.video.nFrameHeight = pInputPort->newPortDefinition.format.video.nFrameHeight;
725 pInputPort->portDefinition.format.video.nStride = pInputPort->newPortDefinition.format.video.nStride;
726 pOutputPort->portDefinition.format.video.nStride = pInputPort->newPortDefinition.format.video.nStride;
727 pInputPort->portDefinition.format.video.nSliceHeight = pInputPort->newPortDefinition.format.video.nSliceHeight;
728 pOutputPort->portDefinition.format.video.nSliceHeight = pInputPort->newPortDefinition.format.video.nSliceHeight;
729 pOutputPort->portDefinition.format.video.eColorFormat = pOutputPort->newPortDefinition.format.video.eColorFormat;
730
731 pOutputPort->portDefinition.nBufferCountActual = pOutputPort->newPortDefinition.nBufferCountActual;
732 pOutputPort->portDefinition.nBufferCountMin = pOutputPort->newPortDefinition.nBufferCountMin;
733
734 UpdateFrameSize(pOMXComponent);
735
736 return ret;
737 }
738
Rkvpu_InputBufferReturn(OMX_COMPONENTTYPE * pOMXComponent,ROCKCHIP_OMX_DATABUFFER * dataBuffer)739 OMX_ERRORTYPE Rkvpu_InputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent, ROCKCHIP_OMX_DATABUFFER *dataBuffer)
740 {
741 OMX_ERRORTYPE ret = OMX_ErrorNone;
742 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
743 ROCKCHIP_OMX_BASEPORT *rockchipOMXInputPort = &pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX];
744 OMX_BUFFERHEADERTYPE *bufferHeader = NULL;
745 FunctionIn();
746 bufferHeader = dataBuffer->bufferHeader;
747 if (bufferHeader != NULL) {
748 omx_trace("bufferHeader is %p", bufferHeader);
749 if (rockchipOMXInputPort->markType.hMarkTargetComponent != NULL) {
750 omx_trace("hMarkTargetComponent is %p", rockchipOMXInputPort->markType.hMarkTargetComponent);
751 bufferHeader->hMarkTargetComponent = rockchipOMXInputPort->markType.hMarkTargetComponent;
752 bufferHeader->pMarkData = rockchipOMXInputPort->markType.pMarkData;
753 rockchipOMXInputPort->markType.hMarkTargetComponent = NULL;
754 rockchipOMXInputPort->markType.pMarkData = NULL;
755 }
756 if (bufferHeader->hMarkTargetComponent != NULL) {
757 omx_trace("bufferHeader->hMarkTargetComponent is %p", bufferHeader->hMarkTargetComponent);
758 if (bufferHeader->hMarkTargetComponent == pOMXComponent) {
759 omx_trace("EventHandler OMX_EventMark");
760 pRockchipComponent->pCallbacks->EventHandler(pOMXComponent, pRockchipComponent->callbackData,
761 OMX_EventMark, 0, 0, bufferHeader->pMarkData);
762 } else {
763 pRockchipComponent->propagateMarkType.hMarkTargetComponent = bufferHeader->hMarkTargetComponent;
764 pRockchipComponent->propagateMarkType.pMarkData = bufferHeader->pMarkData;
765 }
766 }
767 bufferHeader->nFilledLen = 0;
768 bufferHeader->nOffset = 0;
769 omx_trace("input buffer return");
770 Rkvpu_OMX_InputBufferReturn(pOMXComponent, bufferHeader);
771 }
772 /* reset dataBuffer */
773 Rockchip_ResetDataBuffer(dataBuffer);
774 goto EXIT;
775 EXIT:
776 FunctionOut();
777 return ret;
778 }
779
Rkvpu_Frame2Outbuf(OMX_COMPONENTTYPE * pOMXComponent,OMX_BUFFERHEADERTYPE * pOutputBuffer,VPU_FRAME * pframe)780 OMX_ERRORTYPE Rkvpu_Frame2Outbuf(OMX_COMPONENTTYPE *pOMXComponent,
781 OMX_BUFFERHEADERTYPE *pOutputBuffer, VPU_FRAME *pframe)
782 {
783 FunctionIn();
784 OMX_ERRORTYPE ret = OMX_ErrorNone;
785 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
786 #if AVS100
787 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec = (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
788 #endif
789 ROCKCHIP_OMX_BASEPORT *pOutputPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
790
791 #ifdef OHOS_BUFFER_HANDLE
792 if (pVideoDec->bOhosBufferHandle == OMX_TRUE) {
793 omx_trace("bOhosBufferHandle is TRUE");
794 OMX_U32 mWidth = pOutputPort->portDefinition.format.video.nFrameWidth;
795 OMX_U32 mHeight = pOutputPort->portDefinition.format.video.nFrameHeight;
796 OMX_U32 mStride = 0;
797 OMX_U32 mSliceHeight = 0;
798 mStride = Get_Video_HorAlign(pVideoDec->codecId, mWidth, mHeight, pVideoDec->codecProfile);
799 mSliceHeight = Get_Video_VerAlign(pVideoDec->codecId, mHeight, pVideoDec->codecProfile);
800
801 BufferHandle* bufferHandle = (BufferHandle*)pOutputBuffer->pBuffer;
802
803 if (bufferHandle == NULL) {
804 omx_err("bufferHandle is null");
805 return OMX_ErrorBadParameter;
806 }
807
808 if (bufferHandle->format != PIXEL_FMT_YCRCB_420_SP && bufferHandle->format != PIXEL_FMT_YCBCR_420_SP &&
809 bufferHandle->format != PIXEL_FMT_YCBCR_420_P && bufferHandle->format != PIXEL_FMT_YCRCB_420_P) {
810 omx_warn("bufferhandle format is %d", bufferHandle->format);
811 }
812
813 pOutputBuffer->nFilledLen = bufferHandle->size;
814 VPUMemLink(&pframe->vpumem);
815 VPUMemInvalidate(&pframe->vpumem);
816 rga_buffer_t src;
817 rga_buffer_t dst;
818 im_rect rect;
819 Rockchip_OSAL_Memset(&src, 0, sizeof(src));
820 Rockchip_OSAL_Memset(&dst, 0, sizeof(dst));
821 src.fd = pframe->vpumem.phy_addr;
822 src.wstride = pframe->FrameWidth;
823 src.hstride = pframe->FrameHeight;
824 src.width = pframe->DisplayWidth;
825 src.height = pframe->DisplayHeight;
826 src.format = RK_FORMAT_YCbCr_420_SP;
827 dst.fd = bufferHandle->fd;
828 dst.wstride = bufferHandle->stride;
829 dst.hstride = bufferHandle->height;
830 dst.width = bufferHandle->width;
831 dst.height = bufferHandle->height;
832 if (bufferHandle->format == PIXEL_FMT_RGBA_8888) {
833 dst.format = RK_FORMAT_RGBA_8888;
834 dst.wstride = bufferHandle->stride/4; // 4 : rgba alignment
835 } else if (bufferHandle->format == PIXEL_FMT_BGRA_8888) {
836 dst.format = RK_FORMAT_BGRA_8888;
837 dst.wstride = bufferHandle->stride/4; // 4: bgra alignment
838 } else {
839 dst.format = RK_FORMAT_YCbCr_420_SP;
840 }
841 rect.x = 0;
842 rect.y = 0;
843 rect.width = mWidth;
844 rect.height = mHeight;
845 imcrop(src, dst, rect);
846 VPUFreeLinear(&pframe->vpumem);
847 FunctionOut();
848 return ret;
849 } else {
850 omx_trace("bOhosBufferHandle is FALSE");
851 }
852 #endif // OHOS_BUFFER_HANDLE
853 #ifdef USE_STOREMETADATA
854 if (pVideoDec->bStoreMetaData == OMX_TRUE) {
855 OMX_U32 mWidth = pOutputPort->portDefinition.format.video.nFrameWidth;
856 OMX_U32 mHeight = pOutputPort->portDefinition.format.video.nFrameHeight;
857 RockchipVideoPlane vplanes;
858 OMX_PTR pGrallocHandle;
859 OMX_COLOR_FORMATTYPE omx_format = 0;
860 OMX_U32 pixel_format = 0;
861
862 if (Rockchip_OSAL_GetInfoFromMetaData(pOutputBuffer->pBuffer, &pGrallocHandle)) {
863 return OMX_ErrorBadParameter;
864 }
865
866 if (pVideoDec->bPvr_Flag == OMX_TRUE) {
867 pixel_format = RK_FORMAT_BGRA_8888;
868 } else {
869 omx_format = Rockchip_OSAL_GetANBColorFormat(pGrallocHandle);
870 pixel_format = Rockchip_OSAL_OMX2HalPixelFormat(omx_format);
871 if (pixel_format == HAL_PIXEL_FORMAT_RGBA_8888) {
872 pixel_format = RK_FORMAT_RGBA_8888;
873 } else {
874 pixel_format = RK_FORMAT_BGRA_8888;
875 }
876 }
877 if (pVideoDec->rga_ctx != NULL) {
878 Rockchip_OSAL_LockANB(pGrallocHandle, mWidth, mHeight, omx_format, &vplanes);
879 VPUMemLink(&pframe->vpumem);
880 rga_nv122rgb(&vplanes, &pframe->vpumem, mWidth, mHeight, pixel_format, pVideoDec->rga_ctx);
881 VPUFreeLinear(&pframe->vpumem);
882 Rockchip_OSAL_UnlockANB(pGrallocHandle);
883 }
884 FunctionOut();
885 return ret;
886 }
887 #endif
888
889 #ifdef USE_ANB
890 if (pVideoDec->bIsANBEnabled == OMX_TRUE) {
891 omx_trace("enableNativeBuffer");
892 OMX_U32 mWidth = pOutputPort->portDefinition.format.video.nFrameWidth;
893 OMX_U32 mHeight = pOutputPort->portDefinition.format.video.nFrameHeight;
894 RockchipVideoPlane vplanes;
895 OMX_U32 mStride = 0;
896 OMX_U32 mSliceHeight = 0;
897 OMX_COLOR_FORMATTYPE omx_format = 0;
898 OMX_U32 pixel_format = 0;
899 mStride = Get_Video_HorAlign(pVideoDec->codecId, mWidth, mHeight, pVideoDec->codecProfile);
900 mSliceHeight = Get_Video_VerAlign(pVideoDec->codecId, mHeight, pVideoDec->codecProfile);
901 omx_format = Rockchip_OSAL_GetANBColorFormat(pOutputBuffer->pBuffer);
902 pixel_format = Rockchip_OSAL_OMX2HalPixelFormat(omx_format);
903 Rockchip_OSAL_LockANB(pOutputBuffer->pBuffer, mWidth, mHeight, omx_format, &vplanes);
904 {
905 VPUMemLink(&pframe->vpumem);
906 VPUMemInvalidate(&pframe->vpumem);
907 {
908 OMX_U8 *buff_vir = (OMX_U8 *)pframe->vpumem.vir_addr;
909 pOutputBuffer->nFilledLen = mWidth * mHeight * 3 / 2; // 3:byte alignment, 2:byte alignment
910 OMX_U32 uv_offset = mStride * mSliceHeight;
911 OMX_U32 y_size = mWidth * mHeight;
912 OMX_U8 *dst_uv = (OMX_U8 *)((OMX_U8 *)vplanes.addr + y_size);
913 OMX_U8 *src_uv = (OMX_U8 *)(buff_vir + uv_offset);
914 OMX_U32 i = 0;
915
916 omx_trace("mWidth = %d mHeight = %d mStride = %d,mSlicHeight %d",
917 mWidth, mHeight, mStride, mSliceHeight);
918 for (i = 0; i < mHeight; i++) {
919 Rockchip_OSAL_Memcpy((char*)vplanes.addr + i * mWidth, buff_vir + i * mStride, mWidth);
920 }
921
922 for (i = 0; i < mHeight / 2; i++) { // 2:byte alignment
923 Rockchip_OSAL_Memcpy((OMX_U8*)dst_uv, (OMX_U8*)src_uv, mWidth);
924 dst_uv += mWidth;
925 src_uv += mStride;
926 }
927 }
928 VPUFreeLinear(&pframe->vpumem);
929 }
930 Rockchip_OSAL_UnlockANB(pOutputBuffer->pBuffer);
931 FunctionOut();
932 return ret;
933 }
934 #endif
935 OMX_U32 mStride = 0;
936 OMX_U32 mSliceHeight = 0;
937 OMX_U32 mWidth = (pOutputPort->portDefinition.format.video.nFrameWidth);
938 OMX_U32 mHeight = (pOutputPort->portDefinition.format.video.nFrameHeight);
939 VPUMemLink(&pframe->vpumem);
940 VPUMemInvalidate(&pframe->vpumem);
941
942 omx_trace("width:%ld,height:%ld ", mWidth, mHeight);
943 mStride = pframe->FrameWidth;
944 mSliceHeight = pframe->FrameHeight;
945 {
946 // csy@rock-chips.com
947 OMX_U8 *buff_vir = (OMX_U8 *)pframe->vpumem.vir_addr;
948 #if AVS100
949 OMX_U32 srcFormat, dstFormat;
950 srcFormat = dstFormat = HAL_PIXEL_FORMAT_YCrCb_NV12;
951 #endif
952 pOutputBuffer->nFilledLen = GetDataSize(mWidth, mHeight, pOutputPort->portDefinition.format.video.eColorFormat);
953 #if AVS100
954 if ((pVideoDec->codecProfile == OMX_VIDEO_AVCProfileHigh10 && pVideoDec->codecId == OMX_VIDEO_CodingAVC)
955 || ((pVideoDec->codecProfile == CODEC_HEVC_PROFILE_MAIN10 ||
956 pVideoDec->codecProfile == CODEC_HEVC_PROFILE_MAIN10_HDR10)
957 && pVideoDec->codecId == CODEC_OMX_VIDEO_CodingHEVC)) {
958 OMX_U32 horStride = Get_Video_HorAlign(pVideoDec->codecId, pframe->DisplayWidth,
959 pframe->DisplayHeight, pVideoDec->codecProfile);
960 OMX_U32 verStride = Get_Video_VerAlign(pVideoDec->codecId, pframe->DisplayHeight, pVideoDec->codecProfile);
961 pOutputBuffer->nFilledLen = horStride * verStride * 3 / 2; // 3:byte alignment, 2:byte alignment
962 Rockchip_OSAL_Memcpy((char *)pOutputBuffer->pBuffer, buff_vir, pOutputBuffer->nFilledLen);
963 omx_trace("debug 10bit mWidth = %d mHeight = %d horStride = %d,verStride %d",
964 (int)mWidth, (int)mHeight, (int)horStride, (int)verStride);
965 } else {
966 rga_buffer_t src;
967 rga_buffer_t dst;
968 im_rect rect;
969 Rockchip_OSAL_Memset(&src, 0, sizeof(src));
970 Rockchip_OSAL_Memset(&dst, 0, sizeof(dst));
971 src.fd = pframe->vpumem.phy_addr;
972 src.wstride = pframe->FrameWidth;
973 src.hstride = pframe->FrameHeight;
974 src.width = pframe->DisplayWidth;
975 src.height = pframe->DisplayHeight;
976 src.format = RK_FORMAT_YCbCr_420_SP;
977 dst.fd = -1;
978 dst.width = pOutputPort->portDefinition.format.video.nFrameWidth;
979 dst.height = pOutputPort->portDefinition.format.video.nFrameHeight;
980 dst.wstride = dst.width;
981 dst.hstride = dst.height;
982 dst.vir_addr = pOutputBuffer->pBuffer;
983 if (pOutputPort->portDefinition.format.video.eColorFormat == CODEC_COLOR_FORMAT_RGBA8888) {
984 dst.format = RK_FORMAT_RGBA_8888;
985 } else if (pOutputPort->portDefinition.format.video.eColorFormat == OMX_COLOR_Format32bitBGRA8888) {
986 dst.format = RK_FORMAT_BGRA_8888;
987 } else {
988 dst.format = RK_FORMAT_YCbCr_420_SP;
989 }
990 rect.x = 0;
991 rect.y = 0;
992 rect.width = mWidth;
993 rect.height = mHeight;
994 imcrop(src, dst, rect);
995 }
996 #else
997 for (i = 0; i < mHeight; i++) {
998 Rockchip_OSAL_Memcpy((char*)pOutputBuffer->pBuffer + i * mWidth, buff_vir + i * mStride, mWidth);
999 }
1000
1001 for (i = 0; i < mHeight / 2; i++) { // 2:byte alignment
1002 Rockchip_OSAL_Memcpy((OMX_U8*)dst_uv, (OMX_U8*)src_uv, mWidth);
1003 dst_uv += mWidth;
1004 src_uv += mStride;
1005 }
1006 #endif
1007 }
1008 VPUFreeLinear(&pframe->vpumem);
1009 return ret;
1010 }
1011
Rkvpu_InputBufferGetQueue(ROCKCHIP_OMX_BASECOMPONENT * pRockchipComponent)1012 OMX_ERRORTYPE Rkvpu_InputBufferGetQueue(ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent)
1013 {
1014 OMX_U32 ret = OMX_ErrorUndefined;
1015 ROCKCHIP_OMX_BASEPORT *pRockchipPort = &pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX];
1016 ROCKCHIP_OMX_MESSAGE *message = NULL;
1017 ROCKCHIP_OMX_DATABUFFER *inputUseBuffer = NULL;
1018
1019 FunctionIn();
1020
1021 inputUseBuffer = &(pRockchipPort->way.port2WayDataBuffer.inputDataBuffer);
1022
1023 if (pRockchipComponent->currentState != OMX_StateExecuting) {
1024 ret = OMX_ErrorUndefined;
1025 goto EXIT;
1026 } else if ((pRockchipComponent->transientState != ROCKCHIP_OMX_TransStateExecutingToIdle) &&
1027 (!CHECK_PORT_BEING_FLUSHED(pRockchipPort))) {
1028 Rockchip_OSAL_SemaphoreWait(pRockchipPort->bufferSemID);
1029 if (inputUseBuffer->dataValid != OMX_TRUE) {
1030 message = (ROCKCHIP_OMX_MESSAGE *)Rockchip_OSAL_Dequeue(&pRockchipPort->bufferQ);
1031 if (message == NULL) {
1032 ret = OMX_ErrorUndefined;
1033 goto EXIT;
1034 }
1035 if (message->messageType == ROCKCHIP_OMX_CommandFakeBuffer) {
1036 Rockchip_OSAL_Free(message);
1037 ret = OMX_ErrorCodecFlush;
1038 goto EXIT;
1039 }
1040 omx_trace("input buffer count = %d", pRockchipPort->bufferQ.numElem);
1041 inputUseBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
1042 inputUseBuffer->allocSize = inputUseBuffer->bufferHeader->nAllocLen;
1043 inputUseBuffer->dataLen = inputUseBuffer->bufferHeader->nFilledLen;
1044 inputUseBuffer->remainDataLen = inputUseBuffer->dataLen;
1045 inputUseBuffer->usedDataLen = 0;
1046 inputUseBuffer->dataValid = OMX_TRUE;
1047 inputUseBuffer->nFlags = inputUseBuffer->bufferHeader->nFlags;
1048 inputUseBuffer->timeStamp = inputUseBuffer->bufferHeader->nTimeStamp;
1049
1050 Rockchip_OSAL_Free(message);
1051
1052 if (inputUseBuffer->allocSize <= inputUseBuffer->dataLen)
1053 omx_trace("Input Buffer Full, Check input buffer size! allocSize:%lu, dataLen:%lu",
1054 inputUseBuffer->allocSize, inputUseBuffer->dataLen);
1055 }
1056 ret = OMX_ErrorNone;
1057 }
1058 EXIT:
1059 FunctionOut();
1060
1061 return ret;
1062 }
1063
Rkvpu_OutputBufferReturn(OMX_COMPONENTTYPE * pOMXComponent,ROCKCHIP_OMX_DATABUFFER * dataBuffer)1064 OMX_ERRORTYPE Rkvpu_OutputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent, ROCKCHIP_OMX_DATABUFFER *dataBuffer)
1065 {
1066 OMX_ERRORTYPE ret = OMX_ErrorNone;
1067 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1068 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec = (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1069 ROCKCHIP_OMX_BASEPORT *rockchipOMXOutputPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
1070 OMX_BUFFERHEADERTYPE *bufferHeader = NULL;
1071 OMX_U32 i = 0;
1072
1073 FunctionIn();
1074
1075 bufferHeader = dataBuffer->bufferHeader;
1076
1077 if (bufferHeader == NULL) {
1078 if (dataBuffer->nFlags & OMX_BUFFERFLAG_EOS) {
1079 omx_info("eos reach, but don't have buffer.");
1080 VPUMemLinear_t *handle = NULL;
1081 OMX_U32 nUnusedCount = 0;
1082 OMX_U32 retry = 10;
1083 struct vpu_display_mem_pool *pMem_pool = (struct vpu_display_mem_pool *)pVideoDec->vpumem_handle;
1084 while (retry--) {
1085 nUnusedCount = pMem_pool->get_unused_num(pMem_pool);
1086 if (nUnusedCount > 0) {
1087 handle = pMem_pool->get_free(pMem_pool);
1088 if (handle) {
1089 omx_trace("handle: %p fd: 0x%x", handle, VPUMemGetFD(handle));
1090 for (i = 0; i < rockchipOMXOutputPort->portDefinition.nBufferCountActual; i++) {
1091 if (rockchipOMXOutputPort->extendBufferHeader[i].buf_fd[0] == VPUMemGetFD(handle)) {
1092 bufferHeader = rockchipOMXOutputPort->extendBufferHeader[i].OMXBufferHeader;
1093 break;
1094 }
1095 }
1096 VPUMemLink(handle);
1097 VPUFreeLinear(handle);
1098 if (bufferHeader != NULL) {
1099 break;
1100 }
1101 }
1102 }
1103 Rockchip_OSAL_SleepMillisec(20); // 20:sleep
1104 }
1105
1106 if (bufferHeader != NULL) {
1107 omx_info("found matching buffer header");
1108 dataBuffer->bufferHeader = bufferHeader;
1109 } else {
1110 omx_err("not matching buffer header, callback error!");
1111 pRockchipComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
1112 pRockchipComponent->callbackData, OMX_EventError,
1113 OUTPUT_PORT_INDEX,
1114 OMX_IndexParamPortDefinition, NULL);
1115 }
1116 }
1117 }
1118
1119 if (bufferHeader != NULL) {
1120 bufferHeader->nFilledLen = dataBuffer->remainDataLen;
1121 bufferHeader->nOffset = 0;
1122 bufferHeader->nFlags = dataBuffer->nFlags;
1123 bufferHeader->nTimeStamp = dataBuffer->timeStamp;
1124
1125 if ((rockchipOMXOutputPort->bStoreMetaData == OMX_TRUE) && (bufferHeader->nFilledLen > 0))
1126 bufferHeader->nFilledLen = bufferHeader->nAllocLen;
1127 if (pRockchipComponent->propagateMarkType.hMarkTargetComponent != NULL) {
1128 bufferHeader->hMarkTargetComponent = pRockchipComponent->propagateMarkType.hMarkTargetComponent;
1129 bufferHeader->pMarkData = pRockchipComponent->propagateMarkType.pMarkData;
1130 pRockchipComponent->propagateMarkType.hMarkTargetComponent = NULL;
1131 pRockchipComponent->propagateMarkType.pMarkData = NULL;
1132 }
1133
1134 if ((bufferHeader->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
1135 omx_info("event OMX_BUFFERFLAG_EOS!!!");
1136 pRockchipComponent->pCallbacks->EventHandler(pOMXComponent,
1137 pRockchipComponent->callbackData,
1138 OMX_EventBufferFlag,
1139 OUTPUT_PORT_INDEX,
1140 bufferHeader->nFlags, NULL);
1141 }
1142
1143 Rockchip_OMX_OutputBufferReturn(pOMXComponent, bufferHeader);
1144 }
1145
1146 /* reset dataBuffer */
1147 Rockchip_ResetDataBuffer(dataBuffer);
1148
1149 goto EXIT;
1150 EXIT:
1151 FunctionOut();
1152
1153 return ret;
1154 }
1155
Rkvpu_OutputBufferGetQueue(ROCKCHIP_OMX_BASECOMPONENT * pRockchipComponent)1156 OMX_ERRORTYPE Rkvpu_OutputBufferGetQueue(ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent)
1157 {
1158 OMX_U32 ret = OMX_ErrorUndefined;
1159 ROCKCHIP_OMX_BASEPORT *pRockchipPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
1160 ROCKCHIP_OMX_MESSAGE *message = NULL;
1161 ROCKCHIP_OMX_DATABUFFER *outputUseBuffer = NULL;
1162 FunctionIn();
1163 outputUseBuffer = &(pRockchipPort->way.port2WayDataBuffer.outputDataBuffer);
1164
1165 if (pRockchipComponent->currentState != OMX_StateExecuting) {
1166 omx_err_f("currentState is %d", pRockchipComponent->currentState);
1167 ret = OMX_ErrorUndefined;
1168 goto EXIT;
1169 } else if ((pRockchipComponent->transientState != ROCKCHIP_OMX_TransStateExecutingToIdle) &&
1170 (!CHECK_PORT_BEING_FLUSHED(pRockchipPort))) {
1171 Rockchip_OSAL_SemaphoreWait(pRockchipPort->bufferSemID);
1172 if (outputUseBuffer->dataValid != OMX_TRUE) {
1173 message = (ROCKCHIP_OMX_MESSAGE *)Rockchip_OSAL_Dequeue(&pRockchipPort->bufferQ);
1174 if (message == NULL) {
1175 omx_err_f("message is null");
1176 ret = OMX_ErrorUndefined;
1177 goto EXIT;
1178 }
1179 if (message->messageType == ROCKCHIP_OMX_CommandFakeBuffer) {
1180 omx_err_f("messageType == ROCKCHIP_OMX_CommandFakeBuffer");
1181 Rockchip_OSAL_Free(message);
1182 ret = OMX_ErrorCodecFlush;
1183 goto EXIT;
1184 }
1185 outputUseBuffer->dataValid = OMX_TRUE;
1186 outputUseBuffer->dataLen = 0;
1187 outputUseBuffer->usedDataLen = 0;
1188 outputUseBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
1189 outputUseBuffer->allocSize = outputUseBuffer->bufferHeader->nAllocLen;
1190 outputUseBuffer->remainDataLen = outputUseBuffer->dataLen;
1191 Rockchip_OSAL_Free(message);
1192 }
1193 ret = OMX_ErrorNone;
1194 }
1195 EXIT:
1196 FunctionOut();
1197 return ret;
1198 }
1199
Rkvpu_OutputBufferGetQueue_Direct(ROCKCHIP_OMX_BASECOMPONENT * pRockchipComponent)1200 OMX_BUFFERHEADERTYPE *Rkvpu_OutputBufferGetQueue_Direct(ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent)
1201 {
1202 OMX_BUFFERHEADERTYPE *retBuffer = NULL;
1203 ROCKCHIP_OMX_BASEPORT *pRockchipPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
1204 ROCKCHIP_OMX_MESSAGE *message = NULL;
1205
1206 FunctionIn();
1207
1208 if (pRockchipComponent->currentState != OMX_StateExecuting) {
1209 retBuffer = NULL;
1210 goto EXIT;
1211 } else if ((pRockchipComponent->transientState != ROCKCHIP_OMX_TransStateExecutingToIdle) &&
1212 (!CHECK_PORT_BEING_FLUSHED(pRockchipPort))) {
1213 Rockchip_OSAL_SemaphoreWait(pRockchipPort->bufferSemID);
1214
1215 message = (ROCKCHIP_OMX_MESSAGE *)Rockchip_OSAL_Dequeue(&pRockchipPort->bufferQ);
1216 if (message == NULL) {
1217 retBuffer = NULL;
1218 goto EXIT;
1219 }
1220 if (message->messageType == ROCKCHIP_OMX_CommandFakeBuffer) {
1221 Rockchip_OSAL_Free(message);
1222 retBuffer = NULL;
1223 goto EXIT;
1224 }
1225
1226 retBuffer = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
1227 Rockchip_OSAL_Free(message);
1228 }
1229
1230 EXIT:
1231 FunctionOut();
1232
1233 return retBuffer;
1234 }
1235
Rkvpu_CodecBufferReset(ROCKCHIP_OMX_BASECOMPONENT * pRockchipComponent,OMX_U32 PortIndex)1236 OMX_ERRORTYPE Rkvpu_CodecBufferReset(ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent, OMX_U32 PortIndex)
1237 {
1238 OMX_ERRORTYPE ret = OMX_ErrorNone;
1239 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1240
1241 FunctionIn();
1242 pRockchipPort = &pRockchipComponent->pRockchipPort[PortIndex];
1243 ret = Rockchip_OSAL_ResetQueue(&pRockchipPort->codecBufferQ);
1244 if (ret != 0) {
1245 ret = OMX_ErrorUndefined;
1246 goto EXIT;
1247 }
1248 while (1) {
1249 OMX_S32 cnt = 0;
1250 Rockchip_OSAL_Get_SemaphoreCount(pRockchipPort->codecSemID, (OMX_S32*)&cnt);
1251 if (cnt > 0) {
1252 omx_info_f("cnt >0, wait");
1253 Rockchip_OSAL_SemaphoreWait(pRockchipPort->codecSemID);
1254 } else {
1255 omx_info_f("cnt = 0 , do not wait");
1256 break;
1257 }
1258 }
1259 ret = OMX_ErrorNone;
1260 EXIT:
1261 FunctionOut();
1262 return ret;
1263 }
1264
Rkvpu_OMX_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_INOUT OMX_PTR ComponentParameterStructure)1265 OMX_ERRORTYPE Rkvpu_OMX_GetParameter(OMX_IN OMX_HANDLETYPE hComponent, OMX_IN OMX_INDEXTYPE nParamIndex,
1266 OMX_INOUT OMX_PTR ComponentParameterStructure)
1267 {
1268 OMX_ERRORTYPE ret = OMX_ErrorNone;
1269 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1270 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
1271 FunctionIn();
1272 if (hComponent == NULL) {
1273 omx_err_f("hComponent is null");
1274 ret = OMX_ErrorBadParameter;
1275 goto EXIT;
1276 }
1277 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1278 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1279 if (ret != OMX_ErrorNone) {
1280 omx_err_f("check size error");
1281 goto EXIT;
1282 }
1283
1284 if (pOMXComponent->pComponentPrivate == NULL) {
1285 ret = OMX_ErrorBadParameter;
1286 omx_err_f("pComponentPrivate is null");
1287 goto EXIT;
1288 }
1289 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1290 if (pRockchipComponent->currentState == OMX_StateInvalid) {
1291 ret = OMX_ErrorInvalidState;
1292 omx_err_f("currentState is OMX_StateInvalid");
1293 goto EXIT;
1294 }
1295
1296 if (ComponentParameterStructure == NULL) {
1297 omx_err_f("ComponentParameterStructure is null");
1298 ret = OMX_ErrorBadParameter;
1299 goto EXIT;
1300 }
1301
1302 switch ((OMX_U32)nParamIndex) {
1303 case OMX_IndexParamVideoInit: {
1304 OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
1305 ret = Rockchip_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
1306 if (ret != OMX_ErrorNone) {
1307 omx_err_f("check version ret err");
1308 goto EXIT;
1309 }
1310 portParam->nPorts = pRockchipComponent->portParam.nPorts;
1311 portParam->nStartPortNumber = pRockchipComponent->portParam.nStartPortNumber;
1312 ret = OMX_ErrorNone;
1313 break;
1314 }
1315 case OMX_IndexParamVideoPortFormat: {
1316 OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
1317 OMX_U32 portIndex = portFormat->nPortIndex, index = portFormat->nIndex, supportFormatNum = 0;
1318 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1319 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
1320 #ifdef USE_ANB
1321 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1322 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1323 #endif
1324 ret = Rockchip_OMX_Check_SizeVersion(portFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1325 if (ret != OMX_ErrorNone) {
1326 omx_err_f("check size ret err");
1327 goto EXIT;
1328 }
1329 if ((portIndex >= pRockchipComponent->portParam.nPorts)) {
1330 omx_err_f("portIndex is %d", portIndex);
1331 ret = OMX_ErrorBadPortIndex;
1332 goto EXIT;
1333 }
1334 if (portIndex == INPUT_PORT_INDEX) {
1335 supportFormatNum = INPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
1336 if (index > supportFormatNum) {
1337 omx_err_f("index is too large");
1338 ret = OMX_ErrorNoMore;
1339 goto EXIT;
1340 }
1341
1342 pRockchipPort = &pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX];
1343 portDefinition = &pRockchipPort->portDefinition;
1344
1345 portFormat->eCompressionFormat = portDefinition->format.video.eCompressionFormat;
1346 portFormat->eColorFormat = portDefinition->format.video.eColorFormat;
1347 portFormat->xFramerate = portDefinition->format.video.xFramerate;
1348 } else if (portIndex == OUTPUT_PORT_INDEX) {
1349 pRockchipPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
1350 portDefinition = &pRockchipPort->portDefinition;
1351 if (pRockchipPort->bStoreMetaData == OMX_FALSE) {
1352 switch (index) {
1353 case supportFormat_0: {
1354 portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1355 portFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
1356 portFormat->xFramerate = portDefinition->format.video.xFramerate;
1357 omx_info_f("index is supportFormat_0");
1358 break;
1359 }
1360 default: {
1361 if (index > supportFormat_0) {
1362 omx_err_f("nomore index supported");
1363 ret = OMX_ErrorNoMore;
1364 goto EXIT;
1365 }
1366 break;
1367 }
1368 }
1369 } else {
1370 switch (index) {
1371 case supportFormat_0: {
1372 portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1373 portFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
1374 portFormat->xFramerate = portDefinition->format.video.xFramerate;
1375 omx_info_f("index is supportFormat_0");
1376 break;
1377 }
1378 default: {
1379 if (index > supportFormat_0) {
1380 omx_err_f("nomore index supported");
1381 ret = OMX_ErrorNoMore;
1382 goto EXIT;
1383 }
1384 break;
1385 }
1386 }
1387 }
1388 }
1389 ret = OMX_ErrorNone;
1390 break;
1391 }
1392 #ifdef OHOS_BUFFER_HANDLE
1393 case OMX_IndexParamSupportBufferType: {
1394 omx_info("%s:OMX_IndexParamSupportBufferType", __func__);
1395 struct SupportBufferType *bufferTyps = (struct SupportBufferType *)ComponentParameterStructure;
1396 if (bufferTyps == NULL) {
1397 omx_err_f("bufferTyps is null");
1398 ret = OMX_ErrorBadParameter;
1399 goto EXIT;
1400 }
1401 OMX_U32 portIndex = bufferTyps->portIndex;
1402 if (portIndex >= pRockchipComponent->portParam.nPorts) {
1403 ret = OMX_ErrorBadPortIndex;
1404 goto EXIT;
1405 }
1406 ret = Rockchip_OMX_Check_SizeVersion(bufferTyps, sizeof(struct SupportBufferType));
1407 if (ret != OMX_ErrorNone) {
1408 goto EXIT;
1409 }
1410 bufferTyps->bufferTypes = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
1411 if (portIndex == OUTPUT_PORT_INDEX) {
1412 bufferTyps->bufferTypes |= CODEC_BUFFER_TYPE_HANDLE;
1413 }
1414 ret = OMX_ErrorNone;
1415 } break;
1416 case OMX_IndexParamGetBufferHandleUsage: {
1417 struct GetBufferHandleUsageParams *usage = (struct GetBufferHandleUsageParams *)ComponentParameterStructure;
1418 if (usage == NULL) {
1419 omx_err_f("usage is null");
1420 ret = OMX_ErrorBadParameter;
1421 goto EXIT;
1422 }
1423 OMX_U32 portIndex = usage->portIndex;
1424 if (portIndex >= pRockchipComponent->portParam.nPorts || portIndex == INPUT_PORT_INDEX) {
1425 ret = OMX_ErrorBadPortIndex;
1426 goto EXIT;
1427 }
1428
1429 ret = Rockchip_OMX_Check_SizeVersion(usage, sizeof(struct GetBufferHandleUsageParams));
1430 if (ret != OMX_ErrorNone) {
1431 goto EXIT;
1432 }
1433
1434 usage->usage = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA;
1435 ret = OMX_ErrorNone;
1436 } break;
1437 case OMX_IndexCodecVideoPortFormat: {
1438 struct CodecVideoPortFormatParam *videoFormat =
1439 (struct CodecVideoPortFormatParam *)ComponentParameterStructure;
1440 if (videoFormat == NULL) {
1441 omx_err_f("videoFormat is null");
1442 ret = OMX_ErrorBadParameter;
1443 goto EXIT;
1444 }
1445 OMX_U32 portIndex = videoFormat->portIndex;
1446 if (portIndex >= pRockchipComponent->portParam.nPorts) {
1447 ret = OMX_ErrorBadPortIndex;
1448 goto EXIT;
1449 }
1450
1451 ret = Rockchip_OMX_Check_SizeVersion(videoFormat, sizeof(struct CodecVideoPortFormatParam));
1452 if (ret != OMX_ErrorNone) {
1453 goto EXIT;
1454 }
1455 ROCKCHIP_OMX_BASEPORT *pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1456 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = &pRockchipPort->portDefinition;
1457 OMX_U32 index = videoFormat->codecColorIndex;
1458 if (portIndex == INPUT_PORT_INDEX) {
1459 if (index > supportFormat_0) {
1460 omx_err_f("nomore index supported");
1461 ret = OMX_ErrorNoMore;
1462 }
1463 videoFormat->codecColorFormat =
1464 Rockchip_OSAL_OmxColorFormat2CodecFormat(portDefinition->format.video.eColorFormat);
1465 videoFormat->codecCompressFormat = portDefinition->format.video.eCompressionFormat;
1466 videoFormat->framerate = portDefinition->format.video.xFramerate;
1467 } else {
1468 switch (index) {
1469 case supportFormat_0: {
1470 videoFormat->codecColorFormat =
1471 Rockchip_OSAL_OmxColorFormat2CodecFormat(OMX_COLOR_FormatYUV420SemiPlanar);
1472 break;
1473 }
1474 default: {
1475 omx_err_f("nomore index supported");
1476 ret = OMX_ErrorNoMore;
1477 goto EXIT;
1478 }
1479 }
1480
1481 videoFormat->framerate = portDefinition->format.video.xFramerate;
1482 videoFormat->codecCompressFormat = OMX_VIDEO_CodingUnused;
1483 }
1484 ret = OMX_ErrorNone;
1485
1486 } break;
1487 #endif
1488 #ifdef USE_ANB
1489 case OMX_IndexParamGetAndroidNativeBufferUsage:
1490 case OMX_IndexParamdescribeColorFormat: {
1491
1492 omx_trace("Rockchip_OSAL_GetANBParameter!!");
1493 ret = Rockchip_OSAL_GetANBParameter(hComponent, nParamIndex, ComponentParameterStructure);
1494 }
1495 break;
1496 case (OMX_INDEXTYPE)OMX_IndexParamPortDefinition: {
1497 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1498 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
1499 OMX_U32 portIndex = portDefinition->nPortIndex;
1500 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1501 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1502 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1503
1504 ret = Rockchip_OMX_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
1505 if (ret != OMX_ErrorNone) {
1506 goto EXIT;
1507 }
1508
1509 /* at this point, GetParameter has done all the verification, we
1510 * just dereference things directly here
1511 */
1512 if ((pVideoDec->bIsANBEnabled == OMX_TRUE) ||
1513 (pVideoDec->bStoreMetaData == OMX_TRUE)) {
1514 portDefinition->format.video.eColorFormat = pRockchipPort->portDefinition.format.video.eColorFormat;
1515 omx_trace("portDefinition->format.video.eColorFormat:0x%x", portDefinition->format.video.eColorFormat);
1516 }
1517 if (portIndex == OUTPUT_PORT_INDEX &&
1518 pRockchipPort->bufferProcessType != BUFFER_SHARE) {
1519 portDefinition->format.video.nStride = portDefinition->format.video.nFrameWidth;
1520 portDefinition->format.video.nSliceHeight = portDefinition->format.video.nFrameHeight;
1521 }
1522 #ifdef AVS80
1523 if (portIndex == OUTPUT_PORT_INDEX &&
1524 pRockchipPort->bufferProcessType == BUFFER_SHARE) {
1525 ROCKCHIP_OMX_BASEPORT *pInputPort = &pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX];
1526 int32_t depth = (pVideoDec->bIs10bit) ? OMX_DEPTH_BIT_10 : OMX_DEPTH_BIT_8;
1527 OMX_BOOL fbcMode = Rockchip_OSAL_Check_Use_FBCMode(pVideoDec->codecId, depth, pRockchipPort);
1528
1529 /*
1530 * We use pixel_stride instead of byte_stride to setup nativeWindow surface
1531 * for 10bit source at fbcMode
1532 */
1533 if (!pVideoDec->bIs10bit || !fbcMode) {
1534 portDefinition->format.video.nFrameWidth = portDefinition->format.video.nStride;
1535 }
1536
1537 if (fbcMode && (pVideoDec->codecId == CODEC_OMX_VIDEO_CodingHEVC
1538 || pVideoDec->codecId == OMX_VIDEO_CodingAVC)) {
1539 OMX_U32 height = pInputPort->portDefinition.format.video.nFrameHeight;
1540 // On FBC case H.264/H.265 decoder will add 4 lines blank on top.
1541 portDefinition->format.video.nFrameHeight
1542 = Get_Video_VerAlign(pVideoDec->codecId, height + 4, pVideoDec->codecProfile);
1543 } else {
1544 portDefinition->format.video.nFrameHeight = portDefinition->format.video.nSliceHeight;
1545 }
1546 }
1547 #endif
1548 }
1549 break;
1550 #endif
1551
1552 case OMX_IndexParamStandardComponentRole: {
1553 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)ComponentParameterStructure;
1554 ret = Rockchip_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1555 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1556 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1557 if (ret != OMX_ErrorNone) {
1558 goto EXIT;
1559 }
1560 if (pVideoDec->codecId == OMX_VIDEO_CodingAVC) {
1561 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_H264_DEC_ROLE);
1562 } else if (pVideoDec->codecId == OMX_VIDEO_CodingMPEG4) {
1563 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_MPEG4_DEC_ROLE);
1564 } else if (pVideoDec->codecId == OMX_VIDEO_CodingH263) {
1565 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_H263_DEC_ROLE);
1566 } else if (pVideoDec->codecId == OMX_VIDEO_CodingMPEG2) {
1567 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_MPEG2_DEC_ROLE);
1568 } else if (pVideoDec->codecId == OMX_VIDEO_CodingVP8EXT) {
1569 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_VP8_DEC_ROLE);
1570 } else if (pVideoDec->codecId == CODEC_OMX_VIDEO_CodingHEVC) {
1571 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_HEVC_DEC_ROLE);
1572 } else if (pVideoDec->codecId == (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingFLV1) {
1573 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_FLV_DEC_ROLE);
1574 } else if (pVideoDec->codecId == (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingVP6) {
1575 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_VP6_DEC_ROLE);
1576 } else if (pVideoDec->codecId == OMX_VIDEO_CodingMJPEG) {
1577 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_MJPEG_DEC_ROLE);
1578 } else if (pVideoDec->codecId == (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingVC1) {
1579 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_VC1_DEC_ROLE);
1580 } else if (pVideoDec->codecId == OMX_VIDEO_CodingWMV) {
1581 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_WMV3_DEC_ROLE);
1582 } else if (pVideoDec->codecId == OMX_VIDEO_CodingRV) {
1583 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_RMVB_DEC_ROLE);
1584 } else if (pVideoDec->codecId == CODEC_OMX_VIDEO_CodingVP9) {
1585 Rockchip_OSAL_Strcpy((char *)pComponentRole->cRole, RK_OMX_COMPONENT_VP9_DEC_ROLE);
1586 }
1587 }
1588 break;
1589 case OMX_IndexParamVideoAvc: {
1590 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)ComponentParameterStructure;
1591 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
1592 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1593 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1594
1595 ret = Rockchip_OMX_Check_SizeVersion(pDstAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1596 if (ret != OMX_ErrorNone) {
1597 goto EXIT;
1598 }
1599
1600 if (pDstAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1601 ret = OMX_ErrorBadPortIndex;
1602 goto EXIT;
1603 }
1604
1605 pSrcAVCComponent = &pVideoDec->AVCComponent[pDstAVCComponent->nPortIndex];
1606 Rockchip_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1607 }
1608 break;
1609 case OMX_IndexParamVideoProfileLevelQuerySupported: {
1610 OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevel =
1611 (OMX_VIDEO_PARAM_PROFILELEVELTYPE *) ComponentParameterStructure;
1612 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1613 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1614
1615 OMX_U32 index = profileLevel->nProfileIndex;
1616 OMX_U32 nProfileLevels = 0;
1617 if (profileLevel->nPortIndex != 0) {
1618 omx_err("Invalid port index: %ld", profileLevel->nPortIndex);
1619 return OMX_ErrorUnsupportedIndex;
1620 }
1621 if (pVideoDec->codecId == OMX_VIDEO_CodingAVC) {
1622 nProfileLevels =
1623 sizeof(kH264ProfileLevelsMax) / sizeof(kH264ProfileLevelsMax[0]);
1624 if (index >= nProfileLevels) {
1625 return OMX_ErrorNoMore;
1626 }
1627 profileLevel->eProfile = kH264ProfileLevelsMax[index].mProfile;
1628 profileLevel->eLevel = kH264ProfileLevelsMax[index].mLevel;
1629 } else if (pVideoDec->codecId == CODEC_OMX_VIDEO_CodingHEVC) {
1630 nProfileLevels =
1631 sizeof(kH265ProfileLevels) / sizeof(kH265ProfileLevels[0]);
1632 if (index >= nProfileLevels) {
1633 return OMX_ErrorNoMore;
1634 }
1635 profileLevel->eProfile = kH265ProfileLevels[index].mProfile;
1636 profileLevel->eLevel = kH265ProfileLevels[index].mLevel;
1637 } else if (pVideoDec->codecId == OMX_VIDEO_CodingMPEG4) {
1638 nProfileLevels =
1639 sizeof(kM4VProfileLevels) / sizeof(kM4VProfileLevels[0]);
1640 if (index >= nProfileLevels) {
1641 return OMX_ErrorNoMore;
1642 }
1643 profileLevel->eProfile = kM4VProfileLevels[index].mProfile;
1644 profileLevel->eLevel = kM4VProfileLevels[index].mLevel;
1645 } else if (pVideoDec->codecId == OMX_VIDEO_CodingH263) {
1646 nProfileLevels =
1647 sizeof(kH263ProfileLevels) / sizeof(kH263ProfileLevels[0]);
1648 if (index >= nProfileLevels) {
1649 return OMX_ErrorNoMore;
1650 }
1651 profileLevel->eProfile = kH263ProfileLevels[index].mProfile;
1652 profileLevel->eLevel = kH263ProfileLevels[index].mLevel;
1653 } else if (pVideoDec->codecId == OMX_VIDEO_CodingMPEG2) {
1654 nProfileLevels =
1655 sizeof(kM2VProfileLevels) / sizeof(kM2VProfileLevels[0]);
1656 if (index >= nProfileLevels) {
1657 return OMX_ErrorNoMore;
1658 }
1659 profileLevel->eProfile = kM2VProfileLevels[index].mProfile;
1660 profileLevel->eLevel = kM2VProfileLevels[index].mLevel;
1661 } else {
1662 return OMX_ErrorNoMore;
1663 }
1664 return OMX_ErrorNone;
1665 break;
1666 }
1667 case OMX_IndexParamVideoHDRRockchipExtensions: {
1668 OMX_EXTENSION_VIDEO_PARAM_HDR *hdrParams =
1669 (OMX_EXTENSION_VIDEO_PARAM_HDR *) ComponentParameterStructure;
1670 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1671 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1672
1673 ret = Rockchip_OMX_Check_SizeVersion(hdrParams, sizeof(OMX_EXTENSION_VIDEO_PARAM_HDR));
1674 if (ret != OMX_ErrorNone) {
1675 goto EXIT;
1676 }
1677
1678 hdrParams->eColorSpace = pVideoDec->extColorSpace;
1679 hdrParams->eDyncRange = pVideoDec->extDyncRange;
1680 ret = OMX_ErrorNone;
1681 break;
1682 }
1683 default: {
1684 ret = Rockchip_OMX_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
1685 omx_info_f("Rockchip_OMX_GetParameter ret value is %d", ret);
1686 break;
1687 }
1688 }
1689 EXIT:
1690 FunctionOut();
1691 return ret;
1692 }
Rkvpu_OMX_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nIndex,OMX_IN OMX_PTR ComponentParameterStructure)1693 OMX_ERRORTYPE Rkvpu_OMX_SetParameter(OMX_IN OMX_HANDLETYPE hComponent,
1694 OMX_IN OMX_INDEXTYPE nIndex, OMX_IN OMX_PTR ComponentParameterStructure)
1695 {
1696 OMX_ERRORTYPE ret = OMX_ErrorNone;
1697 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1698 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
1699 FunctionIn();
1700 if (hComponent == NULL) {
1701 ret = OMX_ErrorBadParameter;
1702 omx_err_f("hComponent is null");
1703 goto EXIT;
1704 }
1705 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1706 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1707 if (ret != OMX_ErrorNone) {
1708 omx_err_f("version check err");
1709 goto EXIT;
1710 }
1711 if (pOMXComponent->pComponentPrivate == NULL) {
1712 ret = OMX_ErrorBadParameter;
1713 omx_err_f("pComponentPrivate is null");
1714 goto EXIT;
1715 }
1716 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1717 if (pRockchipComponent->currentState == OMX_StateInvalid) {
1718 ret = OMX_ErrorInvalidState;
1719 omx_err_f("currentState is OMX_StateInvalid");
1720 goto EXIT;
1721 }
1722
1723 if (ComponentParameterStructure == NULL) {
1724 ret = OMX_ErrorBadParameter;
1725 omx_err_f("ComponentParameterStructure is null");
1726 goto EXIT;
1727 }
1728
1729 switch ((OMX_U32)nIndex) {
1730 case OMX_IndexParamVideoPortFormat: {
1731 OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
1732 OMX_U32 portIndex = portFormat->nPortIndex;
1733 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
1734 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = NULL;
1735
1736 ret = Rockchip_OMX_Check_SizeVersion(portFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1737 if (ret != OMX_ErrorNone) {
1738 omx_err_f("version check error");
1739 goto EXIT;
1740 }
1741
1742 if ((portIndex >= pRockchipComponent->portParam.nPorts)) {
1743 omx_err_f("protIndex is %d", portIndex);
1744 ret = OMX_ErrorBadPortIndex;
1745 goto EXIT;
1746 } else {
1747 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1748 portDefinition = &pRockchipPort->portDefinition;
1749
1750 portDefinition->format.video.eColorFormat = portFormat->eColorFormat;
1751 portDefinition->format.video.eCompressionFormat = portFormat->eCompressionFormat;
1752 portDefinition->format.video.xFramerate = portFormat->xFramerate;
1753
1754 omx_trace("portIndex:%lu, portFormat->eColorFormat:0x%x", portIndex, portFormat->eColorFormat);
1755 }
1756 }
1757 break;
1758 case OMX_IndexParamPortDefinition: {
1759 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition =
1760 (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
1761 OMX_U32 portIndex = pPortDefinition->nPortIndex;
1762 ROCKCHIP_OMX_BASEPORT *pRockchipPort;
1763
1764 if (portIndex >= pRockchipComponent->portParam.nPorts) {
1765 omx_err_f("protIndex is %d", portIndex);
1766 ret = OMX_ErrorBadPortIndex;
1767 goto EXIT;
1768 }
1769 ret = Rockchip_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1770 if (ret != OMX_ErrorNone) {
1771 omx_err_f("version check error");
1772 goto EXIT;
1773 }
1774
1775 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1776
1777 if ((pRockchipComponent->currentState != OMX_StateLoaded) &&
1778 (pRockchipComponent->currentState != OMX_StateWaitForResources)) {
1779 if (pRockchipPort->portDefinition.bEnabled == OMX_TRUE) {
1780 omx_err_f("portDefinition.bEnabled is TRUE");
1781 ret = OMX_ErrorIncorrectStateOperation;
1782 goto EXIT;
1783 }
1784 }
1785
1786 ret = Rkvpu_UpdatePortDefinition(hComponent, pPortDefinition, portIndex);
1787 if (OMX_ErrorNone != ret) {
1788 omx_err_f("Rkvpu_UpdatePortDefinition ret error");
1789 goto EXIT;
1790 }
1791 }
1792 break;
1793 #ifdef OHOS_BUFFER_HANDLE
1794 case OMX_IndexParamUseBufferType: {
1795 struct UseBufferType *bufferType = (struct UseBufferType *)ComponentParameterStructure;
1796 if (bufferType == NULL) {
1797 omx_err_f("bufferType is null");
1798 ret = OMX_ErrorBadParameter;
1799 goto EXIT;
1800 }
1801
1802 OMX_U32 portIndex = bufferType->portIndex;
1803 if (portIndex >= pRockchipComponent->portParam.nPorts) {
1804 omx_err_f("portIndex is %d", portIndex);
1805 ret = OMX_ErrorBadPortIndex;
1806 goto EXIT;
1807 }
1808 ret = Rockchip_OMX_Check_SizeVersion(bufferType, sizeof(struct UseBufferType));
1809 if (ret != OMX_ErrorNone) {
1810 omx_err_f("check version ret err");
1811 goto EXIT;
1812 }
1813 if (((bufferType->bufferType & CODEC_BUFFER_TYPE_HANDLE) == CODEC_BUFFER_TYPE_HANDLE) &&
1814 portIndex == OUTPUT_PORT_INDEX) {
1815 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1816 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1817 pVideoDec->bOhosBufferHandle = OMX_TRUE;
1818 }
1819 break;
1820 }
1821 case OMX_IndexCodecVideoPortFormat: {
1822 struct CodecVideoPortFormatParam *videoFormat =
1823 (struct CodecVideoPortFormatParam *)ComponentParameterStructure;
1824 if (videoFormat == NULL) {
1825 omx_err_f("videoFormat is null");
1826 ret = OMX_ErrorBadParameter;
1827 goto EXIT;
1828 }
1829 OMX_U32 portIndex = videoFormat->portIndex;
1830 if (portIndex >= pRockchipComponent->portParam.nPorts) {
1831 omx_err_f("portIndex is %d", portIndex);
1832 ret = OMX_ErrorBadPortIndex;
1833 goto EXIT;
1834 }
1835 ret = Rockchip_OMX_Check_SizeVersion(videoFormat, sizeof(struct CodecVideoPortFormatParam));
1836 if (ret != OMX_ErrorNone) {
1837 omx_err_f("check version ret err");
1838 goto EXIT;
1839 }
1840 ROCKCHIP_OMX_BASEPORT *pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
1841 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = &pRockchipPort->portDefinition;
1842 portDefinition->format.video.eColorFormat =
1843 Rochip_OSAL_CodecFormat2OmxColorFormat(videoFormat->codecColorFormat);
1844 portDefinition->format.video.xFramerate = videoFormat->framerate;
1845 portDefinition->format.video.eCompressionFormat = videoFormat->codecCompressFormat;
1846 ret = OMX_ErrorNone;
1847 break;
1848 }
1849 case OMX_IndexCodecExtEnableNativeBuffer: {
1850 struct CodecEnableNativeBufferParams *enableParam =
1851 (struct CodecEnableNativeBufferParams *)ComponentParameterStructure;
1852 if (enableParam == NULL) {
1853 omx_err_f("enableParam is null");
1854 ret = OMX_ErrorBadParameter;
1855 goto EXIT;
1856 }
1857
1858 OMX_U32 portIndex = enableParam->portIndex;
1859 if (portIndex != OUTPUT_PORT_INDEX) {
1860 omx_err_f("portIndex is %d", portIndex);
1861 ret = OMX_ErrorBadPortIndex;
1862 goto EXIT;
1863 }
1864 ret = Rockchip_OMX_Check_SizeVersion(enableParam, sizeof(struct CodecEnableNativeBufferParams));
1865 if (ret != OMX_ErrorNone) {
1866 omx_err_f("check version ret err");
1867 goto EXIT;
1868 }
1869 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1870 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1871 pVideoDec->bOhosBufferHandle = enableParam->enable ? OMX_TRUE : OMX_FALSE;
1872 break;
1873 }
1874 #endif
1875 #ifdef USE_ANB
1876 case OMX_IndexParamEnableAndroidBuffers:
1877 omx_trace("OMX_IndexParamEnableAndroidBuffers!!");
1878 case OMX_IndexParamUseAndroidNativeBuffer:
1879 omx_trace("OMX_IndexParamUseAndroidNativeBuffer!!");
1880 case OMX_IndexParamStoreMetaDataBuffer:
1881 omx_trace("OMX_IndexParamStoreMetaDataBuffer!!");
1882 case OMX_IndexParamprepareForAdaptivePlayback:
1883 omx_trace("OMX_IndexParamprepareForAdaptivePlayback!!");
1884 case OMX_IndexParamAllocateNativeHandle: {
1885 omx_trace("OMX_IndexParamAllocateNativeHandle!!");
1886 ret = Rockchip_OSAL_SetANBParameter(hComponent, nIndex, ComponentParameterStructure);
1887 }
1888 break;
1889 #endif
1890
1891 case OMX_IndexParamEnableThumbnailMode: {
1892 ROCKCHIP_OMX_VIDEO_THUMBNAILMODE *pThumbnailMode =
1893 (ROCKCHIP_OMX_VIDEO_THUMBNAILMODE *)ComponentParameterStructure;
1894 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1895 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1896
1897 ret = Rockchip_OMX_Check_SizeVersion(pThumbnailMode, sizeof(ROCKCHIP_OMX_VIDEO_THUMBNAILMODE));
1898 if (ret != OMX_ErrorNone) {
1899 goto EXIT;
1900 }
1901
1902 pVideoDec->bThumbnailMode = pThumbnailMode->bEnable;
1903 if (pVideoDec->bThumbnailMode == OMX_TRUE) {
1904 ROCKCHIP_OMX_BASEPORT *pRockchipOutputPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
1905 pRockchipOutputPort->portDefinition.nBufferCountMin = 1;
1906 pRockchipOutputPort->portDefinition.nBufferCountActual = 1;
1907 }
1908
1909 ret = OMX_ErrorNone;
1910 }
1911 break;
1912
1913 case OMX_IndexParamRkDecoderExtensionDiv3: {
1914 OMX_BOOL *pIsDiv3 = (OMX_BOOL *)ComponentParameterStructure;
1915 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1916 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1917
1918 if ((*pIsDiv3) == OMX_TRUE) {
1919 pVideoDec->flags |= RKVPU_OMX_VDEC_IS_DIV3;
1920 }
1921
1922 ret = OMX_ErrorNone;
1923 }
1924 break;
1925
1926 case OMX_IndexParamRkDecoderExtensionUseDts: {
1927 OMX_BOOL *pUseDtsFlag = (OMX_BOOL *)ComponentParameterStructure;
1928 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1929 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1930
1931 if ((*pUseDtsFlag) == OMX_TRUE) {
1932 pVideoDec->flags |= RKVPU_OMX_VDEC_USE_DTS;
1933 }
1934
1935 ret = OMX_ErrorNone;
1936 }
1937 break;
1938
1939 case OMX_IndexParamRkDecoderExtensionThumbNailCodecProfile: {
1940 OMX_PARAM_U32TYPE *tmp = (OMX_PARAM_U32TYPE *)ComponentParameterStructure;
1941 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
1942 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
1943 pVideoDec->codecProfile = tmp->nU32;
1944
1945 omx_trace("debug omx codecProfile %ld", pVideoDec->codecProfile);
1946
1947 ret = OMX_ErrorNone;
1948 } break;
1949 case OMX_IndexParamStandardComponentRole: {
1950 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)ComponentParameterStructure;
1951
1952 ret = Rockchip_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1953 if (ret != OMX_ErrorNone) {
1954 goto EXIT;
1955 }
1956
1957 if ((pRockchipComponent->currentState != OMX_StateLoaded) &&
1958 (pRockchipComponent->currentState != OMX_StateWaitForResources)) {
1959 ret = OMX_ErrorIncorrectStateOperation;
1960 goto EXIT;
1961 }
1962
1963 if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_H264_DEC_ROLE)) {
1964 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1965 OMX_VIDEO_CodingAVC;
1966 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_MPEG4_DEC_ROLE)) {
1967 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1968 OMX_VIDEO_CodingMPEG4;
1969 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_H263_DEC_ROLE)) {
1970 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1971 OMX_VIDEO_CodingH263;
1972 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_MPEG2_DEC_ROLE)) {
1973 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1974 OMX_VIDEO_CodingMPEG2;
1975 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_VP8_DEC_ROLE)) {
1976 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1977 (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingVP8EXT;
1978 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_VP9_DEC_ROLE)) {
1979 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1980 (OMX_VIDEO_CODINGTYPE)CODEC_OMX_VIDEO_CodingVP9;
1981 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_HEVC_DEC_ROLE)) {
1982 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1983 (OMX_VIDEO_CODINGTYPE)CODEC_OMX_VIDEO_CodingHEVC;
1984 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_FLV_DEC_ROLE)) {
1985 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1986 (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingFLV1;
1987 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_VP6_DEC_ROLE)) {
1988 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1989 (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingVP6;
1990 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_MJPEG_DEC_ROLE)) {
1991 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1992 OMX_VIDEO_CodingMJPEG;
1993 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_VC1_DEC_ROLE)) {
1994 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1995 (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingVC1;
1996 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_WMV3_DEC_ROLE)) {
1997 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
1998 OMX_VIDEO_CodingWMV;
1999 } else if (!Rockchip_OSAL_Strcmp((char*)pComponentRole->cRole, RK_OMX_COMPONENT_RMVB_DEC_ROLE)) {
2000 pRockchipComponent->pRockchipPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat =
2001 OMX_VIDEO_CodingRV;
2002 } else {
2003 ret = OMX_ErrorInvalidComponentName;
2004 goto EXIT;
2005 }
2006 }
2007 break;
2008 case OMX_IndexParamVideoAvc: {
2009 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
2010 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)ComponentParameterStructure;
2011 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
2012 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
2013 ret = Rockchip_OMX_Check_SizeVersion(pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
2014 if (ret != OMX_ErrorNone) {
2015 goto EXIT;
2016 }
2017 if (pSrcAVCComponent->nPortIndex >= ALL_PORT_NUM) {
2018 ret = OMX_ErrorBadPortIndex;
2019 goto EXIT;
2020 }
2021
2022 pDstAVCComponent = &pVideoDec->AVCComponent[pSrcAVCComponent->nPortIndex];
2023
2024 Rockchip_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
2025 }
2026 break;
2027 case OMX_IndexParamVideoProfileLevelCurrent: {
2028 OMX_VIDEO_PARAM_PROFILELEVELTYPE *params =
2029 (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)ComponentParameterStructure;
2030 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec =
2031 (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
2032 if (pVideoDec != NULL) {
2033 if (pVideoDec->codecId == CODEC_OMX_VIDEO_CodingHEVC) {
2034 if (params->eProfile >= CODEC_HEVC_PROFILE_MAIN10) {
2035 pVideoDec->bIs10bit = OMX_TRUE;
2036 }
2037 } else if (pVideoDec->codecId == OMX_VIDEO_CodingAVC) {
2038 if (params->eProfile == OMX_VIDEO_AVCProfileHigh10) {
2039 pVideoDec->bIs10bit = OMX_TRUE;
2040 }
2041 } else if (pVideoDec->codecId == CODEC_OMX_VIDEO_CodingVP9) {
2042 }
2043 }
2044 }
2045 break;
2046 default: {
2047 ret = Rockchip_OMX_SetParameter(hComponent, nIndex, ComponentParameterStructure);
2048 }
2049 break;
2050 }
2051
2052 EXIT:
2053 FunctionOut();
2054 return ret;
2055 }
2056
Rkvpu_OMX_GetConfig(OMX_HANDLETYPE hComponent,OMX_INDEXTYPE nIndex,OMX_PTR pComponentConfigStructure)2057 OMX_ERRORTYPE Rkvpu_OMX_GetConfig(OMX_HANDLETYPE hComponent,
2058 OMX_INDEXTYPE nIndex, OMX_PTR pComponentConfigStructure)
2059 {
2060 FunctionIn();
2061 OMX_ERRORTYPE ret = OMX_ErrorNone;
2062 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2063 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
2064 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2065 if (hComponent == NULL) {
2066 omx_err_f("hComponent is null");
2067 ret = OMX_ErrorBadParameter;
2068 goto EXIT;
2069 }
2070 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2071 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
2072 if (ret != OMX_ErrorNone) {
2073 omx_err_f("check version ret err");
2074 goto EXIT;
2075 }
2076 if (pOMXComponent->pComponentPrivate == NULL) {
2077 omx_err_f("pComponentPrivate is null");
2078 ret = OMX_ErrorBadParameter;
2079 goto EXIT;
2080 }
2081 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2082 if (pComponentConfigStructure == NULL) {
2083 omx_err_f("pComponentConfigStructure is null");
2084 ret = OMX_ErrorBadParameter;
2085 goto EXIT;
2086 }
2087 if (pRockchipComponent->currentState == OMX_StateInvalid) {
2088 omx_err_f("currentState == OMX_StateInvalid");
2089 ret = OMX_ErrorInvalidState;
2090 goto EXIT;
2091 }
2092
2093 pVideoDec = (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
2094 if (pVideoDec == NULL) {
2095 omx_err_f("pVideoDec is null");
2096 ret = OMX_ErrorBadParameter;
2097 goto EXIT;
2098 }
2099 OMX_INDEXEXEXTTYPE nIndexExt = (OMX_INDEXEXEXTTYPE)nIndex;
2100 switch (nIndex) {
2101 #ifdef AVS80
2102 case OMX_IndexConfigCommonOutputCrop: {
2103 OMX_CONFIG_RECTTYPE *rectParams = (OMX_CONFIG_RECTTYPE *)pComponentConfigStructure;
2104 OMX_U32 portIndex = rectParams->nPortIndex;
2105 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
2106 pRockchipPort = &pRockchipComponent->pRockchipPort[portIndex];
2107
2108 if (rectParams->nPortIndex != OUTPUT_PORT_INDEX) {
2109 omx_err_f("nPortIndex is not OUTPUT_PORT_INDEX");
2110 return OMX_ErrorUndefined;
2111 }
2112 /* Avoid rectParams->nWidth and rectParams->nHeight to be set as 0 */
2113 if (pRockchipPort->cropRectangle.nHeight > 0 && pRockchipPort->cropRectangle.nWidth > 0) {
2114 Rockchip_OSAL_Memcpy(rectParams, &(pRockchipPort->cropRectangle), sizeof(OMX_CONFIG_RECTTYPE));
2115 } else {
2116 rectParams->nWidth = rectParams->nHeight = 1;
2117 }
2118 // fbc output buffer offset X/Y
2119 int32_t depth = (pVideoDec->bIs10bit) ? OMX_DEPTH_BIT_10 : OMX_DEPTH_BIT_8;
2120 if (Rockchip_OSAL_Check_Use_FBCMode(pVideoDec->codecId, depth, pRockchipPort)) {
2121 if (pVideoDec->codecId == CODEC_OMX_VIDEO_CodingHEVC
2122 || pVideoDec->codecId == OMX_VIDEO_CodingAVC) {
2123 rectParams->nTop = 4; // 4:value of nTop
2124 }
2125 }
2126 omx_info("rectParams:%d %d %d %d", rectParams->nLeft, rectParams->nTop,
2127 rectParams->nWidth, rectParams->nHeight);
2128 break;
2129 }
2130
2131 #endif
2132 default:
2133 switch (nIndexExt) {
2134 case OMX_IndexParamRkDescribeColorAspects: {
2135 OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS *colorAspectsParams =
2136 (OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS *)pComponentConfigStructure;
2137
2138 ret = Rockchip_OMX_Check_SizeVersion((void *)colorAspectsParams,
2139 sizeof(OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS));
2140 if (ret != OMX_ErrorNone) {
2141 omx_err_f("check version ret err");
2142 goto EXIT;
2143 }
2144 if (colorAspectsParams->nPortIndex != OUTPUT_PORT_INDEX) {
2145 omx_err_f("nPortIndex is not OUTPUT_PORT_INDEX");
2146 return OMX_ErrorBadParameter;
2147 }
2148
2149 colorAspectsParams->sAspects.mRange = pVideoDec->mFinalColorAspects.mRange;
2150 colorAspectsParams->sAspects.mPrimaries = pVideoDec->mFinalColorAspects.mPrimaries;
2151 colorAspectsParams->sAspects.mTransfer = pVideoDec->mFinalColorAspects.mTransfer;
2152 colorAspectsParams->sAspects.mMatrixCoeffs = pVideoDec->mFinalColorAspects.mMatrixCoeffs;
2153
2154 if (colorAspectsParams->bRequestingDataSpace || colorAspectsParams->bDataSpaceChanged) {
2155 omx_err_f("unsupported");
2156 return OMX_ErrorUnsupportedSetting;
2157 }
2158 }
2159 break;
2160 default:
2161 ret = Rockchip_OMX_GetConfig(hComponent, nIndex, pComponentConfigStructure);
2162 break;
2163 }
2164 }
2165
2166 EXIT:
2167 FunctionOut();
2168 return ret;
2169 }
2170
Rkvpu_OMX_SetConfig(OMX_HANDLETYPE hComponent,OMX_INDEXTYPE nIndex,OMX_PTR pComponentConfigStructure)2171 OMX_ERRORTYPE Rkvpu_OMX_SetConfig(OMX_HANDLETYPE hComponent,
2172 OMX_INDEXTYPE nIndex, OMX_PTR pComponentConfigStructure)
2173 {
2174 FunctionIn();
2175 OMX_ERRORTYPE ret = OMX_ErrorNone;
2176 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2177 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
2178 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2179 if (hComponent == NULL) {
2180 omx_err_f("hComponent is null");
2181 ret = OMX_ErrorBadParameter;
2182 goto EXIT;
2183 }
2184 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2185 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
2186 if (ret != OMX_ErrorNone) {
2187 omx_err_f("check version ret err");
2188 goto EXIT;
2189 }
2190 if (pOMXComponent->pComponentPrivate == NULL) {
2191 omx_err_f("pComponentPrivate is null");
2192 ret = OMX_ErrorBadParameter;
2193 goto EXIT;
2194 }
2195 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2196 if (pComponentConfigStructure == NULL) {
2197 omx_err_f("pComponentConfigStructure is null");
2198 ret = OMX_ErrorBadParameter;
2199 goto EXIT;
2200 }
2201 if (pRockchipComponent->currentState == OMX_StateInvalid) {
2202 omx_err_f("currentState == OMX_StateInvalid)");
2203 ret = OMX_ErrorInvalidState;
2204 goto EXIT;
2205 }
2206 pVideoDec = (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
2207 if (pVideoDec == NULL) {
2208 omx_err_f("pVideoDec is null");
2209 ret = OMX_ErrorBadParameter;
2210 goto EXIT;
2211 }
2212 OMX_INDEXEXEXTTYPE nIndexExt = (OMX_INDEXEXEXTTYPE)nIndex;
2213 switch (nIndexExt) {
2214 case OMX_IndexParamRkDescribeColorAspects: {
2215 const OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS* colorAspectsParams =
2216 (const OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS *)pComponentConfigStructure;
2217
2218 ret = Rockchip_OMX_Check_SizeVersion((void *)colorAspectsParams,
2219 sizeof(OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS));
2220 if (ret != OMX_ErrorNone) {
2221 omx_err_f("check version ret err");
2222 goto EXIT;
2223 }
2224 if (colorAspectsParams->nPortIndex != OUTPUT_PORT_INDEX) {
2225 omx_err_f("nPortIndex is not OUTPUT_PORT_INDEX");
2226 return OMX_ErrorBadParameter;
2227 }
2228 // Update color aspects if necessary.
2229 if (colorAspectsDiffer(&colorAspectsParams->sAspects, &pVideoDec->mDefaultColorAspects)) {
2230 pVideoDec->mDefaultColorAspects.mRange = colorAspectsParams->sAspects.mRange;
2231 pVideoDec->mDefaultColorAspects.mPrimaries = colorAspectsParams->sAspects.mPrimaries;
2232 pVideoDec->mDefaultColorAspects.mTransfer = colorAspectsParams->sAspects.mTransfer;
2233 pVideoDec->mDefaultColorAspects.mMatrixCoeffs = colorAspectsParams->sAspects.mMatrixCoeffs;
2234
2235 if (pVideoDec->codecId != OMX_VIDEO_CodingVP8EXT) {
2236 handleColorAspectsChange(&pVideoDec->mDefaultColorAspects /* mDefaultColorAspects */,
2237 &pVideoDec->mBitstreamColorAspects /* mBitstreamColorAspects */,
2238 &pVideoDec->mFinalColorAspects /* mFinalColorAspects */,
2239 kPreferBitstream);
2240 } else {
2241 handleColorAspectsChange(&pVideoDec->mDefaultColorAspects /* mDefaultColorAspects */,
2242 &pVideoDec->mBitstreamColorAspects /* mBitstreamColorAspects */,
2243 &pVideoDec->mFinalColorAspects /* mFinalColorAspects */,
2244 kPreferContainer);
2245 }
2246 }
2247 }
2248 break;
2249 default:
2250 ret = Rockchip_OMX_SetConfig(hComponent, nIndex, pComponentConfigStructure);
2251 break;
2252 }
2253 EXIT:
2254 FunctionOut();
2255 return ret;
2256 }
2257
Rkvpu_OMX_ComponentRoleEnum(OMX_HANDLETYPE hComponent,OMX_U8 * cRole,OMX_U32 nIndex)2258 OMX_ERRORTYPE Rkvpu_OMX_ComponentRoleEnum(OMX_HANDLETYPE hComponent, OMX_U8 *cRole, OMX_U32 nIndex)
2259 {
2260 OMX_ERRORTYPE ret = OMX_ErrorNone;
2261 FunctionIn();
2262 if ((hComponent == NULL) || (cRole == NULL)) {
2263 omx_err_f("hComponent or cRole is null");
2264 ret = OMX_ErrorBadParameter;
2265 goto EXIT;
2266 }
2267 if (nIndex == 0) {
2268 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_H264_DEC_ROLE);
2269 ret = OMX_ErrorNone;
2270 } else if (nIndex == 1) {
2271 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_MPEG4_DEC_ROLE);
2272 ret = OMX_ErrorNone;
2273 } else if (nIndex == 2) { // 2:value of nIndex
2274 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_H263_DEC_ROLE);
2275 ret = OMX_ErrorNone;
2276 } else if (nIndex == 3) { // 3:value of nIndex
2277 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_FLV_DEC_ROLE);
2278 ret = OMX_ErrorNone;
2279 } else if (nIndex == 4) { // 4:value of nIndex
2280 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_MPEG2_DEC_ROLE);
2281 ret = OMX_ErrorNone;
2282 } else if (nIndex == 5) { // 5:value of nIndex
2283 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_RMVB_DEC_ROLE);
2284 ret = OMX_ErrorNone;
2285 } else if (nIndex == 6) { // 6:value of nIndex
2286 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_VP8_DEC_ROLE);
2287 ret = OMX_ErrorNone;
2288 } else if (nIndex == 7) { // 7:value of nIndex
2289 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_VC1_DEC_ROLE);
2290 ret = OMX_ErrorNone;
2291 } else if (nIndex == 8) { // 8:value of nIndex
2292 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_WMV3_DEC_ROLE);
2293 ret = OMX_ErrorNone;
2294 } else if (nIndex == 9) { // 9:value of nIndex
2295 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_VP6_DEC_ROLE);
2296 ret = OMX_ErrorNone;
2297 } else if (nIndex == 10) { // 10:value of nIndex
2298 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_HEVC_DEC_ROLE);
2299 ret = OMX_ErrorNone;
2300 } else if (nIndex == 12) { // 12:value of nIndex
2301 Rockchip_OSAL_Strcpy((char *)cRole, RK_OMX_COMPONENT_H264_DEC_ROLE);
2302 ret = OMX_ErrorNone;
2303 } else {
2304 ret = OMX_ErrorNoMore;
2305 }
2306 EXIT:
2307 FunctionOut();
2308 return ret;
2309 }
2310
Rkvpu_OMX_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_STRING cParameterName,OMX_OUT OMX_INDEXTYPE * pIndexType)2311 OMX_ERRORTYPE Rkvpu_OMX_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,
2312 OMX_IN OMX_STRING cParameterName, OMX_OUT OMX_INDEXTYPE *pIndexType)
2313 {
2314 FunctionIn();
2315 OMX_ERRORTYPE ret = OMX_ErrorNone;
2316 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2317 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
2318 if (hComponent == NULL) {
2319 omx_err_f("hComponentis null");
2320 ret = OMX_ErrorBadParameter;
2321 goto EXIT;
2322 }
2323 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2324 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
2325 if (ret != OMX_ErrorNone) {
2326 omx_err_f("check version ret err");
2327 goto EXIT;
2328 }
2329
2330 if (pOMXComponent->pComponentPrivate == NULL) {
2331 omx_err_f("pComponentPrivate null");
2332 ret = OMX_ErrorBadParameter;
2333 goto EXIT;
2334 }
2335 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2336
2337 if ((cParameterName == NULL) || (pIndexType == NULL)) {
2338 omx_err_f("cParameterName or pIndexType null");
2339 ret = OMX_ErrorBadParameter;
2340 goto EXIT;
2341 }
2342 if (pRockchipComponent->currentState == OMX_StateInvalid) {
2343 omx_err_f("currentState == OMX_StateInvalid");
2344 ret = OMX_ErrorInvalidState;
2345 goto EXIT;
2346 }
2347 #ifdef USE_ANB
2348 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_ENABLE_ANB) == 0) {
2349 *pIndexType = (OMX_INDEXTYPE) OMX_IndexParamEnableAndroidBuffers;
2350 goto EXIT;
2351 }
2352 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_GET_ANB_Usage) == 0) {
2353 *pIndexType = (OMX_INDEXTYPE) OMX_IndexParamGetAndroidNativeBufferUsage;
2354 goto EXIT;
2355 }
2356 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_USE_ANB) == 0) {
2357 *pIndexType = (OMX_INDEXTYPE) NULL; // OMX_IndexParamUseAndroidNativeBuffer;
2358 goto EXIT;
2359 }
2360
2361 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PREPARE_ADAPTIVE_PLAYBACK) == 0) {
2362 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamprepareForAdaptivePlayback;
2363 goto EXIT;
2364 }
2365 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_DESCRIBE_COLORFORMAT) == 0) {
2366 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamdescribeColorFormat;
2367 goto EXIT;
2368 }
2369 #endif
2370
2371 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
2372 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamEnableThumbnailMode;
2373 goto EXIT;
2374 }
2375 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_ROCKCHIP_DEC_EXTENSION_DIV3) == 0) {
2376 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamRkDecoderExtensionDiv3;
2377 goto EXIT;
2378 }
2379 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_ROCKCHIP_DEC_EXTENSION_THUMBNAILCODECPROFILE) == 0) {
2380 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamRkDecoderExtensionThumbNailCodecProfile;
2381 goto EXIT;
2382 }
2383 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_ROCKCHIP_DEC_EXTENSION_USE_DTS) == 0) {
2384 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamRkDecoderExtensionUseDts;
2385 goto EXIT;
2386 }
2387 #ifdef USE_STOREMETADATA
2388 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
2389 *pIndexType = (OMX_INDEXTYPE) NULL;
2390 goto EXIT;
2391 }
2392 #endif
2393
2394 #ifdef AVS80
2395 #ifdef HAVE_L1_SVP_MODE
2396 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_ALLOCATENATIVEHANDLE) == 0) {
2397 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamAllocateNativeHandle;
2398 goto EXIT;
2399 }
2400 #endif
2401 #endif
2402 if (Rockchip_OSAL_Strcmp(cParameterName, ROCKCHIP_INDEX_PARAM_DSECRIBECOLORASPECTS) == 0) {
2403 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamRkDescribeColorAspects;
2404 goto EXIT;
2405 }
2406
2407 ret = Rockchip_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
2408
2409 EXIT:
2410 FunctionOut();
2411 return ret;
2412 }
2413
Rkvpu_UpdatePortDefinition(OMX_HANDLETYPE hComponent,const OMX_PARAM_PORTDEFINITIONTYPE * pPortDefinition,const OMX_U32 nPortIndex)2414 OMX_ERRORTYPE Rkvpu_UpdatePortDefinition(
2415 OMX_HANDLETYPE hComponent,
2416 const OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition,
2417 const OMX_U32 nPortIndex)
2418 {
2419 OMX_ERRORTYPE ret = OMX_ErrorNone;
2420 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2421 ROCKCHIP_OMX_BASECOMPONENT *pRockchipComponent = NULL;
2422 ROCKCHIP_OMX_BASEPORT *pRockchipPort = NULL;
2423 RKVPU_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2424 OMX_U32 nFrameWidth = 0;
2425 OMX_U32 nFrameHeight = 0;
2426 OMX_S32 nStride = 0;
2427 OMX_U32 nSliceHeight = 0;
2428
2429 FunctionIn();
2430
2431 if (hComponent == NULL) {
2432 omx_err("error in");
2433 ret = OMX_ErrorBadParameter;
2434 goto EXIT;
2435 }
2436 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2437 ret = Rockchip_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
2438 if (ret != OMX_ErrorNone) {
2439 omx_err("error in");
2440 goto EXIT;
2441 }
2442
2443 pRockchipComponent = (ROCKCHIP_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2444 if (pRockchipComponent == NULL) {
2445 omx_err("error in");
2446 ret = OMX_ErrorBadParameter;
2447 goto EXIT;
2448 }
2449
2450 pRockchipPort = &pRockchipComponent->pRockchipPort[nPortIndex];
2451 if (pRockchipPort == NULL) {
2452 omx_err("error in");
2453 ret = OMX_ErrorBadParameter;
2454 goto EXIT;
2455 }
2456
2457 pVideoDec = (RKVPU_OMX_VIDEODEC_COMPONENT *)pRockchipComponent->hComponentHandle;
2458 if (pVideoDec == NULL) {
2459 omx_err("error in");
2460 ret = OMX_ErrorBadParameter;
2461 goto EXIT;
2462 }
2463
2464 /*
2465 * check set param legal
2466 */
2467 ret = Rkvpu_CheckPortDefinition(pPortDefinition, &pRockchipPort->portDefinition, nPortIndex);
2468 if (OMX_ErrorNone != ret) {
2469 pRockchipPort->portDefinition.nBufferCountActual = pPortDefinition->nBufferCountActual;
2470 }
2471
2472 Rockchip_OSAL_Memcpy((OMX_PTR)&pRockchipPort->portDefinition, (OMX_PTR)pPortDefinition, pPortDefinition->nSize);
2473
2474 nFrameWidth = pRockchipPort->portDefinition.format.video.nFrameWidth;
2475 nFrameHeight = pRockchipPort->portDefinition.format.video.nFrameHeight;
2476
2477 nStride = Get_Video_HorAlign(pVideoDec->codecId, nFrameWidth, nFrameHeight, pVideoDec->codecProfile);
2478 nSliceHeight = Get_Video_VerAlign(pVideoDec->codecId, nFrameHeight, pVideoDec->codecProfile);
2479
2480 omx_trace("[%s:%d] nStride = %ld,nSliceHeight = %lu", __func__, __LINE__, nStride, nSliceHeight);
2481
2482 pRockchipPort->portDefinition.format.video.nStride = nStride;
2483 pRockchipPort->portDefinition.format.video.nSliceHeight = nSliceHeight;
2484 if (INPUT_PORT_INDEX == nPortIndex) {
2485 /*
2486 * Determining the compression ratio by coding type.
2487 */
2488 pRockchipPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2489 {
2490 /*
2491 * update output port info from input port.
2492 */
2493 ROCKCHIP_OMX_BASEPORT *pRockchipOutputPort = &pRockchipComponent->pRockchipPort[OUTPUT_PORT_INDEX];
2494 pRockchipOutputPort->portDefinition.format.video.nFrameWidth =
2495 pRockchipPort->portDefinition.format.video.nFrameWidth;
2496 pRockchipOutputPort->portDefinition.format.video.nFrameHeight =
2497 pRockchipPort->portDefinition.format.video.nFrameHeight;
2498 pRockchipOutputPort->portDefinition.format.video.nStride = nStride;
2499 pRockchipOutputPort->portDefinition.format.video.nSliceHeight = nSliceHeight;
2500 #ifdef AVS80
2501 Rockchip_OSAL_Memset(&(pRockchipOutputPort->cropRectangle), 0, sizeof(OMX_CONFIG_RECTTYPE));
2502 pRockchipOutputPort->cropRectangle.nWidth = pRockchipOutputPort->portDefinition.format.video.nFrameWidth;
2503 pRockchipOutputPort->cropRectangle.nHeight = pRockchipOutputPort->portDefinition.format.video.nFrameHeight;
2504 omx_info("cropRectangle.nWidth: %d, height: %d", pRockchipOutputPort->cropRectangle.nWidth,
2505 pRockchipOutputPort->cropRectangle.nHeight);
2506 pRockchipComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2507 pRockchipComponent->callbackData,
2508 OMX_EventPortSettingsChanged,
2509 OUTPUT_PORT_INDEX,
2510 OMX_IndexConfigCommonOutputCrop,
2511 NULL);
2512 #endif
2513 switch ((OMX_U32)pRockchipOutputPort->portDefinition.format.video.eColorFormat) {
2514 case OMX_COLOR_FormatYUV420Planar:
2515 case OMX_COLOR_FormatYUV420SemiPlanar:
2516 pRockchipOutputPort->portDefinition.nBufferSize =
2517 nStride * nSliceHeight * 3 / 2; // 3:byte alignment, 2:byte alignment
2518 omx_trace("%s nStride = %ld,nSliceHeight = %lu", __func__, nStride, nSliceHeight);
2519 break;
2520 #ifdef OHOS_BUFFER_HANDLE
2521 case CODEC_COLOR_FORMAT_RGBA8888:
2522 case OMX_COLOR_Format32bitBGRA8888: {
2523 omx_trace("%s rgba/bgra nStride = %ld,nSliceHeight = %lu", __func__, nStride, nSliceHeight);
2524 pRockchipOutputPort->portDefinition.nBufferSize = nStride * nSliceHeight * 4; // 4:byte alignment
2525 break;
2526 }
2527 #endif
2528 #ifdef USE_STOREMETADATA
2529 /*
2530 * this case used RGBA buffer size
2531 */
2532 case OMX_COLOR_FormatAndroidOpaque:
2533 pRockchipOutputPort->portDefinition.nBufferSize = nStride * nSliceHeight * 4; // 4:byte alignment
2534 if (pVideoDec->bPvr_Flag == OMX_TRUE) {
2535 pRockchipOutputPort->portDefinition.format.video.eColorFormat =
2536 (OMX_COLOR_FORMATTYPE)HAL_PIXEL_FORMAT_BGRA_8888;
2537 } else {
2538 pRockchipOutputPort->portDefinition.format.video.eColorFormat =
2539 (OMX_COLOR_FORMATTYPE)HAL_PIXEL_FORMAT_RGBA_8888;
2540 }
2541 break;
2542 #endif
2543 default:
2544 omx_err("Color format is not support!! use default YUV size!");
2545 ret = OMX_ErrorUnsupportedSetting;
2546 break;
2547 }
2548 }
2549 }
2550
2551 if (OUTPUT_PORT_INDEX == nPortIndex) {
2552 int32_t depth = (pVideoDec->bIs10bit) ? OMX_DEPTH_BIT_10 : OMX_DEPTH_BIT_8;
2553 OMX_BOOL fbcMode = Rockchip_OSAL_Check_Use_FBCMode(pVideoDec->codecId, depth, pRockchipPort);
2554 OMX_COLOR_FORMATTYPE format = pRockchipPort->portDefinition.format.video.eColorFormat;
2555 #ifdef OHOS_BUFFER_HANDLE
2556 if (format == CODEC_COLOR_FORMAT_RGBA8888 || format == OMX_COLOR_Format32bitBGRA8888) {
2557 omx_trace("%s rgba/bgra nStride = %ld,nSliceHeight = %lu", __func__, nStride, nSliceHeight);
2558 pRockchipPort->portDefinition.nBufferSize = nStride * nSliceHeight * 4; // 4: byte alignment
2559 }
2560 #endif
2561 if (fbcMode) {
2562 // fbc stride default 64 align
2563 nStride = (nFrameWidth + 63) & (~63); // 63:byte alignment
2564 pRockchipPort->portDefinition.format.video.nStride = nStride;
2565
2566 if (format == OMX_COLOR_FormatYUV420Planar || format == OMX_COLOR_FormatYUV420SemiPlanar) {
2567 pRockchipPort->portDefinition.format.video.eColorFormat
2568 = (OMX_COLOR_FORMATTYPE)HAL_PIXEL_FORMAT_YUV420_8BIT_I;
2569 } else if (format == OMX_COLOR_FormatYUV422Planar || format == OMX_COLOR_FormatYUV422SemiPlanar) {
2570 pRockchipPort->portDefinition.format.video.eColorFormat
2571 = (OMX_COLOR_FORMATTYPE)HAL_PIXEL_FORMAT_YCbCr_422_I;
2572 }
2573 }
2574 omx_info("update output PortDefinition [%d,%d,%d,%d], eColorFormat 0x%x->0x%x",
2575 (int)nFrameWidth, (int)nFrameHeight, (int)nStride, (int)nSliceHeight, format,
2576 pRockchipPort->portDefinition.format.video.eColorFormat);
2577 }
2578
2579 /*
2580 * compute buffer count if need
2581 */
2582 ret = Rkvpu_ComputeDecBufferCount(hComponent);
2583 if (OMX_ErrorNone != ret) {
2584 goto EXIT;
2585 }
2586
2587 EXIT:
2588 FunctionOut();
2589
2590 return ret;
2591 }
2592
Rkvpu_GetCompressRatioByCodingtype(OMX_VIDEO_CODINGTYPE codingType)2593 OMX_U32 Rkvpu_GetCompressRatioByCodingtype(
2594 OMX_VIDEO_CODINGTYPE codingType)
2595 {
2596 OMX_U32 nCompressRatio = 1;
2597 OMX_U32 codingTypeWithExt = (OMX_U32)codingType;
2598 switch (codingTypeWithExt) {
2599 case OMX_VIDEO_CodingAVC:
2600 nCompressRatio = 2; // 2:value of nCompressRatio
2601 break;
2602 case CODEC_OMX_VIDEO_CodingHEVC:
2603 case CODEC_OMX_VIDEO_CodingVP9:
2604 nCompressRatio = 4; // 4:value of nCompressRatio
2605 break;
2606 default:
2607 nCompressRatio = 2; // 2:value of nCompressRatio
2608 break;
2609 }
2610
2611 return nCompressRatio;
2612 }
2613
Rkvpu_CheckPortDefinition(const OMX_PARAM_PORTDEFINITIONTYPE * pNewPortDefinition,const OMX_PARAM_PORTDEFINITIONTYPE * pPortDefinition,const OMX_U32 nPortIndex)2614 OMX_ERRORTYPE Rkvpu_CheckPortDefinition(
2615 const OMX_PARAM_PORTDEFINITIONTYPE *pNewPortDefinition,
2616 const OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition,
2617 const OMX_U32 nPortIndex)
2618 {
2619 OMX_ERRORTYPE ret = OMX_ErrorNone;
2620 OMX_U32 nSupportWidthMax = 0;
2621
2622 FunctionIn();
2623
2624 if (pNewPortDefinition->nBufferCountActual > pPortDefinition->nBufferCountActual) {
2625 omx_err("error: SET buffer count: %d, count min: %d "
2626 "NOW buffer count: %d, count min: %d",
2627 (int)pNewPortDefinition->nBufferCountActual,
2628 (int)pNewPortDefinition->nBufferCountMin,
2629 (int)pPortDefinition->nBufferCountActual,
2630 (int)pPortDefinition->nBufferCountMin);
2631 ret = OMX_ErrorBadParameter;
2632 goto EXIT;
2633 }
2634
2635 if (INPUT_PORT_INDEX == nPortIndex) {
2636 if (pNewPortDefinition->format.video.eCompressionFormat == OMX_VIDEO_CodingUnused) {
2637 omx_err("error: input conding type is OMX_VIDEO_CodingUnused!");
2638 ret = OMX_ErrorBadParameter;
2639 goto EXIT;
2640 }
2641 nSupportWidthMax = VPUCheckSupportWidth();
2642 if (nSupportWidthMax == 0) {
2643 omx_warn("VPUCheckSupportWidth is failed , force max width to 4096.");
2644 nSupportWidthMax = 4096; // 4096:value of nSupportWidthMax
2645 }
2646
2647 if (pNewPortDefinition->format.video.nFrameWidth > nSupportWidthMax) {
2648 if (access("/dev/rkvdec", 06) != 0) { // 06:access para
2649 omx_err("decoder width %d big than support width %d return error",
2650 (int)pNewPortDefinition->format.video.nFrameWidth,
2651 (int)nSupportWidthMax);
2652 ret = OMX_ErrorBadParameter;
2653 goto EXIT;
2654 }
2655 if (pNewPortDefinition->format.video.eCompressionFormat == CODEC_OMX_VIDEO_CodingHEVC ||
2656 pNewPortDefinition->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC ||
2657 pNewPortDefinition->format.video.eCompressionFormat == CODEC_OMX_VIDEO_CodingVP9) {
2658 nSupportWidthMax = 4096; // 4096:value of nSupportWidthMax
2659 } else {
2660 omx_err("decoder width %d big than support width %d return error",
2661 (int)pNewPortDefinition->format.video.nFrameWidth,
2662 (int)nSupportWidthMax);
2663 ret = OMX_ErrorBadParameter;
2664 goto EXIT;
2665 }
2666 }
2667 omx_info("decoder width %d support %d",
2668 (int)pNewPortDefinition->format.video.nFrameWidth,
2669 (int)nSupportWidthMax);
2670 }
2671
2672 EXIT:
2673 FunctionOut();
2674
2675 return ret;
2676 }