1 /*
2 * Copyright (C) 2020 Rockchip Electronics Co., Ltd.
3 * Authors:
4 * PutinLee <putin.lee@rock-chips.com>
5 * Cerf Yu <cerf.yu@rock-chips.com>
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20 #ifdef LOG_TAG
21 #undef LOG_TAG
22 #define LOG_TAG "im2d_rga"
23 #else
24 #define LOG_TAG "im2d_rga"
25 #endif
26
27 #include <math.h>
28 #include <sstream>
29
30 #include "RgaUtils.h"
31 #include "utils.h"
32 #include "core/rga_sync.h"
33 #include "core/NormalRga.h"
34 #include "RockchipRga.h"
35 #include "im2d_hardware.h"
36 #include "im2d_impl.h"
37 #include "im2d_log.h"
38 #include "im2d.hpp"
39
40 #ifdef ANDROID
41 using namespace android;
42 #endif
43 using namespace std;
44
45 extern __thread im_context_t g_im2d_context;
46 extern __thread char g_rga_err_str[IM_ERR_MSG_LEN];
47
imStrError_t(IM_STATUS status)48 IM_API const char* imStrError_t(IM_STATUS status) {
49 const char *error_type[] = {
50 "No errors during operation",
51 "Run successfully",
52 "Unsupported function",
53 "Memory overflow",
54 "Invalid parameters",
55 "Illegal parameters",
56 "Version verification failed",
57 "Fatal error",
58 "unkown status"
59 };
60 static __thread char error_str[IM_ERR_MSG_LEN] = "The current error message is empty!";
61 const char *ptr = NULL;
62
63 switch(status) {
64 case IM_STATUS_NOERROR :
65 return error_type[0];
66
67 case IM_STATUS_SUCCESS :
68 return error_type[1];
69
70 case IM_STATUS_NOT_SUPPORTED :
71 ptr = error_type[2];
72 break;
73
74 case IM_STATUS_OUT_OF_MEMORY :
75 ptr = error_type[3];
76 break;
77
78 case IM_STATUS_INVALID_PARAM :
79 ptr = error_type[4];
80 break;
81
82 case IM_STATUS_ILLEGAL_PARAM :
83 ptr = error_type[5];
84 break;
85
86 case IM_STATUS_ERROR_VERSION :
87 ptr = error_type[6];
88 break;
89
90 case IM_STATUS_FAILED :
91 ptr = error_type[7];
92 break;
93
94 default :
95 return error_type[8];
96 }
97
98 snprintf(error_str, IM_ERR_MSG_LEN, "%s: %s", ptr, g_rga_err_str);
99 rga_error_msg_set("No error message, it has been cleared.");
100
101 return error_str;
102 }
103
importbuffer_fd(int fd,int size)104 IM_API rga_buffer_handle_t importbuffer_fd(int fd, int size) {
105 return rga_import_buffer((uint64_t)fd, RGA_DMA_BUFFER, (uint32_t)size);
106 }
107
importbuffer_fd(int fd,im_handle_param_t * param)108 IM_API rga_buffer_handle_t importbuffer_fd(int fd, im_handle_param_t *param) {
109 return rga_import_buffer((uint64_t)fd, RGA_DMA_BUFFER, param);
110 }
111
importbuffer_fd(int fd,int width,int height,int format)112 IM_API rga_buffer_handle_t importbuffer_fd(int fd, int width, int height, int format) {
113 im_handle_param_t param = {(uint32_t)width, (uint32_t)height, (uint32_t)format};
114 return rga_import_buffer((uint64_t)fd, RGA_DMA_BUFFER, ¶m);
115 }
116
importbuffer_virtualaddr(void * va,im_handle_param_t * param)117 IM_API rga_buffer_handle_t importbuffer_virtualaddr(void *va, im_handle_param_t *param) {
118 return rga_import_buffer(ptr_to_u64(va), RGA_VIRTUAL_ADDRESS, param);
119 }
120
importbuffer_virtualaddr(void * va,int size)121 IM_API rga_buffer_handle_t importbuffer_virtualaddr(void *va, int size) {
122 return rga_import_buffer(ptr_to_u64(va), RGA_VIRTUAL_ADDRESS, (uint32_t)size);
123 }
124
importbuffer_virtualaddr(void * va,int width,int height,int format)125 IM_API rga_buffer_handle_t importbuffer_virtualaddr(void *va, int width, int height, int format) {
126 im_handle_param_t param = {(uint32_t)width, (uint32_t)height, (uint32_t)format};
127 return rga_import_buffer(ptr_to_u64(va), RGA_VIRTUAL_ADDRESS, ¶m);
128 }
129
importbuffer_physicaladdr(uint64_t pa,im_handle_param_t * param)130 IM_API rga_buffer_handle_t importbuffer_physicaladdr(uint64_t pa, im_handle_param_t *param) {
131 return rga_import_buffer(pa, RGA_PHYSICAL_ADDRESS, param);
132 }
133
importbuffer_physicaladdr(uint64_t pa,int size)134 IM_API rga_buffer_handle_t importbuffer_physicaladdr(uint64_t pa, int size) {
135 return rga_import_buffer(pa, RGA_PHYSICAL_ADDRESS, (uint32_t)size);
136 }
137
importbuffer_physicaladdr(uint64_t pa,int width,int height,int format)138 IM_API rga_buffer_handle_t importbuffer_physicaladdr(uint64_t pa, int width, int height, int format) {
139 im_handle_param_t param = {(uint32_t)width, (uint32_t)height, (uint32_t)format};
140 return rga_import_buffer(pa, RGA_PHYSICAL_ADDRESS, ¶m);
141 }
142
releasebuffer_handle(rga_buffer_handle_t handle)143 IM_API IM_STATUS releasebuffer_handle(rga_buffer_handle_t handle) {
144 return rga_release_buffer(handle);
145 }
146
147 #undef wrapbuffer_virtualaddr
wrapbuffer_virtualaddr(void * vir_addr,int width,int height,int format,int wstride,int hstride)148 static rga_buffer_t wrapbuffer_virtualaddr(void* vir_addr,
149 int width, int height, int format,
150 int wstride, int hstride) {
151 rga_buffer_t buffer;
152
153 memset(&buffer, 0, sizeof(rga_buffer_t));
154
155 buffer.vir_addr = vir_addr;
156 buffer.width = width;
157 buffer.height = height;
158 buffer.format = format;
159 buffer.wstride = wstride ? wstride : width;
160 buffer.hstride = hstride ? hstride : height;
161
162 return buffer;
163 }
164
165 #undef wrapbuffer_physicaladdr
wrapbuffer_physicaladdr(void * phy_addr,int width,int height,int format,int wstride,int hstride)166 static rga_buffer_t wrapbuffer_physicaladdr(void* phy_addr,
167 int width, int height, int format,
168 int wstride, int hstride) {
169 rga_buffer_t buffer;
170
171 memset(&buffer, 0, sizeof(rga_buffer_t));
172
173 buffer.phy_addr = phy_addr;
174 buffer.width = width;
175 buffer.height = height;
176 buffer.format = format;
177 buffer.wstride = wstride ? wstride : width;
178 buffer.hstride = hstride ? hstride : height;
179
180 return buffer;
181 }
182
183 #undef wrapbuffer_fd
wrapbuffer_fd(int fd,int width,int height,int format,int wstride,int hstride)184 static rga_buffer_t wrapbuffer_fd(int fd,
185 int width, int height, int format,
186 int wstride, int hstride) {
187 rga_buffer_t buffer;
188
189 memset(&buffer, 0, sizeof(rga_buffer_t));
190
191 buffer.fd = fd;
192 buffer.width = width;
193 buffer.height = height;
194 buffer.format = format;
195 buffer.wstride = wstride ? wstride : width;
196 buffer.hstride = hstride ? hstride : height;
197
198 return buffer;
199 }
200
201 #undef wrapbuffer_handle
wrapbuffer_handle(rga_buffer_handle_t handle,int width,int height,int format,int wstride,int hstride)202 IM_API rga_buffer_t wrapbuffer_handle(rga_buffer_handle_t handle,
203 int width, int height, int format,
204 int wstride, int hstride) {
205 rga_buffer_t buffer;
206
207 memset(&buffer, 0, sizeof(rga_buffer_t));
208
209 buffer.handle = handle;
210 buffer.width = width;
211 buffer.height = height;
212 buffer.format = format;
213 buffer.wstride = wstride ? wstride : width;
214 buffer.hstride = hstride ? hstride : height;
215
216 return buffer;
217 }
218
wrapbuffer_handle(rga_buffer_handle_t handle,int width,int height,int format)219 IM_API rga_buffer_t wrapbuffer_handle(rga_buffer_handle_t handle,
220 int width, int height,
221 int format) {
222 return wrapbuffer_handle(handle, width, height, format, width, height);
223 }
224
225 #ifdef ANDROID
importbuffer_GraphicBuffer_handle(buffer_handle_t hnd)226 IM_API rga_buffer_handle_t importbuffer_GraphicBuffer_handle(buffer_handle_t hnd) {
227 int ret = 0;
228 int fd = -1;
229 void *virt_addr = NULL;
230 std::vector<int> dstAttrs;
231 im_handle_param_t param;
232
233 RockchipRga& rkRga(RockchipRga::get());
234
235 ret = RkRgaGetHandleAttributes(hnd, &dstAttrs);
236 if (ret) {
237 IM_LOGE("handle get Attributes fail ret = %d,hnd=%p", ret, &hnd);
238 return -1;
239 }
240
241 param.width = dstAttrs.at(ASTRIDE);
242 param.height = dstAttrs.at(AHEIGHT);
243 param.format = dstAttrs.at(AFORMAT);
244
245 ret = rkRga.RkRgaGetBufferFd(hnd, &fd);
246 if (ret)
247 IM_LOGE("rga_im2d: get buffer fd fail: %s, hnd=%p", strerror(errno), (void*)(hnd));
248
249 if (fd <= 0) {
250 ret = rkRga.RkRgaGetHandleMapCpuAddress(hnd, &virt_addr);
251 if(!virt_addr) {
252 IM_LOGE("invaild GraphicBuffer, can not get fd and virtual address, hnd = %p", (void *)hnd);
253 return -1;
254 } else {
255 return importbuffer_virtualaddr(virt_addr, ¶m);
256 }
257 } else {
258 return importbuffer_fd(fd, ¶m);
259 }
260 }
261
importbuffer_GraphicBuffer(sp<GraphicBuffer> buf)262 IM_API rga_buffer_handle_t importbuffer_GraphicBuffer(sp<GraphicBuffer> buf) {
263 return importbuffer_GraphicBuffer_handle(buf->handle);
264 }
265
266 /*When wrapbuffer_GraphicBuffer and wrapbuffer_AHardwareBuffer are used, */
267 /*it is necessary to check whether fd and virtual address of the return rga_buffer_t are valid parameters*/
wrapbuffer_handle(buffer_handle_t hnd)268 IM_API rga_buffer_t wrapbuffer_handle(buffer_handle_t hnd) {
269 int ret = 0;
270 rga_buffer_t buffer;
271 std::vector<int> dstAttrs;
272
273 RockchipRga& rkRga(RockchipRga::get());
274
275 memset(&buffer, 0, sizeof(rga_buffer_t));
276
277 ret = rkRga.RkRgaGetBufferFd(hnd, &buffer.fd);
278 if (ret)
279 IM_LOGE("rga_im2d: get buffer fd fail: %s, hnd=%p", strerror(errno), (void*)(hnd));
280
281 if (buffer.fd <= 0) {
282 ret = rkRga.RkRgaGetHandleMapCpuAddress(hnd, &buffer.vir_addr);
283 if(!buffer.vir_addr) {
284 IM_LOGE("invaild GraphicBuffer, can not get fd and virtual address, hnd = %p", (void *)hnd);
285 goto INVAILD;
286 }
287 }
288
289 ret = RkRgaGetHandleAttributes(hnd, &dstAttrs);
290 if (ret) {
291 IM_LOGE("handle get Attributes fail, ret = %d,hnd = %p", ret, (void *)hnd);
292 goto INVAILD;
293 }
294
295 buffer.width = dstAttrs.at(AWIDTH);
296 buffer.height = dstAttrs.at(AHEIGHT);
297 buffer.wstride = dstAttrs.at(ASTRIDE);
298 buffer.hstride = dstAttrs.at(AHEIGHT);
299 buffer.format = dstAttrs.at(AFORMAT);
300
301 if (buffer.wstride % 16) {
302 IM_LOGE("Graphicbuffer wstride needs align to 16, please align to 16 or use other buffer types, wstride = %d", buffer.wstride);
303 goto INVAILD;
304 }
305
306 INVAILD:
307 return buffer;
308 }
309
wrapbuffer_GraphicBuffer(sp<GraphicBuffer> buf)310 IM_API rga_buffer_t wrapbuffer_GraphicBuffer(sp<GraphicBuffer> buf) {
311 int ret = 0;
312 rga_buffer_t buffer;
313 std::vector<int> dstAttrs;
314
315 RockchipRga& rkRga(RockchipRga::get());
316
317 memset(&buffer, 0, sizeof(rga_buffer_t));
318
319 ret = rkRga.RkRgaGetBufferFd(buf->handle, &buffer.fd);
320 if (ret)
321 IM_LOGE("rga_im2d: get buffer fd fail: %s, hnd=%p", strerror(errno), (void*)(buf->handle));
322
323 if (buffer.fd <= 0) {
324 ret = rkRga.RkRgaGetHandleMapCpuAddress(buf->handle, &buffer.vir_addr);
325 if(!buffer.vir_addr) {
326 IM_LOGE("invaild GraphicBuffer, can not get fd and virtual address, hnd = %p", (void *)(buf->handle));
327 goto INVAILD;
328 }
329 }
330
331 ret = RkRgaGetHandleAttributes(buf->handle, &dstAttrs);
332 if (ret) {
333 IM_LOGE("handle get Attributes fail, ret = %d, hnd = %p", ret, (void *)(buf->handle));
334 goto INVAILD;
335 }
336
337 buffer.width = dstAttrs.at(AWIDTH);
338 buffer.height = dstAttrs.at(AHEIGHT);
339 buffer.wstride = dstAttrs.at(ASTRIDE);
340 buffer.hstride = dstAttrs.at(AHEIGHT);
341 buffer.format = dstAttrs.at(AFORMAT);
342
343 if (buffer.wstride % 16) {
344 IM_LOGE("Graphicbuffer wstride needs align to 16, please align to 16 or use other buffer types, wstride = %d", buffer.wstride);
345 goto INVAILD;
346 }
347
348 INVAILD:
349 return buffer;
350 }
351
352 #if USE_AHARDWAREBUFFER
353 #include <android/hardware_buffer.h>
importbuffer_AHardwareBuffer(AHardwareBuffer * buf)354 IM_API rga_buffer_handle_t importbuffer_AHardwareBuffer(AHardwareBuffer *buf) {
355 GraphicBuffer *gbuffer = reinterpret_cast<GraphicBuffer*>(buf);
356
357 return importbuffer_GraphicBuffer_handle(gbuffer->handle);
358 }
359
wrapbuffer_AHardwareBuffer(AHardwareBuffer * buf)360 IM_API rga_buffer_t wrapbuffer_AHardwareBuffer(AHardwareBuffer *buf) {
361 int ret = 0;
362 rga_buffer_t buffer;
363 std::vector<int> dstAttrs;
364
365 RockchipRga& rkRga(RockchipRga::get());
366
367 memset(&buffer, 0, sizeof(rga_buffer_t));
368
369 GraphicBuffer *gbuffer = reinterpret_cast<GraphicBuffer*>(buf);
370
371 ret = rkRga.RkRgaGetBufferFd(gbuffer->handle, &buffer.fd);
372 if (ret)
373 IM_LOGE("rga_im2d: get buffer fd fail: %s, hnd=%p", strerror(errno), (void*)(gbuffer->handle));
374
375 if (buffer.fd <= 0) {
376 ret = rkRga.RkRgaGetHandleMapCpuAddress(gbuffer->handle, &buffer.vir_addr);
377 if(!buffer.vir_addr) {
378 IM_LOGE("invaild GraphicBuffer, can not get fd and virtual address, hnd = %p", (void *)(gbuffer->handle));
379 goto INVAILD;
380 }
381 }
382
383 ret = RkRgaGetHandleAttributes(gbuffer->handle, &dstAttrs);
384 if (ret) {
385 IM_LOGE("handle get Attributes fail, ret = %d, hnd = %p", ret, (void *)(gbuffer->handle));
386 goto INVAILD;
387 }
388
389 buffer.width = dstAttrs.at(AWIDTH);
390 buffer.height = dstAttrs.at(AHEIGHT);
391 buffer.wstride = dstAttrs.at(ASTRIDE);
392 buffer.hstride = dstAttrs.at(AHEIGHT);
393 buffer.format = dstAttrs.at(AFORMAT);
394
395 if (buffer.wstride % 16) {
396 IM_LOGE("Graphicbuffer wstride needs align to 16, please align to 16 or use other buffer types, wstride = %d", buffer.wstride);
397 goto INVAILD;
398 }
399
400 INVAILD:
401 return buffer;
402 }
403 #endif
404 #endif
405
querystring(int name)406 IM_API const char* querystring(int name) {
407 bool all_output = 0, all_output_prepared = 0;
408 int rga_version = 0;
409 long usage = 0;
410 enum {
411 RGA_API = 0,
412 };
413 const char *temp;
414 const char *output_vendor = "Rockchip Electronics Co.,Ltd.";
415 const char *output_name[] = {
416 "RGA vendor : ",
417 "RGA version : ",
418 "Max input : ",
419 "Max output : ",
420 "Byte stride : ",
421 "Scale limit : ",
422 "Input support format : ",
423 "output support format : ",
424 "RGA feature : ",
425 "expected performance : ",
426 };
427 const char *version_name[] = {
428 "RGA_api version : ",
429 };
430 const char *output_version[] = {
431 "unknown ",
432 "RGA_1 ",
433 "RGA_1_plus ",
434 "RGA_2 ",
435 "RGA_2_lite0 ",
436 "RGA_2_lite1 ",
437 "RGA_2_Enhance ",
438 "RGA_3 ",
439 };
440 const char *output_resolution[] = {
441 "unknown",
442 "2048x2048",
443 "4096x4096",
444 "8192x8192",
445 "8128x8128",
446 };
447 const char *output_scale_limit[] = {
448 "unknown",
449 "0.125 ~ 8",
450 "0.0625 ~ 16"
451 };
452 const char *output_format[] = {
453 "unknown",
454 "RGBA_8888 RGB_888 RGB_565 ",
455 "RGBA_4444 RGBA_5551 ",
456 "BPP8 BPP4 BPP2 BPP1 ",
457 "YUV420_sp_8bit ",
458 "YUV420_sp_10bit ",
459 "YUV420_p_8bit ",
460 "YUV420_p_10bit ",
461 "YUV422_sp_8bit ",
462 "YUV422_sp_10bit ",
463 "YUV422_p_8bit ",
464 "YUV422_p_10bit ",
465 "YUYV420 ",
466 "YUYV422 ",
467 "YUV400/Y4 "
468 };
469 const char *feature[] = {
470 "unknown ",
471 "color_fill ",
472 "color_palette ",
473 "ROP ",
474 "quantize ",
475 "src1_r2y_csc ",
476 "dst_full_csc ",
477 "FBC_mode ",
478 "blend_in_YUV ",
479 "BT.2020 ",
480 "mosaic ",
481 "OSD ",
482 "early_interruption ",
483 };
484 const char *performance[] = {
485 "unknown",
486 "max 1 pixel/cycle ",
487 "max 2 pixel/cycle ",
488 "max 4 pixel/cycle ",
489 };
490 ostringstream out;
491 static string info;
492
493 rga_info_table_entry rga_info;
494
495 memset(&rga_info, 0x0, sizeof(rga_info));
496 usage = rga_get_info(&rga_info);
497 if (IM_STATUS_FAILED == usage) {
498 IM_LOGE("rga im2d: rga2 get info failed!\n");
499 return "get info failed";
500 }
501
502 do {
503 switch(name) {
504 case RGA_VENDOR :
505 out << output_name[name] << output_vendor << endl;
506 break;
507
508 case RGA_VERSION :
509 out << version_name[RGA_API] << "v" << RGA_API_VERSION << endl;
510
511 out << output_name[name];
512 if (rga_info.version == IM_RGA_HW_VERSION_RGA_V_ERR) {
513 out << output_version[IM_RGA_HW_VERSION_RGA_V_ERR_INDEX];
514 } else {
515 if (rga_info.version & IM_RGA_HW_VERSION_RGA_1)
516 out << output_version[IM_RGA_HW_VERSION_RGA_1_INDEX];
517 if (rga_info.version & IM_RGA_HW_VERSION_RGA_1_PLUS)
518 out << output_version[IM_RGA_HW_VERSION_RGA_1_PLUS_INDEX];
519 if (rga_info.version & IM_RGA_HW_VERSION_RGA_2)
520 out << output_version[IM_RGA_HW_VERSION_RGA_2_INDEX];
521 if (rga_info.version & IM_RGA_HW_VERSION_RGA_2_LITE0)
522 out << output_version[IM_RGA_HW_VERSION_RGA_2_LITE0_INDEX];
523 if (rga_info.version & IM_RGA_HW_VERSION_RGA_2_LITE1)
524 out << output_version[IM_RGA_HW_VERSION_RGA_2_LITE1_INDEX];
525 if (rga_info.version & IM_RGA_HW_VERSION_RGA_2_ENHANCE)
526 out << output_version[IM_RGA_HW_VERSION_RGA_2_ENHANCE_INDEX];
527 if (rga_info.version & IM_RGA_HW_VERSION_RGA_3)
528 out << output_version[IM_RGA_HW_VERSION_RGA_3_INDEX];
529 }
530 out << endl;
531 break;
532
533 case RGA_MAX_INPUT :
534 switch (rga_info.input_resolution) {
535 case 2048 :
536 out << output_name[name] << output_resolution[1] << endl;
537 break;
538 case 4096 :
539 out << output_name[name] << output_resolution[2] << endl;
540 break;
541 case 8192 :
542 out << output_name[name] << output_resolution[3] << endl;
543 break;
544 case 8128 :
545 out << output_name[name] << output_resolution[4] << endl;
546 break;
547 default :
548 out << output_name[name] << output_resolution[IM_RGA_HW_VERSION_RGA_V_ERR_INDEX] << endl;
549 break;
550 }
551 break;
552
553 case RGA_MAX_OUTPUT :
554 switch(rga_info.output_resolution) {
555 case 2048 :
556 out << output_name[name] << output_resolution[1] << endl;
557 break;
558 case 4096 :
559 out << output_name[name] << output_resolution[2] << endl;
560 break;
561 case 8192 :
562 out << output_name[name] << output_resolution[3] << endl;
563 break;
564 case 8128 :
565 out << output_name[name] << output_resolution[4] << endl;
566 break;
567 default :
568 out << output_name[name] << output_resolution[IM_RGA_HW_VERSION_RGA_V_ERR_INDEX] << endl;
569 break;
570 }
571 break;
572
573 case RGA_BYTE_STRIDE :
574 if (rga_info.byte_stride > 0)
575 out << output_name[name] << rga_info.byte_stride << " byte" << endl;
576 else
577 out << output_name[name] << "unknown" << endl;
578
579 break;
580
581 case RGA_SCALE_LIMIT :
582 switch(rga_info.scale_limit) {
583 case 8 :
584 out << output_name[name] << output_scale_limit[1] << endl;
585 break;
586 case 16 :
587 out << output_name[name] << output_scale_limit[2] << endl;
588 break;
589 default :
590 out << output_name[name] << output_scale_limit[IM_RGA_HW_VERSION_RGA_V_ERR_INDEX] << endl;
591 break;
592 }
593 break;
594
595 case RGA_INPUT_FORMAT :
596 out << output_name[name];
597 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_RGB)
598 out << output_format[IM_RGA_SUPPORT_FORMAT_RGB_INDEX];
599 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_RGB_OTHER)
600 out << output_format[IM_RGA_SUPPORT_FORMAT_RGB_OTHER_INDEX];
601 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_BPP)
602 out << output_format[IM_RGA_SUPPORT_FORMAT_BPP_INDEX];
603 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUV_420_SEMI_PLANNER_8_BIT)
604 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_420_SEMI_PLANNER_8_BIT_INDEX];
605 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUV_420_SEMI_PLANNER_10_BIT)
606 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_420_SEMI_PLANNER_10_BIT_INDEX];
607 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUV_420_PLANNER_8_BIT)
608 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_420_PLANNER_8_BIT_INDEX];
609 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUV_420_PLANNER_10_BIT)
610 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_420_PLANNER_10_BIT_INDEX];
611 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUV_422_SEMI_PLANNER_8_BIT)
612 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_422_SEMI_PLANNER_8_BIT_INDEX];
613 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUV_422_SEMI_PLANNER_10_BIT)
614 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_422_SEMI_PLANNER_10_BIT_INDEX];
615 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUV_422_PLANNER_8_BIT)
616 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_422_PLANNER_8_BIT_INDEX];
617 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUV_422_PLANNER_10_BIT)
618 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_422_PLANNER_10_BIT_INDEX];
619 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUYV_420)
620 out << output_format[IM_RGA_SUPPORT_FORMAT_YUYV_420_INDEX];
621 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUYV_422)
622 out << output_format[IM_RGA_SUPPORT_FORMAT_YUYV_422_INDEX];
623 if(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_YUV_400)
624 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_400_INDEX];
625 if(!(rga_info.input_format & IM_RGA_SUPPORT_FORMAT_MASK))
626 out << output_format[IM_RGA_SUPPORT_FORMAT_ERROR_INDEX];
627 out << endl;
628 break;
629
630 case RGA_OUTPUT_FORMAT :
631 out << output_name[name];
632 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_RGB)
633 out << output_format[IM_RGA_SUPPORT_FORMAT_RGB_INDEX];
634 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_RGB_OTHER)
635 out << output_format[IM_RGA_SUPPORT_FORMAT_RGB_OTHER_INDEX];
636 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_BPP)
637 out << output_format[IM_RGA_SUPPORT_FORMAT_BPP_INDEX];
638 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUV_420_SEMI_PLANNER_8_BIT)
639 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_420_SEMI_PLANNER_8_BIT_INDEX];
640 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUV_420_SEMI_PLANNER_10_BIT)
641 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_420_SEMI_PLANNER_10_BIT_INDEX];
642 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUV_420_PLANNER_8_BIT)
643 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_420_PLANNER_8_BIT_INDEX];
644 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUV_420_PLANNER_10_BIT)
645 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_420_PLANNER_10_BIT_INDEX];
646 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUV_422_SEMI_PLANNER_8_BIT)
647 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_422_SEMI_PLANNER_8_BIT_INDEX];
648 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUV_422_SEMI_PLANNER_10_BIT)
649 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_422_SEMI_PLANNER_10_BIT_INDEX];
650 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUV_422_PLANNER_8_BIT)
651 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_422_PLANNER_8_BIT_INDEX];
652 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUV_422_PLANNER_10_BIT)
653 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_422_PLANNER_10_BIT_INDEX];
654 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUYV_420)
655 out << output_format[IM_RGA_SUPPORT_FORMAT_YUYV_420_INDEX];
656 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUYV_422)
657 out << output_format[IM_RGA_SUPPORT_FORMAT_YUYV_422_INDEX];
658 if(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_YUV_400)
659 out << output_format[IM_RGA_SUPPORT_FORMAT_YUV_400_INDEX];
660 if(!(rga_info.output_format & IM_RGA_SUPPORT_FORMAT_MASK))
661 out << output_format[IM_RGA_SUPPORT_FORMAT_ERROR_INDEX];
662 out << endl;
663 break;
664
665 case RGA_FEATURE :
666 out << output_name[name];
667 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_COLOR_FILL)
668 out << feature[IM_RGA_SUPPORT_FEATURE_COLOR_FILL_INDEX];
669 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_COLOR_PALETTE)
670 out << feature[IM_RGA_SUPPORT_FEATURE_COLOR_PALETTE_INDEX];
671 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_ROP)
672 out << feature[IM_RGA_SUPPORT_FEATURE_ROP_INDEX];
673 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_QUANTIZE)
674 out << feature[IM_RGA_SUPPORT_FEATURE_QUANTIZE_INDEX];
675 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_SRC1_R2Y_CSC)
676 out << feature[IM_RGA_SUPPORT_FEATURE_SRC1_R2Y_CSC_INDEX];
677 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_DST_FULL_CSC)
678 out << feature[IM_RGA_SUPPORT_FEATURE_DST_FULL_CSC_INDEX];
679 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_FBC)
680 out << feature[IM_RGA_SUPPORT_FEATURE_FBC_INDEX];
681 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_BLEND_YUV)
682 out << feature[IM_RGA_SUPPORT_FEATURE_BLEND_YUV_INDEX];
683 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_BT2020)
684 out << feature[IM_RGA_SUPPORT_FEATURE_BT2020_INDEX];
685 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_MOSAIC)
686 out << feature[IM_RGA_SUPPORT_FEATURE_MOSAIC_INDEX];
687 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_OSD)
688 out << feature[IM_RGA_SUPPORT_FEATURE_OSD_INDEX];
689 if(rga_info.feature & IM_RGA_SUPPORT_FEATURE_PRE_INTR)
690 out << feature[IM_RGA_SUPPORT_FEATURE_PRE_INTR_INDEX];
691 out << endl;
692 break;
693
694 case RGA_EXPECTED :
695 switch(rga_info.performance) {
696 case 1 :
697 out << output_name[name] << performance[1] << endl;
698 break;
699 case 2 :
700 out << output_name[name] << performance[2] << endl;
701 break;
702 case 4 :
703 out << output_name[name] << performance[3] << endl;
704 break;
705 default :
706 out << output_name[name] << performance[IM_RGA_HW_VERSION_RGA_V_ERR_INDEX] << endl;
707 break;
708 }
709 break;
710
711 case RGA_ALL :
712 if (!all_output) {
713 all_output = 1;
714 name = 0;
715 } else
716 all_output_prepared = 1;
717 break;
718
719 default:
720 return "Invalid instruction";
721 }
722
723 info = out.str();
724
725 if (all_output_prepared)
726 break;
727 else if (all_output && strcmp(info.c_str(),"0")>0)
728 name++;
729
730 } while(all_output);
731
732 temp = info.c_str();
733
734 return temp;
735 }
736
imcheckHeader(im_api_version_t header_version)737 IM_API IM_STATUS imcheckHeader(im_api_version_t header_version) {
738 return rga_check_header(RGA_GET_API_VERSION(header_version));
739 }
740
rga_check_perpare(rga_buffer_t * src,rga_buffer_t * dst,rga_buffer_t * pat,im_rect * src_rect,im_rect * dst_rect,im_rect * pat_rect,int mode_usage)741 void rga_check_perpare(rga_buffer_t *src, rga_buffer_t *dst, rga_buffer_t *pat,
742 im_rect *src_rect, im_rect *dst_rect, im_rect *pat_rect, int mode_usage) {
743 (void)(src);
744 (void)(dst);
745 (void)(pat);
746 (void)(src_rect);
747 (void)(dst_rect);
748 (void)(pat_rect);
749 (void)(mode_usage);
750 }
751
imsync(int fence_fd)752 IM_API IM_STATUS imsync(int fence_fd) {
753 int ret = 0;
754
755 if (fence_fd <= 0) {
756 IM_LOGE("illegal fence_fd[%d]", fence_fd);
757 return IM_STATUS_ILLEGAL_PARAM;
758 }
759
760 ret = rga_sync_wait(fence_fd, -1);
761 if (ret) {
762 IM_LOGE("Failed to wait for out fence = %d, ret = %d", fence_fd, ret);
763 return IM_STATUS_FAILED;
764 }
765
766 close(fence_fd);
767
768 return IM_STATUS_SUCCESS;
769 }
770
imconfig(IM_CONFIG_NAME name,uint64_t value)771 IM_API IM_STATUS imconfig(IM_CONFIG_NAME name, uint64_t value) {
772
773 switch (name) {
774 case IM_CONFIG_SCHEDULER_CORE :
775 if (value & IM_SCHEDULER_MASK) {
776 g_im2d_context.core = (IM_SCHEDULER_CORE)value;
777 } else {
778 IM_LOGE("IM2D: It's not legal rga_core[0x%lx], it needs to be a 'IM_SCHEDULER_CORE'.", (unsigned long)value);
779 return IM_STATUS_ILLEGAL_PARAM;
780 }
781 break;
782 case IM_CONFIG_PRIORITY :
783 if (value <= 6) {
784 g_im2d_context.priority = (int)value;
785 } else {
786 IM_LOGE("IM2D: It's not legal priority[0x%lx], it needs to be a 'int', and it should be in the range of 0~6.", (unsigned long)value);
787 return IM_STATUS_ILLEGAL_PARAM;
788 }
789 break;
790 case IM_CONFIG_CHECK :
791 if (value == false || value == true) {
792 g_im2d_context.check_mode = (bool)value;
793 } else {
794 IM_LOGE("IM2D: It's not legal check config[0x%lx], it needs to be a 'bool'.", (unsigned long)value);
795 return IM_STATUS_ILLEGAL_PARAM;
796 }
797 break;
798 default :
799 IM_LOGE("IM2D: Unsupported config name!");
800 return IM_STATUS_NOT_SUPPORTED;
801 }
802
803 return IM_STATUS_SUCCESS;
804 }
805
806 /* Start single task api */
imcopy(const rga_buffer_t src,rga_buffer_t dst,int sync,int * release_fence_fd)807 IM_API IM_STATUS imcopy(const rga_buffer_t src, rga_buffer_t dst, int sync, int *release_fence_fd) {
808 int usage = 0;
809 IM_STATUS ret = IM_STATUS_NOERROR;
810
811 im_opt_t opt;
812
813 rga_buffer_t pat;
814
815 im_rect srect;
816 im_rect drect;
817 im_rect prect;
818
819 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
820
821 if ((src.width != dst.width) || (src.height != dst.height)) {
822 IM_LOGW("imcopy cannot support scale, src[w,h] = [%d, %d], dst[w,h] = [%d, %d]",
823 src.width, src.height, dst.width, dst.height);
824 return IM_STATUS_INVALID_PARAM;
825 }
826
827 if (sync == 0)
828 usage |= IM_ASYNC;
829 else if (sync == 1)
830 usage |= IM_SYNC;
831
832 ret = improcess(src, dst, pat, srect, drect, prect, -1, release_fence_fd, &opt, usage);
833
834 return ret;
835 }
836
imresize(const rga_buffer_t src,rga_buffer_t dst,double fx,double fy,int interpolation,int sync,int * release_fence_fd)837 IM_API IM_STATUS imresize(const rga_buffer_t src, rga_buffer_t dst, double fx, double fy, int interpolation, int sync, int *release_fence_fd) {
838 int usage = 0;
839 IM_STATUS ret = IM_STATUS_NOERROR;
840
841 im_opt_t opt;
842
843 rga_buffer_t pat;
844
845 im_rect srect;
846 im_rect drect;
847 im_rect prect;
848
849 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
850
851 if (fx > 0 || fy > 0) {
852 if (fx == 0) fx = 1;
853 if (fy == 0) fy = 1;
854
855 dst.width = (int)(src.width * fx);
856 dst.height = (int)(src.height * fy);
857
858 int format = convert_to_rga_format(dst.format);
859 if (format == RK_FORMAT_UNKNOWN) {
860 IM_LOGE("Invaild dst format [0x%x]!\n", dst.format);
861 return IM_STATUS_NOT_SUPPORTED;
862 }
863
864 if(NormalRgaIsYuvFormat(format)) {
865 int width = dst.width;
866 int height = dst.height;
867 dst.width = DOWN_ALIGN(dst.width, 2);
868 dst.height = DOWN_ALIGN(dst.height, 2);
869
870 ret = imcheck(src, dst, srect, drect, usage);
871 if (ret != IM_STATUS_NOERROR) {
872 IM_LOGE("imresize error, factor[fx,fy]=[%lf,%lf], ALIGN[dw,dh]=[%d,%d][%d,%d]", fx, fy, width, height, dst.width, dst.height);
873 return ret;
874 }
875 }
876 }
877 UNUSED(interpolation);
878
879 if (sync == 0)
880 usage |= IM_ASYNC;
881 else if (sync == 1)
882 usage |= IM_SYNC;
883
884 ret = improcess(src, dst, pat, srect, drect, prect, -1, release_fence_fd, &opt, usage);
885
886 return ret;
887 }
888
imcvtcolor(rga_buffer_t src,rga_buffer_t dst,int sfmt,int dfmt,int mode,int sync,int * release_fence_fd)889 IM_API IM_STATUS imcvtcolor(rga_buffer_t src, rga_buffer_t dst, int sfmt, int dfmt, int mode, int sync, int *release_fence_fd) {
890 int usage = 0;
891 IM_STATUS ret = IM_STATUS_NOERROR;
892
893 im_opt_t opt;
894
895 rga_buffer_t pat;
896
897 im_rect srect;
898 im_rect drect;
899 im_rect prect;
900
901 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
902
903 src.format = sfmt;
904 dst.format = dfmt;
905
906 dst.color_space_mode = mode;
907
908 if (sync == 0)
909 usage |= IM_ASYNC;
910 else if (sync == 1)
911 usage |= IM_SYNC;
912
913 ret = improcess(src, dst, pat, srect, drect, prect, -1, release_fence_fd, &opt, usage);
914
915 return ret;
916 }
917
imcrop(const rga_buffer_t src,rga_buffer_t dst,im_rect rect,int sync,int * release_fence_fd)918 IM_API IM_STATUS imcrop(const rga_buffer_t src, rga_buffer_t dst, im_rect rect, int sync, int *release_fence_fd) {
919 int usage = 0;
920 IM_STATUS ret = IM_STATUS_NOERROR;
921
922 im_opt_t opt;
923
924 rga_buffer_t pat;
925
926 im_rect drect;
927 im_rect prect;
928
929 empty_structure(NULL, NULL, &pat, NULL, &drect, &prect, &opt);
930
931 drect.width = rect.width;
932 drect.height = rect.height;
933
934 if (sync == 0)
935 usage |= IM_ASYNC;
936 else if (sync == 1)
937 usage |= IM_SYNC;
938
939 ret = improcess(src, dst, pat, rect, drect, prect, -1, release_fence_fd, &opt, usage);
940
941 return ret;
942 }
943
imtranslate(const rga_buffer_t src,rga_buffer_t dst,int x,int y,int sync,int * release_fence_fd)944 IM_API IM_STATUS imtranslate(const rga_buffer_t src, rga_buffer_t dst, int x, int y, int sync, int *release_fence_fd) {
945 int usage = 0;
946 IM_STATUS ret = IM_STATUS_NOERROR;
947
948 im_opt_t opt;
949
950 rga_buffer_t pat;
951
952 im_rect srect;
953 im_rect drect;
954 im_rect prect;
955
956 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
957
958 if ((src.width != dst.width) || (src.height != dst.height)) {
959 IM_LOGW("The width and height of src and dst need to be equal, src[w,h] = [%d, %d], dst[w,h] = [%d, %d]",
960 src.width, src.height, dst.width, dst.height);
961 return IM_STATUS_INVALID_PARAM;
962 }
963
964 if (sync == 0)
965 usage |= IM_ASYNC;
966 else if (sync == 1)
967 usage |= IM_SYNC;
968
969 srect.width = src.width - x;
970 srect.height = src.height - y;
971 drect.x = x;
972 drect.y = y;
973 drect.width = src.width - x;
974 drect.height = src.height - y;
975
976 ret = improcess(src, dst, pat, srect, drect, prect, -1, release_fence_fd, &opt, usage);
977
978 return ret;
979 }
980
imrotate(const rga_buffer_t src,rga_buffer_t dst,int rotation,int sync,int * release_fence_fd)981 IM_API IM_STATUS imrotate(const rga_buffer_t src, rga_buffer_t dst, int rotation, int sync, int *release_fence_fd) {
982 int usage = 0;
983 IM_STATUS ret = IM_STATUS_NOERROR;
984
985 im_opt_t opt;
986
987 rga_buffer_t pat;
988
989 im_rect srect;
990 im_rect drect;
991 im_rect prect;
992
993 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
994
995 usage |= rotation;
996
997 if (sync == 0)
998 usage |= IM_ASYNC;
999 else if (sync == 1)
1000 usage |= IM_SYNC;
1001
1002 ret = improcess(src, dst, pat, srect, drect, prect, -1, release_fence_fd, &opt, usage);
1003
1004 return ret;
1005 }
1006
imflip(const rga_buffer_t src,rga_buffer_t dst,int mode,int sync,int * release_fence_fd)1007 IM_API IM_STATUS imflip(const rga_buffer_t src, rga_buffer_t dst, int mode, int sync, int *release_fence_fd) {
1008 int usage = 0;
1009 IM_STATUS ret = IM_STATUS_NOERROR;
1010
1011 im_opt_t opt;
1012
1013 rga_buffer_t pat;
1014
1015 im_rect srect;
1016 im_rect drect;
1017 im_rect prect;
1018
1019 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1020
1021 usage |= mode;
1022
1023 if (sync == 0)
1024 usage |= IM_ASYNC;
1025 else if (sync == 1)
1026 usage |= IM_SYNC;
1027
1028 ret = improcess(src, dst, pat, srect, drect, prect, -1, release_fence_fd, &opt, usage);
1029
1030 return ret;
1031 }
1032
imcomposite(const rga_buffer_t srcA,const rga_buffer_t srcB,rga_buffer_t dst,int mode,int sync,int * release_fence_fd)1033 IM_API IM_STATUS imcomposite(const rga_buffer_t srcA, const rga_buffer_t srcB, rga_buffer_t dst, int mode, int sync, int *release_fence_fd) {
1034 int usage = 0;
1035 IM_STATUS ret = IM_STATUS_NOERROR;
1036
1037 im_opt_t opt;
1038
1039 im_rect srect;
1040 im_rect drect;
1041 im_rect prect;
1042
1043 empty_structure(NULL, NULL, NULL, &srect, &drect, &prect, &opt);
1044
1045 usage |= mode;
1046
1047 if (sync == 0)
1048 usage |= IM_ASYNC;
1049 else if (sync == 1)
1050 usage |= IM_SYNC;
1051
1052 ret = improcess(srcA, dst, srcB, srect, drect, prect, -1, release_fence_fd, &opt, usage);
1053
1054 return ret;
1055 }
1056
imblend(const rga_buffer_t src,rga_buffer_t dst,int mode,int sync,int * release_fence_fd)1057 IM_API IM_STATUS imblend(const rga_buffer_t src, rga_buffer_t dst, int mode, int sync, int *release_fence_fd) {
1058 rga_buffer_t pat;
1059
1060 memset(&pat, 0x0, sizeof(pat));
1061
1062 return imcomposite(src, pat, dst, mode, sync, release_fence_fd);
1063 }
1064
imosd(const rga_buffer_t osd,const rga_buffer_t dst,const im_rect osd_rect,im_osd_t * osd_info,int sync,int * release_fence_fd)1065 IM_API IM_STATUS imosd(const rga_buffer_t osd,const rga_buffer_t dst,
1066 const im_rect osd_rect, im_osd_t *osd_info,
1067 int sync, int *release_fence_fd) {
1068 int usage = 0;
1069 im_opt_t opt;
1070 im_rect tmp_rect;
1071
1072 memset(&opt, 0x0, sizeof(opt));
1073 memset(&tmp_rect, 0x0, sizeof(tmp_rect));
1074
1075 opt.version = RGA_CURRENT_API_VERSION;
1076 memcpy(&opt.osd_config, osd_info, sizeof(im_osd_t));
1077
1078 usage |= IM_ALPHA_BLEND_DST_OVER | IM_OSD;
1079
1080 if (sync == 0)
1081 usage |= IM_ASYNC;
1082 else if (sync == 1)
1083 usage |= IM_SYNC;
1084
1085 return improcess(dst, dst, osd, osd_rect, osd_rect, tmp_rect, -1, release_fence_fd, &opt, usage);
1086 }
1087
imcolorkey(const rga_buffer_t src,rga_buffer_t dst,im_colorkey_range range,int mode,int sync,int * release_fence_fd)1088 IM_API IM_STATUS imcolorkey(const rga_buffer_t src, rga_buffer_t dst, im_colorkey_range range, int mode, int sync, int *release_fence_fd) {
1089 int usage = 0;
1090 IM_STATUS ret = IM_STATUS_NOERROR;
1091
1092 im_opt_t opt;
1093
1094 rga_buffer_t pat;
1095
1096 im_rect srect;
1097 im_rect drect;
1098 im_rect prect;
1099
1100 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1101
1102 usage |= mode;
1103
1104 opt.colorkey_range = range;
1105
1106 if (sync == 0)
1107 usage |= IM_ASYNC;
1108 else if (sync == 1)
1109 usage |= IM_SYNC;
1110
1111 ret = improcess(src, dst, pat, srect, drect, prect, -1, release_fence_fd, &opt, usage);
1112
1113 return ret;
1114 }
1115
imquantize(const rga_buffer_t src,rga_buffer_t dst,im_nn_t nn_info,int sync,int * release_fence_fd)1116 IM_API IM_STATUS imquantize(const rga_buffer_t src, rga_buffer_t dst, im_nn_t nn_info, int sync, int *release_fence_fd) {
1117 int usage = 0;
1118 IM_STATUS ret = IM_STATUS_NOERROR;
1119
1120 im_opt_t opt;
1121
1122 rga_buffer_t pat;
1123
1124 im_rect srect;
1125 im_rect drect;
1126 im_rect prect;
1127
1128 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1129
1130 usage |= IM_NN_QUANTIZE;
1131
1132 opt.nn = nn_info;
1133
1134 if (sync == 0)
1135 usage |= IM_ASYNC;
1136 else if (sync == 1)
1137 usage |= IM_SYNC;
1138
1139 ret = improcess(src, dst, pat, srect, drect, prect, -1, release_fence_fd, &opt, usage);
1140
1141 return ret;
1142 }
1143
imrop(const rga_buffer_t src,rga_buffer_t dst,int rop_code,int sync,int * release_fence_fd)1144 IM_API IM_STATUS imrop(const rga_buffer_t src, rga_buffer_t dst, int rop_code, int sync, int *release_fence_fd) {
1145 int usage = 0;
1146 IM_STATUS ret = IM_STATUS_NOERROR;
1147
1148 im_opt_t opt;
1149
1150 rga_buffer_t pat;
1151
1152 im_rect srect;
1153 im_rect drect;
1154 im_rect prect;
1155
1156 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1157
1158 usage |= IM_ROP;
1159
1160 opt.rop_code = rop_code;
1161
1162 if (sync == 0)
1163 usage |= IM_ASYNC;
1164 else if (sync == 1)
1165 usage |= IM_SYNC;
1166
1167 ret = improcess(src, dst, pat, srect, drect, prect, -1, release_fence_fd, &opt, usage);
1168
1169 return ret;
1170 }
1171
immosaic(const rga_buffer_t image,im_rect rect,int mosaic_mode,int sync,int * release_fence_fd)1172 IM_API IM_STATUS immosaic(const rga_buffer_t image, im_rect rect, int mosaic_mode, int sync, int *release_fence_fd) {
1173 IM_STATUS ret = IM_STATUS_NOERROR;
1174 int usage = 0;
1175 im_opt_t opt;
1176 rga_buffer_t tmp_image;
1177 im_rect tmp_rect;
1178
1179 memset(&opt, 0x0, sizeof(opt));
1180 memset(&tmp_image, 0x0, sizeof(tmp_image));
1181 memset(&tmp_rect, 0x0, sizeof(tmp_rect));
1182
1183 usage |= IM_MOSAIC;
1184
1185 opt.version = RGA_CURRENT_API_VERSION;
1186 opt.mosaic_mode = mosaic_mode;
1187
1188 if (sync == 0)
1189 usage |= IM_ASYNC;
1190 else if (sync == 1)
1191 usage |= IM_SYNC;
1192
1193 return improcess(image, image, tmp_image, rect, rect, tmp_rect, -1, release_fence_fd, &opt, usage);
1194 }
1195
immosaicArray(rga_buffer_t dst,im_rect * rect_array,int array_size,int mosaic_mode,int sync,int * release_fence_fd)1196 IM_STATUS immosaicArray(rga_buffer_t dst, im_rect *rect_array, int array_size, int mosaic_mode, int sync, int *release_fence_fd) {
1197 IM_STATUS ret;
1198 int tmp_fence_fd = -1;
1199
1200 for (int i = 0; i < array_size; i++) {
1201 ret = immosaic(dst, rect_array[i], mosaic_mode, sync, release_fence_fd);
1202 if (ret != IM_STATUS_SUCCESS)
1203 return ret;
1204
1205 if (sync == 0 && release_fence_fd) {
1206 if (*release_fence_fd >= 0 && tmp_fence_fd >= 0) {
1207 tmp_fence_fd = rga_sync_merge("mosaic_array", tmp_fence_fd, *release_fence_fd);
1208 } else if (*release_fence_fd >= 0) {
1209 tmp_fence_fd = *release_fence_fd;
1210 }
1211 }
1212 }
1213
1214 if (release_fence_fd)
1215 *release_fence_fd = tmp_fence_fd;
1216
1217 return IM_STATUS_SUCCESS;
1218 }
1219
impalette(rga_buffer_t src,rga_buffer_t dst,rga_buffer_t lut,int sync,int * release_fence_fd)1220 IM_API IM_STATUS impalette(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t lut, int sync, int *release_fence_fd) {
1221 int usage = 0;
1222 IM_STATUS ret = IM_STATUS_NOERROR;
1223 im_rect srect;
1224 im_rect drect;
1225 im_rect prect;
1226
1227 im_opt_t opt;
1228
1229 empty_structure(NULL, NULL, NULL, &srect, &drect, &prect, &opt);
1230
1231 /*Don't know if it supports zooming.*/
1232 if ((src.width != dst.width) || (src.height != dst.height)) {
1233 IM_LOGW("The width and height of src and dst need to be equal, src[w,h] = [%d, %d], dst[w,h] = [%d, %d]",
1234 src.width, src.height, dst.width, dst.height);
1235 return IM_STATUS_INVALID_PARAM;
1236 }
1237
1238 usage |= IM_COLOR_PALETTE;
1239
1240 if (sync == 0)
1241 usage |= IM_ASYNC;
1242 else if (sync == 1)
1243 usage |= IM_SYNC;
1244
1245 ret = improcess(src, dst, lut, srect, drect, prect, -1, release_fence_fd, &opt, usage);
1246
1247 return ret;
1248 }
1249
imfill(rga_buffer_t dst,im_rect rect,int color,int sync,int * release_fence_fd)1250 IM_API IM_STATUS imfill(rga_buffer_t dst, im_rect rect, int color, int sync, int *release_fence_fd) {
1251 int usage = 0;
1252 IM_STATUS ret = IM_STATUS_NOERROR;
1253
1254 im_opt_t opt;
1255
1256 rga_buffer_t pat;
1257 rga_buffer_t src;
1258
1259 im_rect srect;
1260 im_rect prect;
1261
1262 empty_structure(&src, NULL, &pat, &srect, NULL, &prect, &opt);
1263
1264 memset(&src, 0, sizeof(rga_buffer_t));
1265
1266 usage |= IM_COLOR_FILL;
1267
1268 opt.color = color;
1269
1270 if (sync == 0)
1271 usage |= IM_ASYNC;
1272 else if (sync == 1)
1273 usage |= IM_SYNC;
1274
1275 ret = improcess(src, dst, pat, srect, rect, prect, -1, release_fence_fd, &opt, usage);
1276
1277 return ret;
1278 }
1279
imfillArray(rga_buffer_t dst,im_rect * rect_array,int array_size,uint32_t color,int sync,int * release_fence_fd)1280 IM_STATUS imfillArray(rga_buffer_t dst, im_rect *rect_array, int array_size, uint32_t color, int sync, int *release_fence_fd) {
1281 IM_STATUS ret;
1282 int tmp_fence_fd = -1;
1283
1284 for (int i = 0; i < array_size; i++) {
1285 ret = imfill(dst, rect_array[i], color, sync, release_fence_fd);
1286 if (ret != IM_STATUS_SUCCESS)
1287 return ret;
1288
1289 if (sync == 0 && release_fence_fd) {
1290 if (*release_fence_fd >= 0 && tmp_fence_fd >= 0) {
1291 tmp_fence_fd = rga_sync_merge("fill_array", tmp_fence_fd, *release_fence_fd);
1292 } else if (*release_fence_fd >= 0) {
1293 tmp_fence_fd = *release_fence_fd;
1294 }
1295 }
1296 }
1297
1298 if (release_fence_fd)
1299 *release_fence_fd = tmp_fence_fd;
1300
1301 return IM_STATUS_SUCCESS;
1302 }
1303
imrectangle(rga_buffer_t dst,im_rect rect,uint32_t color,int thickness,int sync,int * release_fence_fd)1304 IM_STATUS imrectangle(rga_buffer_t dst, im_rect rect, uint32_t color, int thickness, int sync, int *release_fence_fd) {
1305 if (thickness < 0)
1306 return imfill(dst, rect, color, sync, release_fence_fd);
1307
1308 int h_length = rect.width;
1309 int v_length = rect.height - 2 * thickness;
1310 im_rect fill_rect[4] = {};
1311
1312 fill_rect[0] = {rect.x, rect.y, h_length, thickness};
1313 fill_rect[1] = {rect.x, rect.y + (rect.height - thickness), h_length, thickness};
1314 fill_rect[2] = {rect.x, rect.y + thickness, thickness, v_length};
1315 fill_rect[3] = {rect.x + (rect.width - thickness), rect.y + thickness, thickness, v_length};
1316
1317 return imfillArray(dst, fill_rect, 4, color, sync, release_fence_fd);
1318 }
1319
imrectangleArray(rga_buffer_t dst,im_rect * rect_array,int array_size,uint32_t color,int thickness,int sync,int * release_fence_fd)1320 IM_STATUS imrectangleArray(rga_buffer_t dst, im_rect *rect_array, int array_size, uint32_t color, int thickness, int sync, int *release_fence_fd) {
1321 IM_STATUS ret;
1322 int tmp_fence_fd = -1;
1323
1324 for (int i = 0; i < array_size; i++) {
1325 ret = imrectangle(dst, rect_array[i], color, thickness, sync, release_fence_fd);
1326 if (ret != IM_STATUS_SUCCESS)
1327 return ret;
1328
1329 if (sync == 0 && release_fence_fd) {
1330 if (*release_fence_fd >= 0 && tmp_fence_fd >= 0) {
1331 tmp_fence_fd = rga_sync_merge("rectangle_array", tmp_fence_fd, *release_fence_fd);
1332 } else if (*release_fence_fd >= 0) {
1333 tmp_fence_fd = *release_fence_fd;
1334 }
1335 }
1336 }
1337
1338 if (release_fence_fd)
1339 *release_fence_fd = tmp_fence_fd;
1340
1341 return IM_STATUS_SUCCESS;
1342 }
1343
improcess(rga_buffer_t src,rga_buffer_t dst,rga_buffer_t pat,im_rect srect,im_rect drect,im_rect prect,int usage)1344 IM_API IM_STATUS improcess(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat,
1345 im_rect srect, im_rect drect, im_rect prect, int usage) {
1346 return rga_single_task_submit(src, dst, pat, srect, drect, prect, -1, NULL, NULL, usage);
1347 }
1348
improcess(rga_buffer_t src,rga_buffer_t dst,rga_buffer_t pat,im_rect srect,im_rect drect,im_rect prect,int acquire_fence_fd,int * release_fence_fd,im_opt_t * opt_ptr,int usage)1349 IM_API IM_STATUS improcess(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat,
1350 im_rect srect, im_rect drect, im_rect prect,
1351 int acquire_fence_fd, int *release_fence_fd, im_opt_t *opt_ptr, int usage) {
1352 return rga_single_task_submit(src, dst, pat, srect, drect, prect,
1353 acquire_fence_fd, release_fence_fd,
1354 opt_ptr, usage);
1355 }
1356 /* End single task api */
1357
immakeBorder(rga_buffer_t src,rga_buffer_t dst,int top,int bottom,int left,int right,int border_type,int value,int sync,int acquir_fence_fd,int * release_fence_fd)1358 IM_STATUS immakeBorder(rga_buffer_t src, rga_buffer_t dst,
1359 int top, int bottom, int left, int right,
1360 int border_type, int value,
1361 int sync, int acquir_fence_fd, int *release_fence_fd) {
1362 IM_STATUS ret;
1363 im_job_handle_t job_handle;
1364 im_rect border_rect[4], border_src_rect[4];
1365 bool reflect;
1366 int copy_fence_fd = -1, tmp_fence_fd = -1;
1367
1368 if (sync != 1 && release_fence_fd == NULL) {
1369 IM_LOGE("async mode, address of release_fence_fd cannot be NULL!\n");
1370 return IM_STATUS_INVALID_PARAM;
1371 }
1372
1373 if (src.width + left + right != dst.width ||
1374 src.height + top + bottom != dst.height) {
1375 IM_LOGW("The width/height of dst must be equal to the width/height after making the border!"
1376 "src[w,h] = [%d, %d], dst[w,h] = [%d, %d], [t,b,l,r] = [%d, %d, %d, %d]\n",
1377 src.width, src.height, dst.width, dst.height, top, bottom, left, right);
1378 return IM_STATUS_ILLEGAL_PARAM;
1379 }
1380
1381 ret = improcess(src, dst, {}, {}, {left, top, src.width, src.height}, {}, acquir_fence_fd, ©_fence_fd, NULL, IM_ASYNC);
1382 if (ret != IM_STATUS_SUCCESS || copy_fence_fd <= 0)
1383 return ret;
1384
1385 if (top == 0 && bottom == 0 && left == 0 && right == 0) {
1386 if (sync == 1) {
1387 ret = imsync(copy_fence_fd);
1388 if (ret != IM_STATUS_SUCCESS)
1389 return ret;
1390 } else {
1391 *release_fence_fd = copy_fence_fd;
1392 return IM_STATUS_SUCCESS;
1393 }
1394 }
1395
1396 job_handle = imbeginJob();
1397 if (job_handle <= 0)
1398 return IM_STATUS_FAILED;
1399
1400 /* top */
1401 border_rect[0] = {left, 0, src.width, top};
1402 /* bottom */
1403 border_rect[1] = {left, src.height + top, border_rect[0].width, bottom};
1404 /* left */
1405 border_rect[2] = {0, 0, left, src.height + top + bottom};
1406 /* right */
1407 border_rect[3] = {src.width + left, 0, right, border_rect[2].height};
1408
1409 if (border_type == IM_BORDER_CONSTANT) {
1410 if (top) {
1411 ret = imfillTask(job_handle, dst, border_rect[0], value);
1412 if (ret != IM_STATUS_SUCCESS)
1413 goto cancel_job_handle;
1414 }
1415
1416 if (bottom) {
1417 ret = imfillTask(job_handle, dst, border_rect[1], value);
1418 if (ret != IM_STATUS_SUCCESS)
1419 goto cancel_job_handle;
1420 }
1421
1422 if (left) {
1423 ret = imfillTask(job_handle, dst, border_rect[2], value);
1424 if (ret != IM_STATUS_SUCCESS)
1425 goto cancel_job_handle;
1426 }
1427
1428 if (right) {
1429 ret = imfillTask(job_handle, dst, border_rect[3], value);
1430 if (ret != IM_STATUS_SUCCESS)
1431 goto cancel_job_handle;
1432 }
1433 } else {
1434 switch (border_type) {
1435 case IM_BORDER_REFLECT:
1436 /* top */
1437 border_src_rect[0] = {0, 0, src.width, top};
1438 /* bottom */
1439 border_src_rect[1] = {0, src.height - bottom, src.width, bottom};
1440 /* left */
1441 border_src_rect[2] = {left, 0, left, border_rect[2].height};
1442 /* right */
1443 border_src_rect[3] = {border_rect[3].x - right, 0, right, border_rect[3].height};
1444
1445 reflect = true;
1446 break;
1447 case IM_BORDER_WRAP:
1448 /* top */
1449 border_src_rect[0] = {0, src.height - top, src.width, top};
1450 /* bottom */
1451 border_src_rect[1] = {0, 0, src.width, bottom};
1452 /* left */
1453 border_src_rect[2] = {border_rect[3].x - left, 0, left, border_rect[3].height};
1454 /* right */
1455 border_src_rect[3] = {left, 0, right, border_rect[2].height};
1456 reflect = false;
1457 break;
1458 default:
1459 IM_LOGW("unknown border type 0x%x\n", border_type);
1460 return imcancelJob(job_handle);
1461 }
1462
1463 if (top || bottom) {
1464 /* top */
1465 if (top) {
1466 ret = improcessTask(job_handle, src, dst, {}, border_src_rect[0], border_rect[0], {}, NULL, reflect ? IM_HAL_TRANSFORM_FLIP_V : 0);
1467 if (ret != IM_STATUS_SUCCESS)
1468 goto cancel_job_handle;
1469 }
1470
1471 /* bottom */
1472 if (bottom) {
1473 ret = improcessTask(job_handle, src, dst, {}, border_src_rect[1], border_rect[1], {}, NULL, reflect ? IM_HAL_TRANSFORM_FLIP_V : 0);
1474 if (ret != IM_STATUS_SUCCESS)
1475 goto cancel_job_handle;
1476 }
1477
1478 ret = imendJob(job_handle, IM_ASYNC, copy_fence_fd, &tmp_fence_fd);
1479 if (ret != IM_STATUS_SUCCESS || tmp_fence_fd <= 0)
1480 goto cancel_job_handle;
1481
1482 copy_fence_fd = tmp_fence_fd;
1483
1484 job_handle = 0;
1485 job_handle = imbeginJob();
1486 if (job_handle <= 0)
1487 return IM_STATUS_FAILED;
1488 }
1489
1490 /* left */
1491 if (left || right) {
1492 ret = improcessTask(job_handle, dst, dst, {}, border_src_rect[2], border_rect[2], {}, NULL, reflect ? IM_HAL_TRANSFORM_FLIP_H : 0);
1493 if (ret != IM_STATUS_SUCCESS)
1494 goto cancel_job_handle;
1495
1496 /* right */
1497 ret = improcessTask(job_handle, dst, dst, {}, border_src_rect[3], border_rect[3], {}, NULL, reflect ? IM_HAL_TRANSFORM_FLIP_H : 0);
1498 if (ret != IM_STATUS_SUCCESS)
1499 goto cancel_job_handle;
1500 }
1501 }
1502
1503 if (sync == 1) {
1504 ret = imsync(copy_fence_fd);
1505 if (ret != IM_STATUS_SUCCESS)
1506 goto cancel_job_handle;
1507
1508 return imendJob(job_handle);
1509 } else {
1510 return imendJob(job_handle, IM_ASYNC, copy_fence_fd, release_fence_fd);
1511 }
1512
1513 cancel_job_handle:
1514 imcancelJob(job_handle);
1515 return ret;
1516 }
1517
1518 /* Start task api */
imbeginJob(uint64_t flags)1519 IM_API im_job_handle_t imbeginJob(uint64_t flags) {
1520 return rga_job_create(flags);
1521 }
1522
imcancelJob(im_job_handle_t job_handle)1523 IM_API IM_STATUS imcancelJob(im_job_handle_t job_handle) {
1524 return rga_job_cancel(job_handle);
1525 }
1526
imendJob(im_job_handle_t job_handle,int sync_mode,int acquire_fence_fd,int * release_fence_fd)1527 IM_API IM_STATUS imendJob(im_job_handle_t job_handle, int sync_mode, int acquire_fence_fd, int *release_fence_fd) {
1528 return rga_job_submit(job_handle, sync_mode, acquire_fence_fd, release_fence_fd);
1529 }
1530
imcopyTask(im_job_handle_t job_handle,const rga_buffer_t src,rga_buffer_t dst)1531 IM_API IM_STATUS imcopyTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst) {
1532 int usage = 0;
1533 im_opt_t opt;
1534 rga_buffer_t pat;
1535 im_rect srect;
1536 im_rect drect;
1537 im_rect prect;
1538
1539 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1540
1541 if ((src.width != dst.width) || (src.height != dst.height)) {
1542 IM_LOGW("imcopy cannot support scale, src[w,h] = [%d, %d], dst[w,h] = [%d, %d]",
1543 src.width, src.height, dst.width, dst.height);
1544 return IM_STATUS_INVALID_PARAM;
1545 }
1546
1547 return improcessTask(job_handle, src, dst, pat, srect, drect, prect, &opt, usage);
1548 }
1549
imresizeTask(im_job_handle_t job_handle,const rga_buffer_t src,rga_buffer_t dst,double fx,double fy,int interpolation)1550 IM_API IM_STATUS imresizeTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst, double fx, double fy, int interpolation) {
1551 int usage = 0;
1552 IM_STATUS ret = IM_STATUS_NOERROR;
1553 im_opt_t opt;
1554 rga_buffer_t pat;
1555 im_rect srect;
1556 im_rect drect;
1557 im_rect prect;
1558
1559 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1560
1561 if (fx > 0 || fy > 0) {
1562 if (fx == 0) fx = 1;
1563 if (fy == 0) fy = 1;
1564
1565 dst.width = (int)(src.width * fx);
1566 dst.height = (int)(src.height * fy);
1567
1568 int format = convert_to_rga_format(dst.format);
1569 if (format == RK_FORMAT_UNKNOWN) {
1570 IM_LOGE("Invaild dst format [0x%x]!\n", dst.format);
1571 return IM_STATUS_NOT_SUPPORTED;
1572 }
1573
1574 if(NormalRgaIsYuvFormat(format)) {
1575 int width = dst.width;
1576 int height = dst.height;
1577 dst.width = DOWN_ALIGN(dst.width, 2);
1578 dst.height = DOWN_ALIGN(dst.height, 2);
1579
1580 ret = imcheck(src, dst, srect, drect, usage);
1581 if (ret != IM_STATUS_NOERROR) {
1582 IM_LOGE("imresize error, factor[fx,fy]=[%lf,%lf], ALIGN[dw,dh]=[%d,%d][%d,%d]", fx, fy, width, height, dst.width, dst.height);
1583 return ret;
1584 }
1585 }
1586 }
1587 UNUSED(interpolation);
1588
1589 return improcessTask(job_handle, src, dst, pat, srect, drect, prect, &opt, usage);
1590 }
1591
imcropTask(im_job_handle_t job_handle,const rga_buffer_t src,rga_buffer_t dst,im_rect rect)1592 IM_API IM_STATUS imcropTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst, im_rect rect) {
1593 int usage = 0;
1594 im_opt_t opt;
1595 rga_buffer_t pat;
1596 im_rect drect;
1597 im_rect prect;
1598
1599 empty_structure(NULL, NULL, &pat, NULL, &drect, &prect, &opt);
1600
1601 drect.width = rect.width;
1602 drect.height = rect.height;
1603
1604 return improcessTask(job_handle, src, dst, pat, rect, drect, prect, &opt, usage);
1605 }
1606
imcvtcolorTask(im_job_handle_t job_handle,rga_buffer_t src,rga_buffer_t dst,int sfmt,int dfmt,int mode)1607 IM_API IM_STATUS imcvtcolorTask(im_job_handle_t job_handle, rga_buffer_t src, rga_buffer_t dst, int sfmt, int dfmt, int mode) {
1608 int usage = 0;
1609 im_opt_t opt;
1610 rga_buffer_t pat;
1611 im_rect srect;
1612 im_rect drect;
1613 im_rect prect;
1614
1615 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1616
1617 src.format = sfmt;
1618 dst.format = dfmt;
1619
1620 dst.color_space_mode = mode;
1621
1622 return improcessTask(job_handle, src, dst, pat, srect, drect, prect, &opt, usage);
1623 }
1624
imtranslateTask(im_job_handle_t job_handle,const rga_buffer_t src,rga_buffer_t dst,int x,int y)1625 IM_API IM_STATUS imtranslateTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst, int x, int y) {
1626 int usage = 0;
1627 im_opt_t opt;
1628 rga_buffer_t pat;
1629 im_rect srect;
1630 im_rect drect;
1631 im_rect prect;
1632
1633 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1634
1635 if ((src.width != dst.width) || (src.height != dst.height)) {
1636 IM_LOGW("The width and height of src and dst need to be equal, src[w,h] = [%d, %d], dst[w,h] = [%d, %d]",
1637 src.width, src.height, dst.width, dst.height);
1638 return IM_STATUS_INVALID_PARAM;
1639 }
1640
1641 srect.width = src.width - x;
1642 srect.height = src.height - y;
1643 drect.x = x;
1644 drect.y = y;
1645 drect.width = src.width - x;
1646 drect.height = src.height - y;
1647
1648 return improcessTask(job_handle, src, dst, pat, srect, drect, prect, &opt, usage);
1649 }
1650
imrotateTask(im_job_handle_t job_handle,const rga_buffer_t src,rga_buffer_t dst,int rotation)1651 IM_API IM_STATUS imrotateTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst, int rotation) {
1652 int usage = 0;
1653 im_opt_t opt;
1654 rga_buffer_t pat;
1655
1656 im_rect srect;
1657 im_rect drect;
1658 im_rect prect;
1659
1660 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1661
1662 usage |= rotation;
1663
1664 return improcessTask(job_handle, src, dst, pat, srect, drect, prect, &opt, usage);
1665 }
1666
imflipTask(im_job_handle_t job_handle,const rga_buffer_t src,rga_buffer_t dst,int mode)1667 IM_API IM_STATUS imflipTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst, int mode) {
1668 int usage = 0;
1669 im_opt_t opt;
1670 rga_buffer_t pat;
1671 im_rect srect;
1672 im_rect drect;
1673 im_rect prect;
1674
1675 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1676
1677 usage |= mode;
1678
1679 return improcessTask(job_handle, src, dst, pat, srect, drect, prect, &opt, usage);
1680 }
1681
imcompositeTask(im_job_handle_t job_handle,const rga_buffer_t srcA,const rga_buffer_t srcB,rga_buffer_t dst,int mode)1682 IM_API IM_STATUS imcompositeTask(im_job_handle_t job_handle, const rga_buffer_t srcA, const rga_buffer_t srcB, rga_buffer_t dst, int mode) {
1683 int usage = 0;
1684 im_opt_t opt;
1685 im_rect srect;
1686 im_rect drect;
1687 im_rect prect;
1688
1689 empty_structure(NULL, NULL, NULL, &srect, &drect, &prect, &opt);
1690
1691 usage |= mode;
1692
1693 return improcessTask(job_handle, srcA, dst, srcB, srect, drect, prect, &opt, usage);
1694 }
1695
imblendTask(im_job_handle_t job_handle,const rga_buffer_t src,rga_buffer_t dst,int mode)1696 IM_API IM_STATUS imblendTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst, int mode) {
1697 rga_buffer_t pat;
1698
1699 memset(&pat, 0x0, sizeof(pat));
1700
1701 return imcompositeTask(job_handle, src, pat, dst, mode);
1702 }
1703
imcolorkeyTask(im_job_handle_t job_handle,const rga_buffer_t src,rga_buffer_t dst,im_colorkey_range range,int mode)1704 IM_API IM_STATUS imcolorkeyTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst, im_colorkey_range range, int mode) {
1705 int usage = 0;
1706 im_opt_t opt;
1707 rga_buffer_t pat;
1708 im_rect srect;
1709 im_rect drect;
1710 im_rect prect;
1711
1712 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1713
1714 usage |= mode;
1715
1716 opt.colorkey_range = range;
1717
1718 return improcessTask(job_handle, src, dst, pat, srect, drect, prect, &opt, usage);
1719 }
1720
imosdTask(im_job_handle_t job_handle,const rga_buffer_t osd,const rga_buffer_t bg_image,const im_rect osd_rect,im_osd_t * osd_config)1721 IM_API IM_STATUS imosdTask(im_job_handle_t job_handle,
1722 const rga_buffer_t osd,const rga_buffer_t bg_image,
1723 const im_rect osd_rect, im_osd_t *osd_config) {
1724 int usage = 0;
1725 im_opt_t opt;
1726 im_rect tmp_rect;
1727
1728 memset(&opt, 0x0, sizeof(opt));
1729 memset(&tmp_rect, 0x0, sizeof(tmp_rect));
1730
1731 opt.version = RGA_CURRENT_API_VERSION;
1732 memcpy(&opt.osd_config, osd_config, sizeof(im_osd_t));
1733
1734 usage |= IM_ALPHA_BLEND_DST_OVER | IM_OSD;
1735
1736 return improcessTask(job_handle, bg_image, bg_image, osd, osd_rect, osd_rect, tmp_rect, &opt, usage);
1737 }
1738
imquantizeTask(im_job_handle_t job_handle,const rga_buffer_t src,rga_buffer_t dst,im_nn_t nn_info)1739 IM_API IM_STATUS imquantizeTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst, im_nn_t nn_info) {
1740 int usage = 0;
1741 im_opt_t opt;
1742 rga_buffer_t pat;
1743 im_rect srect;
1744 im_rect drect;
1745 im_rect prect;
1746
1747 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1748
1749 usage |= IM_NN_QUANTIZE;
1750
1751 opt.nn = nn_info;
1752
1753 return improcessTask(job_handle, src, dst, pat, srect, drect, prect, &opt, usage);
1754 }
1755
imropTask(im_job_handle_t job_handle,const rga_buffer_t src,rga_buffer_t dst,int rop_code)1756 IM_API IM_STATUS imropTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst, int rop_code) {
1757 int usage = 0;
1758 im_opt_t opt;
1759 rga_buffer_t pat;
1760 im_rect srect;
1761 im_rect drect;
1762 im_rect prect;
1763
1764 empty_structure(NULL, NULL, &pat, &srect, &drect, &prect, &opt);
1765
1766 usage |= IM_ROP;
1767
1768 opt.rop_code = rop_code;
1769
1770 return improcessTask(job_handle, src, dst, pat, srect, drect, prect, &opt, usage);
1771 }
1772
immosaicTask(im_job_handle_t job_handle,const rga_buffer_t image,im_rect rect,int mosaic_mode)1773 IM_API IM_STATUS immosaicTask(im_job_handle_t job_handle, const rga_buffer_t image, im_rect rect, int mosaic_mode) {
1774 int usage = 0;
1775 im_opt_t opt;
1776 rga_buffer_t tmp_image;
1777 im_rect tmp_rect;
1778
1779 memset(&opt, 0x0, sizeof(opt));
1780 memset(&tmp_image, 0x0, sizeof(tmp_image));
1781 memset(&tmp_rect, 0x0, sizeof(tmp_rect));
1782
1783 usage |= IM_MOSAIC;
1784
1785 opt.version = RGA_CURRENT_API_VERSION;
1786 opt.mosaic_mode = mosaic_mode;
1787
1788 return improcessTask(job_handle, image, image, tmp_image, rect, rect, tmp_rect, &opt, usage);
1789 }
1790
immosaicTaskArray(im_job_handle_t job_handle,rga_buffer_t dst,im_rect * rect_array,int array_size,int color)1791 IM_API IM_STATUS immosaicTaskArray(im_job_handle_t job_handle, rga_buffer_t dst, im_rect *rect_array, int array_size, int color) {
1792 IM_STATUS ret;
1793
1794 for (int i = 0; i < array_size; i++) {
1795 ret = immosaicTask(job_handle, dst, rect_array[i], color);
1796 if (ret != IM_STATUS_SUCCESS)
1797 return ret;
1798 }
1799
1800 return IM_STATUS_SUCCESS;
1801 }
1802
imfillTask(im_job_handle_t job_handle,rga_buffer_t dst,im_rect rect,uint32_t color)1803 IM_API IM_STATUS imfillTask(im_job_handle_t job_handle, rga_buffer_t dst, im_rect rect, uint32_t color) {
1804 int usage = 0;
1805 im_opt_t opt;
1806 rga_buffer_t pat;
1807 rga_buffer_t src;
1808 im_rect srect;
1809 im_rect prect;
1810
1811 empty_structure(&src, NULL, &pat, &srect, NULL, &prect, &opt);
1812
1813 memset(&src, 0, sizeof(rga_buffer_t));
1814
1815 usage |= IM_COLOR_FILL;
1816
1817 opt.color = color;
1818
1819 return improcessTask(job_handle, src, dst, pat, srect, rect, prect, &opt, usage);
1820 }
1821
imfillTaskArray(im_job_handle_t job_handle,rga_buffer_t dst,im_rect * rect_array,int array_size,uint32_t color)1822 IM_API IM_STATUS imfillTaskArray(im_job_handle_t job_handle, rga_buffer_t dst, im_rect *rect_array, int array_size, uint32_t color) {
1823 IM_STATUS ret;
1824
1825 for (int i = 0; i < array_size; i++) {
1826 ret = imfillTask(job_handle, dst, rect_array[i], color);
1827 if (ret != IM_STATUS_SUCCESS)
1828 return ret;
1829 }
1830
1831 return IM_STATUS_SUCCESS;
1832 }
1833
imrectangleTask(im_job_handle_t job_handle,rga_buffer_t dst,im_rect rect,uint32_t color,int thickness)1834 IM_STATUS imrectangleTask(im_job_handle_t job_handle, rga_buffer_t dst, im_rect rect, uint32_t color, int thickness) {
1835 if (thickness < 0)
1836 return imfillTask(job_handle, dst, rect, color);
1837
1838 int h_length = rect.width;
1839 int v_length = rect.height - 2 * thickness;
1840 im_rect fill_rect[4] = {};
1841
1842 fill_rect[0] = {rect.x, rect.y, h_length, thickness};
1843 fill_rect[1] = {rect.x, rect.y + (rect.height - thickness), h_length, thickness};
1844 fill_rect[2] = {rect.x, rect.y + thickness, thickness, v_length};
1845 fill_rect[3] = {rect.x + (rect.width - thickness), rect.y + thickness, thickness, v_length};
1846
1847 return imfillTaskArray(job_handle, dst, fill_rect, 4, color);
1848 }
1849
imrectangleTaskArray(im_job_handle_t job_handle,rga_buffer_t dst,im_rect * rect_array,int array_size,uint32_t color,int thickness)1850 IM_STATUS imrectangleTaskArray(im_job_handle_t job_handle, rga_buffer_t dst, im_rect *rect_array, int array_size, uint32_t color, int thickness) {
1851 IM_STATUS ret;
1852
1853 for (int i = 0; i < array_size; i++) {
1854 ret = imrectangleTask(job_handle, dst, rect_array[i], color, thickness);
1855 if (ret != IM_STATUS_SUCCESS)
1856 return ret;
1857 }
1858
1859 return IM_STATUS_SUCCESS;
1860 }
1861
impaletteTask(im_job_handle_t job_handle,rga_buffer_t src,rga_buffer_t dst,rga_buffer_t lut)1862 IM_API IM_STATUS impaletteTask(im_job_handle_t job_handle, rga_buffer_t src, rga_buffer_t dst, rga_buffer_t lut) {
1863 int usage = 0;
1864 im_rect srect;
1865 im_rect drect;
1866 im_rect prect;
1867
1868 im_opt_t opt;
1869
1870 empty_structure(NULL, NULL, NULL, &srect, &drect, &prect, &opt);
1871
1872 /*Don't know if it supports zooming.*/
1873 if ((src.width != dst.width) || (src.height != dst.height)) {
1874 IM_LOGW("The width and height of src and dst need to be equal, src[w,h] = [%d, %d], dst[w,h] = [%d, %d]",
1875 src.width, src.height, dst.width, dst.height);
1876 return IM_STATUS_INVALID_PARAM;
1877 }
1878
1879 usage |= IM_COLOR_PALETTE;
1880
1881 return improcessTask(job_handle, src, dst, lut, srect, drect, prect, &opt, usage);
1882 }
1883
improcessTask(im_job_handle_t job_handle,rga_buffer_t src,rga_buffer_t dst,rga_buffer_t pat,im_rect srect,im_rect drect,im_rect prect,im_opt_t * opt_ptr,int usage)1884 IM_API IM_STATUS improcessTask(im_job_handle_t job_handle,
1885 rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat,
1886 im_rect srect, im_rect drect, im_rect prect,
1887 im_opt_t *opt_ptr, int usage) {
1888 return rga_task_submit(job_handle, src, dst, pat, srect, drect, prect, opt_ptr, usage);
1889 }
1890 /* End task api */
1891
1892 /* for rockit-ko */
imbegin(uint32_t flags)1893 im_ctx_id_t imbegin(uint32_t flags) {
1894 return rga_job_create(flags);
1895 }
1896
imcancel(im_ctx_id_t id)1897 IM_STATUS imcancel(im_ctx_id_t id) {
1898 return rga_job_cancel((im_job_handle_t)id);
1899 }
1900
improcess(rga_buffer_t src,rga_buffer_t dst,rga_buffer_t pat,im_rect srect,im_rect drect,im_rect prect,int acquire_fence_fd,int * release_fence_fd,im_opt_t * opt_ptr,int usage,im_ctx_id_t ctx_id)1901 IM_STATUS improcess(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat,
1902 im_rect srect, im_rect drect, im_rect prect,
1903 int acquire_fence_fd, int *release_fence_fd,
1904 im_opt_t *opt_ptr, int usage, im_ctx_id_t ctx_id) {
1905 int ret;
1906 int sync_mode;
1907
1908 UNUSED(acquire_fence_fd);
1909 UNUSED(release_fence_fd);
1910
1911 ret = rga_task_submit((im_job_handle_t)ctx_id, src, dst, pat, srect, drect, prect, opt_ptr, usage);
1912 if (ret != IM_STATUS_SUCCESS)
1913 return (IM_STATUS)ret;
1914
1915 if (usage & IM_ASYNC)
1916 sync_mode = IM_ASYNC;
1917 else
1918 sync_mode = IM_SYNC;
1919
1920 return rga_job_config((im_job_handle_t)ctx_id, sync_mode, acquire_fence_fd, release_fence_fd);
1921 }
1922
improcess_ctx(rga_buffer_t src,rga_buffer_t dst,rga_buffer_t pat,im_rect srect,im_rect drect,im_rect prect,int acquire_fence_fd,int * release_fence_fd,im_opt_t * opt_ptr,int usage,im_ctx_id_t ctx_id)1923 IM_STATUS improcess_ctx(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat,
1924 im_rect srect, im_rect drect, im_rect prect,
1925 int acquire_fence_fd, int *release_fence_fd,
1926 im_opt_t *opt_ptr, int usage, im_ctx_id_t ctx_id) {
1927 return improcess(src, dst, pat, srect, drect, prect, acquire_fence_fd, release_fence_fd, opt_ptr, usage, ctx_id);
1928 }
1929
1930 /* For the C interface */
wrapbuffer_handle_t(rga_buffer_handle_t handle,int width,int height,int wstride,int hstride,int format)1931 IM_API rga_buffer_t wrapbuffer_handle_t(rga_buffer_handle_t handle,
1932 int width, int height,
1933 int wstride, int hstride,
1934 int format) {
1935 return wrapbuffer_handle(handle, width, height, format, wstride, hstride);
1936 }
1937
wrapbuffer_virtualaddr_t(void * vir_addr,int width,int height,int wstride,int hstride,int format)1938 IM_API rga_buffer_t wrapbuffer_virtualaddr_t(void* vir_addr,
1939 int width, int height,
1940 int wstride, int hstride,
1941 int format) {
1942 return wrapbuffer_virtualaddr(vir_addr, width, height, format, wstride, hstride);
1943 }
1944
wrapbuffer_physicaladdr_t(void * phy_addr,int width,int height,int wstride,int hstride,int format)1945 IM_API rga_buffer_t wrapbuffer_physicaladdr_t(void* phy_addr,
1946 int width, int height,
1947 int wstride, int hstride,
1948 int format) {
1949 return wrapbuffer_physicaladdr(phy_addr, width, height, format, wstride, hstride);
1950 }
1951
wrapbuffer_fd_t(int fd,int width,int height,int wstride,int hstride,int format)1952 IM_API rga_buffer_t wrapbuffer_fd_t(int fd,
1953 int width, int height,
1954 int wstride, int hstride,
1955 int format) {
1956 return wrapbuffer_fd(fd, width, height, format, wstride, hstride);
1957 }
1958
imcheck_t(rga_buffer_t src,rga_buffer_t dst,rga_buffer_t pat,im_rect src_rect,im_rect dst_rect,im_rect pat_rect,int mode_usage)1959 IM_API IM_STATUS imcheck_t(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat,
1960 im_rect src_rect, im_rect dst_rect, im_rect pat_rect, int mode_usage) {
1961 return rga_check_external(src, dst, pat, src_rect, dst_rect, pat_rect, mode_usage);
1962 }
1963
imresize_t(const rga_buffer_t src,rga_buffer_t dst,double fx,double fy,int interpolation,int sync)1964 IM_API IM_STATUS imresize_t(const rga_buffer_t src, rga_buffer_t dst, double fx, double fy, int interpolation, int sync) {
1965 return imresize(src, dst, fx, fy, interpolation, sync, NULL);
1966 }
1967
imcrop_t(const rga_buffer_t src,rga_buffer_t dst,im_rect rect,int sync)1968 IM_API IM_STATUS imcrop_t(const rga_buffer_t src, rga_buffer_t dst, im_rect rect, int sync) {
1969 return imcrop(src, dst, rect, sync, NULL);
1970 }
1971
imrotate_t(const rga_buffer_t src,rga_buffer_t dst,int rotation,int sync)1972 IM_API IM_STATUS imrotate_t(const rga_buffer_t src, rga_buffer_t dst, int rotation, int sync) {
1973 return imrotate(src, dst, rotation, sync, NULL);
1974 }
1975
imflip_t(const rga_buffer_t src,rga_buffer_t dst,int mode,int sync)1976 IM_API IM_STATUS imflip_t (const rga_buffer_t src, rga_buffer_t dst, int mode, int sync) {
1977 return imflip(src, dst, mode, sync, NULL);
1978 }
1979
imfill_t(rga_buffer_t dst,im_rect rect,int color,int sync)1980 IM_API IM_STATUS imfill_t(rga_buffer_t dst, im_rect rect, int color, int sync) {
1981 return imfill(dst, rect, color, sync, NULL);
1982 }
1983
impalette_t(rga_buffer_t src,rga_buffer_t dst,rga_buffer_t lut,int sync)1984 IM_API IM_STATUS impalette_t(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t lut, int sync) {
1985 return impalette(src, dst, lut, sync, NULL);
1986 }
1987
imtranslate_t(const rga_buffer_t src,rga_buffer_t dst,int x,int y,int sync)1988 IM_API IM_STATUS imtranslate_t(const rga_buffer_t src, rga_buffer_t dst, int x, int y, int sync) {
1989 return imtranslate(src, dst, x, y, sync, NULL);
1990 }
1991
imcopy_t(const rga_buffer_t src,rga_buffer_t dst,int sync)1992 IM_API IM_STATUS imcopy_t(const rga_buffer_t src, rga_buffer_t dst, int sync) {
1993 return imcopy(src, dst, sync, NULL);
1994 }
1995
imcolorkey_t(const rga_buffer_t src,rga_buffer_t dst,im_colorkey_range range,int mode,int sync)1996 IM_API IM_STATUS imcolorkey_t(const rga_buffer_t src, rga_buffer_t dst, im_colorkey_range range, int mode, int sync) {
1997 return imcolorkey(src, dst, range, mode, sync, NULL);
1998 }
1999
imblend_t(const rga_buffer_t srcA,const rga_buffer_t srcB,rga_buffer_t dst,int mode,int sync)2000 IM_API IM_STATUS imblend_t(const rga_buffer_t srcA, const rga_buffer_t srcB, rga_buffer_t dst, int mode, int sync) {
2001 return imcomposite(srcA, srcB, dst, mode, sync, NULL);
2002 }
2003
imcvtcolor_t(rga_buffer_t src,rga_buffer_t dst,int sfmt,int dfmt,int mode,int sync)2004 IM_API IM_STATUS imcvtcolor_t(rga_buffer_t src, rga_buffer_t dst, int sfmt, int dfmt, int mode, int sync) {
2005 return imcvtcolor(src, dst, sfmt, dfmt, mode, sync, NULL);
2006 }
2007
imquantize_t(const rga_buffer_t src,rga_buffer_t dst,im_nn_t nn_info,int sync)2008 IM_API IM_STATUS imquantize_t(const rga_buffer_t src, rga_buffer_t dst, im_nn_t nn_info, int sync) {
2009 return imquantize(src, dst, nn_info, sync, NULL);
2010 }
2011
imrop_t(const rga_buffer_t src,rga_buffer_t dst,int rop_code,int sync)2012 IM_API IM_STATUS imrop_t(const rga_buffer_t src, rga_buffer_t dst, int rop_code, int sync) {
2013 return imrop(src, dst, rop_code, sync, NULL);
2014 }
2015
immosaic(const rga_buffer_t image,im_rect rect,int mosaic_mode,int sync)2016 IM_API IM_STATUS immosaic(const rga_buffer_t image, im_rect rect, int mosaic_mode, int sync) {
2017 return immosaic(image, rect, mosaic_mode, sync, NULL);
2018 }
2019
imosd(const rga_buffer_t osd,const rga_buffer_t dst,const im_rect osd_rect,im_osd_t * osd_info,int sync)2020 IM_API IM_STATUS imosd(const rga_buffer_t osd,const rga_buffer_t dst, const im_rect osd_rect,
2021 im_osd_t *osd_info, int sync) {
2022 return imosd(osd, dst, osd_rect, osd_info, sync, NULL);
2023 }
2024