copybit_c2d.cpp revision 966f989a6d502dc12ad7f5ad950180df6581f382
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * Copyright (c) 2010-2013, The Linux Foundation. All rights reserved. 4 * 5 * Not a Contribution, Apache license notifications and license are retained 6 * for attribution purposes only. 7 * 8 * Licensed under the Apache License, Version 2.0 (the "License"); 9 * you may not use this file except in compliance with the License. 10 * You may obtain a copy of the License at 11 * 12 * http://www.apache.org/licenses/LICENSE-2.0 13 * 14 * Unless required by applicable law or agreed to in writing, software 15 * distributed under the License is distributed on an "AS IS" BASIS, 16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 17 * See the License for the specific language governing permissions and 18 * limitations under the License. 19 */ 20#include <cutils/log.h> 21#include <sys/resource.h> 22#include <sys/prctl.h> 23 24#include <stdint.h> 25#include <string.h> 26#include <unistd.h> 27#include <errno.h> 28#include <fcntl.h> 29 30#include <sys/ioctl.h> 31#include <sys/types.h> 32#include <sys/mman.h> 33 34#include <linux/msm_kgsl.h> 35 36#include <EGL/eglplatform.h> 37#include <cutils/native_handle.h> 38#include <cutils/ashmem.h> 39#include <linux/ashmem.h> 40#include <gralloc_priv.h> 41 42#include <copybit.h> 43#include <alloc_controller.h> 44#include <memalloc.h> 45 46#include "c2d2.h" 47#include "software_converter.h" 48 49#include <dlfcn.h> 50 51using gralloc::IMemAlloc; 52using gralloc::IonController; 53using gralloc::alloc_data; 54 55C2D_STATUS (*LINK_c2dCreateSurface)( uint32 *surface_id, 56 uint32 surface_bits, 57 C2D_SURFACE_TYPE surface_type, 58 void *surface_definition ); 59 60C2D_STATUS (*LINK_c2dUpdateSurface)( uint32 surface_id, 61 uint32 surface_bits, 62 C2D_SURFACE_TYPE surface_type, 63 void *surface_definition ); 64 65C2D_STATUS (*LINK_c2dReadSurface)( uint32 surface_id, 66 C2D_SURFACE_TYPE surface_type, 67 void *surface_definition, 68 int32 x, int32 y ); 69 70C2D_STATUS (*LINK_c2dDraw)( uint32 target_id, 71 uint32 target_config, C2D_RECT *target_scissor, 72 uint32 target_mask_id, uint32 target_color_key, 73 C2D_OBJECT *objects_list, uint32 num_objects ); 74 75C2D_STATUS (*LINK_c2dFinish)( uint32 target_id); 76 77C2D_STATUS (*LINK_c2dFlush)( uint32 target_id, c2d_ts_handle *timestamp); 78 79C2D_STATUS (*LINK_c2dWaitTimestamp)( c2d_ts_handle timestamp ); 80 81C2D_STATUS (*LINK_c2dDestroySurface)( uint32 surface_id ); 82 83C2D_STATUS (*LINK_c2dMapAddr) ( int mem_fd, void * hostptr, uint32 len, 84 uint32 offset, uint32 flags, void ** gpuaddr); 85 86C2D_STATUS (*LINK_c2dUnMapAddr) ( void * gpuaddr); 87 88C2D_STATUS (*LINK_c2dGetDriverCapabilities) ( C2D_DRIVER_INFO * driver_info); 89 90/* create a fence fd for the timestamp */ 91C2D_STATUS (*LINK_c2dCreateFenceFD) ( uint32 target_id, c2d_ts_handle timestamp, 92 int32 *fd); 93 94C2D_STATUS (*LINK_c2dFillSurface) ( uint32 surface_id, uint32 fill_color, 95 C2D_RECT * fill_rect); 96 97/******************************************************************************/ 98 99#if defined(COPYBIT_Z180) 100#define MAX_SCALE_FACTOR (4096) 101#define MAX_DIMENSION (4096) 102#else 103#error "Unsupported HW version" 104#endif 105 106// The following defines can be changed as required i.e. as we encounter 107// complex use cases. 108#define MAX_RGB_SURFACES 8 // Max. RGB layers currently supported per draw 109#define MAX_YUV_2_PLANE_SURFACES 4// Max. 2-plane YUV layers currently supported per draw 110#define MAX_YUV_3_PLANE_SURFACES 1// Max. 3-plane YUV layers currently supported per draw 111// +1 for the destination surface. We cannot have multiple destination surfaces. 112#define MAX_SURFACES (MAX_RGB_SURFACES + MAX_YUV_2_PLANE_SURFACES + MAX_YUV_3_PLANE_SURFACES + 1) 113#define NUM_SURFACE_TYPES 3 // RGB_SURFACE + YUV_SURFACE_2_PLANES + YUV_SURFACE_3_PLANES 114#define MAX_BLIT_OBJECT_COUNT 50 // Max. blit objects that can be passed per draw 115 116enum { 117 RGB_SURFACE, 118 YUV_SURFACE_2_PLANES, 119 YUV_SURFACE_3_PLANES 120}; 121 122enum eConversionType { 123 CONVERT_TO_ANDROID_FORMAT, 124 CONVERT_TO_C2D_FORMAT 125}; 126 127enum eC2DFlags { 128 FLAGS_PREMULTIPLIED_ALPHA = 1<<0, 129 FLAGS_YUV_DESTINATION = 1<<1, 130 FLAGS_TEMP_SRC_DST = 1<<2 131}; 132 133static gralloc::IAllocController* sAlloc = 0; 134/******************************************************************************/ 135 136/** State information for each device instance */ 137struct copybit_context_t { 138 struct copybit_device_t device; 139 // Templates for the various source surfaces. These templates are created 140 // to avoid the expensive create/destroy C2D Surfaces 141 C2D_OBJECT_STR blit_rgb_object[MAX_RGB_SURFACES]; 142 C2D_OBJECT_STR blit_yuv_2_plane_object[MAX_YUV_2_PLANE_SURFACES]; 143 C2D_OBJECT_STR blit_yuv_3_plane_object[MAX_YUV_3_PLANE_SURFACES]; 144 C2D_OBJECT_STR blit_list[MAX_BLIT_OBJECT_COUNT]; // Z-ordered list of blit objects 145 C2D_DRIVER_INFO c2d_driver_info; 146 void *libc2d2; 147 alloc_data temp_src_buffer; 148 alloc_data temp_dst_buffer; 149 unsigned int dst[NUM_SURFACE_TYPES]; // dst surfaces 150 unsigned int mapped_gpu_addr[MAX_SURFACES]; // GPU addresses mapped inside copybit 151 int blit_rgb_count; // Total RGB surfaces being blit 152 int blit_yuv_2_plane_count; // Total 2 plane YUV surfaces being 153 int blit_yuv_3_plane_count; // Total 3 plane YUV surfaces being blit 154 int blit_count; // Total blit objects. 155 unsigned int trg_transform; /* target transform */ 156 int fb_width; 157 int fb_height; 158 int src_global_alpha; 159 int config_mask; 160 int dst_surface_type; 161 bool is_premultiplied_alpha; 162 void* time_stamp; 163 164 // used for signaling the wait thread 165 bool wait_timestamp; 166 pthread_t wait_thread_id; 167 bool stop_thread; 168 pthread_mutex_t wait_cleanup_lock; 169 pthread_cond_t wait_cleanup_cond; 170 171}; 172 173struct bufferInfo { 174 int width; 175 int height; 176 int format; 177}; 178 179struct yuvPlaneInfo { 180 int yStride; //luma stride 181 int plane1_stride; 182 int plane2_stride; 183 int plane1_offset; 184 int plane2_offset; 185}; 186 187/** 188 * Common hardware methods 189 */ 190 191static int open_copybit(const struct hw_module_t* module, const char* name, 192 struct hw_device_t** device); 193 194static struct hw_module_methods_t copybit_module_methods = { 195open: open_copybit 196}; 197 198/* 199 * The COPYBIT Module 200 */ 201struct copybit_module_t HAL_MODULE_INFO_SYM = { 202common: { 203tag: HARDWARE_MODULE_TAG, 204 version_major: 1, 205 version_minor: 0, 206 id: COPYBIT_HARDWARE_MODULE_ID, 207 name: "QCT COPYBIT C2D 2.0 Module", 208 author: "Qualcomm", 209 methods: ©bit_module_methods 210 } 211}; 212 213 214/* thread function which waits on the timeStamp and cleans up the surfaces */ 215static void* c2d_wait_loop(void* ptr) { 216 copybit_context_t* ctx = (copybit_context_t*)(ptr); 217 char thread_name[64] = "copybitWaitThr"; 218 prctl(PR_SET_NAME, (unsigned long) &thread_name, 0, 0, 0); 219 setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY); 220 221 while(ctx->stop_thread == false) { 222 pthread_mutex_lock(&ctx->wait_cleanup_lock); 223 while(ctx->wait_timestamp == false && !ctx->stop_thread) { 224 pthread_cond_wait(&(ctx->wait_cleanup_cond), 225 &(ctx->wait_cleanup_lock)); 226 } 227 if(ctx->wait_timestamp) { 228 if(LINK_c2dWaitTimestamp(ctx->time_stamp)) { 229 ALOGE("%s: LINK_c2dWaitTimeStamp ERROR!!", __FUNCTION__); 230 } 231 ctx->wait_timestamp = false; 232 // Unmap any mapped addresses. 233 for (int i = 0; i < MAX_SURFACES; i++) { 234 if (ctx->mapped_gpu_addr[i]) { 235 LINK_c2dUnMapAddr( (void*)ctx->mapped_gpu_addr[i]); 236 ctx->mapped_gpu_addr[i] = 0; 237 } 238 } 239 // Reset the counts after the draw. 240 ctx->blit_rgb_count = 0; 241 ctx->blit_yuv_2_plane_count = 0; 242 ctx->blit_yuv_3_plane_count = 0; 243 ctx->blit_count = 0; 244 } 245 pthread_mutex_unlock(&ctx->wait_cleanup_lock); 246 if(ctx->stop_thread) 247 break; 248 } 249 pthread_exit(NULL); 250 return NULL; 251} 252 253 254/* convert COPYBIT_FORMAT to C2D format */ 255static int get_format(int format) { 256 switch (format) { 257 case HAL_PIXEL_FORMAT_RGB_565: return C2D_COLOR_FORMAT_565_RGB; 258 case HAL_PIXEL_FORMAT_RGBX_8888: return C2D_COLOR_FORMAT_8888_ARGB | 259 C2D_FORMAT_SWAP_RB | 260 C2D_FORMAT_DISABLE_ALPHA; 261 case HAL_PIXEL_FORMAT_RGBA_8888: return C2D_COLOR_FORMAT_8888_ARGB | 262 C2D_FORMAT_SWAP_RB; 263 case HAL_PIXEL_FORMAT_BGRA_8888: return C2D_COLOR_FORMAT_8888_ARGB; 264 case HAL_PIXEL_FORMAT_YCbCr_420_SP: return C2D_COLOR_FORMAT_420_NV12; 265 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:return C2D_COLOR_FORMAT_420_NV12; 266 case HAL_PIXEL_FORMAT_YCrCb_420_SP: return C2D_COLOR_FORMAT_420_NV21; 267 case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED: return C2D_COLOR_FORMAT_420_NV12 | 268 C2D_FORMAT_MACROTILED; 269 default: ALOGE("%s: invalid format (0x%x", 270 __FUNCTION__, format); 271 return -EINVAL; 272 } 273 return -EINVAL; 274} 275 276/* Get the C2D formats needed for conversion to YUV */ 277static int get_c2d_format_for_yuv_destination(int halFormat) { 278 switch (halFormat) { 279 // We do not swap the RB when the target is YUV 280 case HAL_PIXEL_FORMAT_RGBX_8888: return C2D_COLOR_FORMAT_8888_ARGB | 281 C2D_FORMAT_DISABLE_ALPHA; 282 case HAL_PIXEL_FORMAT_RGBA_8888: return C2D_COLOR_FORMAT_8888_ARGB; 283 // The U and V need to be interchanged when the target is YUV 284 case HAL_PIXEL_FORMAT_YCbCr_420_SP: return C2D_COLOR_FORMAT_420_NV21; 285 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:return C2D_COLOR_FORMAT_420_NV21; 286 case HAL_PIXEL_FORMAT_YCrCb_420_SP: return C2D_COLOR_FORMAT_420_NV12; 287 default: return get_format(halFormat); 288 } 289 return -EINVAL; 290} 291 292/* ------------------------------------------------------------------- *//*! 293 * \internal 294 * \brief Get the bpp for a particular color format 295 * \param color format 296 * \return bits per pixel 297 *//* ------------------------------------------------------------------- */ 298int c2diGetBpp(int32 colorformat) 299{ 300 301 int c2dBpp = 0; 302 303 switch(colorformat&0xFF) 304 { 305 case C2D_COLOR_FORMAT_4444_RGBA: 306 case C2D_COLOR_FORMAT_4444_ARGB: 307 case C2D_COLOR_FORMAT_1555_ARGB: 308 case C2D_COLOR_FORMAT_565_RGB: 309 case C2D_COLOR_FORMAT_5551_RGBA: 310 c2dBpp = 16; 311 break; 312 case C2D_COLOR_FORMAT_8888_RGBA: 313 case C2D_COLOR_FORMAT_8888_ARGB: 314 c2dBpp = 32; 315 break; 316 case C2D_COLOR_FORMAT_8_L: 317 case C2D_COLOR_FORMAT_8_A: 318 c2dBpp = 8; 319 break; 320 case C2D_COLOR_FORMAT_4_A: 321 c2dBpp = 4; 322 break; 323 case C2D_COLOR_FORMAT_1: 324 c2dBpp = 1; 325 break; 326 default: 327 ALOGE("%s ERROR", __func__); 328 break; 329 } 330 return c2dBpp; 331} 332 333static uint32 c2d_get_gpuaddr(copybit_context_t* ctx, struct private_handle_t *handle, 334 int &mapped_idx) 335{ 336 uint32 memtype, *gpuaddr; 337 C2D_STATUS rc; 338 339 if(!handle) 340 return 0; 341 342 if (handle->flags & (private_handle_t::PRIV_FLAGS_USES_PMEM | 343 private_handle_t::PRIV_FLAGS_USES_PMEM_ADSP)) 344 memtype = KGSL_USER_MEM_TYPE_PMEM; 345 else if (handle->flags & private_handle_t::PRIV_FLAGS_USES_ASHMEM) 346 memtype = KGSL_USER_MEM_TYPE_ASHMEM; 347 else if (handle->flags & private_handle_t::PRIV_FLAGS_USES_ION) 348 memtype = KGSL_USER_MEM_TYPE_ION; 349 else { 350 ALOGE("Invalid handle flags: 0x%x", handle->flags); 351 return 0; 352 } 353 354 rc = LINK_c2dMapAddr(handle->fd, (void*)handle->base, handle->size, 355 handle->offset, memtype, (void**)&gpuaddr); 356 357 if (rc == C2D_STATUS_OK) { 358 // We have mapped the GPU address inside copybit. We need to unmap this 359 // address after the blit. Store this address 360 for (int i = 0; i < MAX_SURFACES; i++) { 361 if (ctx->mapped_gpu_addr[i] == 0) { 362 ctx->mapped_gpu_addr[i] = (uint32) gpuaddr; 363 mapped_idx = i; 364 break; 365 } 366 } 367 368 return (uint32) gpuaddr; 369 } 370 return 0; 371} 372 373static void unmap_gpuaddr(copybit_context_t* ctx, int mapped_idx) 374{ 375 if (!ctx || (mapped_idx == -1)) 376 return; 377 378 if (ctx->mapped_gpu_addr[mapped_idx]) { 379 LINK_c2dUnMapAddr( (void*)ctx->mapped_gpu_addr[mapped_idx]); 380 ctx->mapped_gpu_addr[mapped_idx] = 0; 381 } 382} 383 384static int is_supported_rgb_format(int format) 385{ 386 switch(format) { 387 case HAL_PIXEL_FORMAT_RGBA_8888: 388 case HAL_PIXEL_FORMAT_RGBX_8888: 389 case HAL_PIXEL_FORMAT_RGB_565: 390 case HAL_PIXEL_FORMAT_BGRA_8888: { 391 return COPYBIT_SUCCESS; 392 } 393 default: 394 return COPYBIT_FAILURE; 395 } 396} 397 398static int get_num_planes(int format) 399{ 400 switch(format) { 401 case HAL_PIXEL_FORMAT_YCbCr_420_SP: 402 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 403 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: 404 case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED: { 405 return 2; 406 } 407 case HAL_PIXEL_FORMAT_YV12: { 408 return 3; 409 } 410 default: 411 return COPYBIT_FAILURE; 412 } 413} 414 415static int is_supported_yuv_format(int format) 416{ 417 switch(format) { 418 case HAL_PIXEL_FORMAT_YCbCr_420_SP: 419 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 420 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: 421 case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED: { 422 return COPYBIT_SUCCESS; 423 } 424 default: 425 return COPYBIT_FAILURE; 426 } 427} 428 429static int is_valid_destination_format(int format) 430{ 431 if (format == HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED) { 432 // C2D does not support NV12Tile as a destination format. 433 return COPYBIT_FAILURE; 434 } 435 return COPYBIT_SUCCESS; 436} 437 438static int calculate_yuv_offset_and_stride(const bufferInfo& info, 439 yuvPlaneInfo& yuvInfo) 440{ 441 int width = info.width; 442 int height = info.height; 443 int format = info.format; 444 445 int aligned_height = 0; 446 int aligned_width = 0, size = 0; 447 448 switch (format) { 449 case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED: { 450 /* NV12 Tile buffers have their luma height aligned to 32bytes and width 451 * aligned to 128 bytes. The chroma offset starts at an 8K boundary 452 */ 453 aligned_height = ALIGN(height, 32); 454 aligned_width = ALIGN(width, 128); 455 size = aligned_width * aligned_height; 456 yuvInfo.plane1_offset = ALIGN(size,8192); 457 yuvInfo.yStride = aligned_width; 458 yuvInfo.plane1_stride = aligned_width; 459 break; 460 } 461 case HAL_PIXEL_FORMAT_YCbCr_420_SP: 462 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: 463 case HAL_PIXEL_FORMAT_YCrCb_420_SP: { 464 aligned_width = ALIGN(width, 32); 465 yuvInfo.yStride = aligned_width; 466 yuvInfo.plane1_stride = aligned_width; 467 if (HAL_PIXEL_FORMAT_NV12_ENCODEABLE == format) { 468 // The encoder requires a 2K aligned chroma offset 469 yuvInfo.plane1_offset = ALIGN(aligned_width * height, 2048); 470 } else 471 yuvInfo.plane1_offset = aligned_width * height; 472 473 break; 474 } 475 default: { 476 return COPYBIT_FAILURE; 477 } 478 } 479 return COPYBIT_SUCCESS; 480} 481 482/** create C2D surface from copybit image */ 483static int set_image(copybit_context_t* ctx, uint32 surfaceId, 484 const struct copybit_image_t *rhs, 485 const eC2DFlags flags, int &mapped_idx) 486{ 487 struct private_handle_t* handle = (struct private_handle_t*)rhs->handle; 488 C2D_SURFACE_TYPE surfaceType; 489 int status = COPYBIT_SUCCESS; 490 uint32 gpuaddr = 0; 491 int c2d_format; 492 mapped_idx = -1; 493 494 if (flags & FLAGS_YUV_DESTINATION) { 495 c2d_format = get_c2d_format_for_yuv_destination(rhs->format); 496 } else { 497 c2d_format = get_format(rhs->format); 498 } 499 500 if(c2d_format == -EINVAL) { 501 ALOGE("%s: invalid format", __FUNCTION__); 502 return -EINVAL; 503 } 504 505 if(handle == NULL) { 506 ALOGE("%s: invalid handle", __func__); 507 return -EINVAL; 508 } 509 510 if (handle->gpuaddr == 0) { 511 gpuaddr = c2d_get_gpuaddr(ctx, handle, mapped_idx); 512 if(!gpuaddr) { 513 ALOGE("%s: c2d_get_gpuaddr failed", __FUNCTION__); 514 return COPYBIT_FAILURE; 515 } 516 } else { 517 gpuaddr = handle->gpuaddr; 518 } 519 520 /* create C2D surface */ 521 if(is_supported_rgb_format(rhs->format) == COPYBIT_SUCCESS) { 522 /* RGB */ 523 C2D_RGB_SURFACE_DEF surfaceDef; 524 525 surfaceType = (C2D_SURFACE_TYPE) (C2D_SURFACE_RGB_HOST | C2D_SURFACE_WITH_PHYS); 526 527 surfaceDef.phys = (void*) gpuaddr; 528 surfaceDef.buffer = (void*) (handle->base); 529 530 surfaceDef.format = c2d_format | 531 ((flags & FLAGS_PREMULTIPLIED_ALPHA) ? C2D_FORMAT_PREMULTIPLIED : 0); 532 surfaceDef.width = rhs->w; 533 surfaceDef.height = rhs->h; 534 int aligned_width = ALIGN(surfaceDef.width,32); 535 surfaceDef.stride = (aligned_width * c2diGetBpp(surfaceDef.format))>>3; 536 537 if(LINK_c2dUpdateSurface( surfaceId,C2D_TARGET | C2D_SOURCE, surfaceType, 538 &surfaceDef)) { 539 ALOGE("%s: RGB Surface c2dUpdateSurface ERROR", __FUNCTION__); 540 unmap_gpuaddr(ctx, mapped_idx); 541 status = COPYBIT_FAILURE; 542 } 543 } else if (is_supported_yuv_format(rhs->format) == COPYBIT_SUCCESS) { 544 C2D_YUV_SURFACE_DEF surfaceDef; 545 memset(&surfaceDef, 0, sizeof(surfaceDef)); 546 surfaceType = (C2D_SURFACE_TYPE)(C2D_SURFACE_YUV_HOST | C2D_SURFACE_WITH_PHYS); 547 surfaceDef.format = c2d_format; 548 549 bufferInfo info; 550 info.width = rhs->w; 551 info.height = rhs->h; 552 info.format = rhs->format; 553 554 yuvPlaneInfo yuvInfo = {0}; 555 status = calculate_yuv_offset_and_stride(info, yuvInfo); 556 if(status != COPYBIT_SUCCESS) { 557 ALOGE("%s: calculate_yuv_offset_and_stride error", __FUNCTION__); 558 unmap_gpuaddr(ctx, mapped_idx); 559 } 560 561 surfaceDef.width = rhs->w; 562 surfaceDef.height = rhs->h; 563 surfaceDef.plane0 = (void*) (handle->base); 564 surfaceDef.phys0 = (void*) (gpuaddr); 565 surfaceDef.stride0 = yuvInfo.yStride; 566 567 surfaceDef.plane1 = (void*) (handle->base + yuvInfo.plane1_offset); 568 surfaceDef.phys1 = (void*) (gpuaddr + yuvInfo.plane1_offset); 569 surfaceDef.stride1 = yuvInfo.plane1_stride; 570 if (3 == get_num_planes(rhs->format)) { 571 surfaceDef.plane2 = (void*) (handle->base + yuvInfo.plane2_offset); 572 surfaceDef.phys2 = (void*) (gpuaddr + yuvInfo.plane2_offset); 573 surfaceDef.stride2 = yuvInfo.plane2_stride; 574 } 575 576 if(LINK_c2dUpdateSurface( surfaceId,C2D_TARGET | C2D_SOURCE, surfaceType, 577 &surfaceDef)) { 578 ALOGE("%s: YUV Surface c2dUpdateSurface ERROR", __FUNCTION__); 579 unmap_gpuaddr(ctx, mapped_idx); 580 status = COPYBIT_FAILURE; 581 } 582 } else { 583 ALOGE("%s: invalid format 0x%x", __FUNCTION__, rhs->format); 584 unmap_gpuaddr(ctx, mapped_idx); 585 status = COPYBIT_FAILURE; 586 } 587 588 return status; 589} 590 591/** copy the bits */ 592static int msm_copybit(struct copybit_context_t *ctx, unsigned int target) 593{ 594 if (ctx->blit_count == 0) { 595 return COPYBIT_SUCCESS; 596 } 597 598 for (int i = 0; i < ctx->blit_count; i++) 599 { 600 ctx->blit_list[i].next = &(ctx->blit_list[i+1]); 601 } 602 ctx->blit_list[ctx->blit_count-1].next = NULL; 603 uint32_t target_transform = ctx->trg_transform; 604 if (ctx->c2d_driver_info.capabilities_mask & 605 C2D_DRIVER_SUPPORTS_OVERRIDE_TARGET_ROTATE_OP) { 606 // For A3xx - set 0x0 as the transform is set in the config_mask 607 target_transform = 0x0; 608 } 609 if(LINK_c2dDraw(target, target_transform, 0x0, 0, 0, ctx->blit_list, 610 ctx->blit_count)) { 611 ALOGE("%s: LINK_c2dDraw ERROR", __FUNCTION__); 612 return COPYBIT_FAILURE; 613 } 614 return COPYBIT_SUCCESS; 615} 616 617 618 619static int flush_get_fence_copybit (struct copybit_device_t *dev, int* fd) 620{ 621 struct copybit_context_t* ctx = (struct copybit_context_t*)dev; 622 int status = COPYBIT_FAILURE; 623 if (!ctx) 624 return COPYBIT_FAILURE; 625 pthread_mutex_lock(&ctx->wait_cleanup_lock); 626 status = msm_copybit(ctx, ctx->dst[ctx->dst_surface_type]); 627 628 if(LINK_c2dFlush(ctx->dst[ctx->dst_surface_type], &ctx->time_stamp)) { 629 ALOGE("%s: LINK_c2dFlush ERROR", __FUNCTION__); 630 // unlock the mutex and return failure 631 pthread_mutex_unlock(&ctx->wait_cleanup_lock); 632 return COPYBIT_FAILURE; 633 } 634 if(LINK_c2dCreateFenceFD(ctx->dst[ctx->dst_surface_type], ctx->time_stamp, 635 fd)) { 636 ALOGE("%s: LINK_c2dCreateFenceFD ERROR", __FUNCTION__); 637 status = COPYBIT_FAILURE; 638 } 639 if(status == COPYBIT_SUCCESS) { 640 //signal the wait_thread 641 ctx->wait_timestamp = true; 642 pthread_cond_signal(&ctx->wait_cleanup_cond); 643 } 644 pthread_mutex_unlock(&ctx->wait_cleanup_lock); 645 return status; 646} 647 648static int finish_copybit(struct copybit_device_t *dev) 649{ 650 struct copybit_context_t* ctx = (struct copybit_context_t*)dev; 651 if (!ctx) 652 return COPYBIT_FAILURE; 653 654 int status = msm_copybit(ctx, ctx->dst[ctx->dst_surface_type]); 655 656 if(LINK_c2dFinish(ctx->dst[ctx->dst_surface_type])) { 657 ALOGE("%s: LINK_c2dFinish ERROR", __FUNCTION__); 658 return COPYBIT_FAILURE; 659 } 660 661 // Unmap any mapped addresses. 662 for (int i = 0; i < MAX_SURFACES; i++) { 663 if (ctx->mapped_gpu_addr[i]) { 664 LINK_c2dUnMapAddr( (void*)ctx->mapped_gpu_addr[i]); 665 ctx->mapped_gpu_addr[i] = 0; 666 } 667 } 668 669 // Reset the counts after the draw. 670 ctx->blit_rgb_count = 0; 671 ctx->blit_yuv_2_plane_count = 0; 672 ctx->blit_yuv_3_plane_count = 0; 673 ctx->blit_count = 0; 674 return status; 675} 676 677static int clear_copybit(struct copybit_device_t *dev, 678 struct copybit_image_t const *buf, 679 struct copybit_rect_t *rect) 680{ 681 int ret = COPYBIT_SUCCESS; 682 int flags = FLAGS_PREMULTIPLIED_ALPHA; 683 int mapped_dst_idx = -1; 684 struct copybit_context_t* ctx = (struct copybit_context_t*)dev; 685 C2D_RECT c2drect = {rect->l, rect->t, rect->r - rect->l, rect->b - rect->t}; 686 pthread_mutex_lock(&ctx->wait_cleanup_lock); 687 ret = set_image(ctx, ctx->dst[RGB_SURFACE], buf, 688 (eC2DFlags)flags, mapped_dst_idx); 689 if(ret) { 690 ALOGE("%s: set_image error", __FUNCTION__); 691 unmap_gpuaddr(ctx, mapped_dst_idx); 692 pthread_mutex_unlock(&ctx->wait_cleanup_lock); 693 return COPYBIT_FAILURE; 694 } 695 696 ret = LINK_c2dFillSurface(ctx->dst[RGB_SURFACE], 0x0, &c2drect); 697 pthread_mutex_unlock(&ctx->wait_cleanup_lock); 698 return ret; 699} 700 701 702/** setup rectangles */ 703static void set_rects(struct copybit_context_t *ctx, 704 C2D_OBJECT *c2dObject, 705 const struct copybit_rect_t *dst, 706 const struct copybit_rect_t *src, 707 const struct copybit_rect_t *scissor) 708{ 709 // Set the target rect. 710 if((ctx->trg_transform & C2D_TARGET_ROTATE_90) && 711 (ctx->trg_transform & C2D_TARGET_ROTATE_180)) { 712 /* target rotation is 270 */ 713 c2dObject->target_rect.x = (dst->t)<<16; 714 c2dObject->target_rect.y = ctx->fb_width?(ALIGN(ctx->fb_width,32)- dst->r):dst->r; 715 c2dObject->target_rect.y = c2dObject->target_rect.y<<16; 716 c2dObject->target_rect.height = ((dst->r) - (dst->l))<<16; 717 c2dObject->target_rect.width = ((dst->b) - (dst->t))<<16; 718 } else if(ctx->trg_transform & C2D_TARGET_ROTATE_90) { 719 c2dObject->target_rect.x = ctx->fb_height?(ctx->fb_height - dst->b):dst->b; 720 c2dObject->target_rect.x = c2dObject->target_rect.x<<16; 721 c2dObject->target_rect.y = (dst->l)<<16; 722 c2dObject->target_rect.height = ((dst->r) - (dst->l))<<16; 723 c2dObject->target_rect.width = ((dst->b) - (dst->t))<<16; 724 } else if(ctx->trg_transform & C2D_TARGET_ROTATE_180) { 725 c2dObject->target_rect.y = ctx->fb_height?(ctx->fb_height - dst->b):dst->b; 726 c2dObject->target_rect.y = c2dObject->target_rect.y<<16; 727 c2dObject->target_rect.x = ctx->fb_width?(ALIGN(ctx->fb_width,32) - dst->r):dst->r; 728 c2dObject->target_rect.x = c2dObject->target_rect.x<<16; 729 c2dObject->target_rect.height = ((dst->b) - (dst->t))<<16; 730 c2dObject->target_rect.width = ((dst->r) - (dst->l))<<16; 731 } else { 732 c2dObject->target_rect.x = (dst->l)<<16; 733 c2dObject->target_rect.y = (dst->t)<<16; 734 c2dObject->target_rect.height = ((dst->b) - (dst->t))<<16; 735 c2dObject->target_rect.width = ((dst->r) - (dst->l))<<16; 736 } 737 c2dObject->config_mask |= C2D_TARGET_RECT_BIT; 738 739 // Set the source rect 740 c2dObject->source_rect.x = (src->l)<<16; 741 c2dObject->source_rect.y = (src->t)<<16; 742 c2dObject->source_rect.height = ((src->b) - (src->t))<<16; 743 c2dObject->source_rect.width = ((src->r) - (src->l))<<16; 744 c2dObject->config_mask |= C2D_SOURCE_RECT_BIT; 745 746 // Set the scissor rect 747 c2dObject->scissor_rect.x = scissor->l; 748 c2dObject->scissor_rect.y = scissor->t; 749 c2dObject->scissor_rect.height = (scissor->b) - (scissor->t); 750 c2dObject->scissor_rect.width = (scissor->r) - (scissor->l); 751 c2dObject->config_mask |= C2D_SCISSOR_RECT_BIT; 752} 753 754/*****************************************************************************/ 755 756/** Set a parameter to value */ 757static int set_parameter_copybit( 758 struct copybit_device_t *dev, 759 int name, 760 int value) 761{ 762 struct copybit_context_t* ctx = (struct copybit_context_t*)dev; 763 int status = COPYBIT_SUCCESS; 764 if (!ctx) { 765 ALOGE("%s: null context", __FUNCTION__); 766 return -EINVAL; 767 } 768 769 pthread_mutex_lock(&ctx->wait_cleanup_lock); 770 switch(name) { 771 case COPYBIT_PLANE_ALPHA: 772 { 773 if (value < 0) value = 0; 774 if (value >= 256) value = 255; 775 776 ctx->src_global_alpha = value; 777 if (value < 255) 778 ctx->config_mask |= C2D_GLOBAL_ALPHA_BIT; 779 else 780 ctx->config_mask &= ~C2D_GLOBAL_ALPHA_BIT; 781 } 782 break; 783 case COPYBIT_BLEND_MODE: 784 { 785 if (value == COPYBIT_BLENDING_NONE) { 786 ctx->config_mask |= C2D_ALPHA_BLEND_NONE; 787 ctx->is_premultiplied_alpha = true; 788 } else if (value == COPYBIT_BLENDING_PREMULT) { 789 ctx->is_premultiplied_alpha = true; 790 } else { 791 ctx->config_mask &= ~C2D_ALPHA_BLEND_NONE; 792 } 793 } 794 break; 795 case COPYBIT_TRANSFORM: 796 { 797 unsigned int transform = 0; 798 uint32 config_mask = 0; 799 config_mask |= C2D_OVERRIDE_GLOBAL_TARGET_ROTATE_CONFIG; 800 if((value & 0x7) == COPYBIT_TRANSFORM_ROT_180) { 801 transform = C2D_TARGET_ROTATE_180; 802 config_mask |= C2D_OVERRIDE_TARGET_ROTATE_180; 803 } else if((value & 0x7) == COPYBIT_TRANSFORM_ROT_270) { 804 transform = C2D_TARGET_ROTATE_90; 805 config_mask |= C2D_OVERRIDE_TARGET_ROTATE_90; 806 } else if(value == COPYBIT_TRANSFORM_ROT_90) { 807 transform = C2D_TARGET_ROTATE_270; 808 config_mask |= C2D_OVERRIDE_TARGET_ROTATE_270; 809 } else { 810 config_mask |= C2D_OVERRIDE_TARGET_ROTATE_0; 811 if(value & COPYBIT_TRANSFORM_FLIP_H) { 812 config_mask |= C2D_MIRROR_H_BIT; 813 } else if(value & COPYBIT_TRANSFORM_FLIP_V) { 814 config_mask |= C2D_MIRROR_V_BIT; 815 } 816 } 817 818 if (ctx->c2d_driver_info.capabilities_mask & 819 C2D_DRIVER_SUPPORTS_OVERRIDE_TARGET_ROTATE_OP) { 820 ctx->config_mask |= config_mask; 821 } else { 822 // The transform for this surface does not match the current 823 // target transform. Draw all previous surfaces. This will be 824 // changed once we have a new mechanism to send different 825 // target rotations to c2d. 826 finish_copybit(dev); 827 } 828 ctx->trg_transform = transform; 829 } 830 break; 831 case COPYBIT_FRAMEBUFFER_WIDTH: 832 ctx->fb_width = value; 833 break; 834 case COPYBIT_FRAMEBUFFER_HEIGHT: 835 ctx->fb_height = value; 836 break; 837 case COPYBIT_ROTATION_DEG: 838 case COPYBIT_DITHER: 839 case COPYBIT_BLUR: 840 case COPYBIT_BLIT_TO_FRAMEBUFFER: 841 // Do nothing 842 break; 843 default: 844 ALOGE("%s: default case param=0x%x", __FUNCTION__, name); 845 status = -EINVAL; 846 break; 847 } 848 pthread_mutex_unlock(&ctx->wait_cleanup_lock); 849 return status; 850} 851 852/** Get a static info value */ 853static int get(struct copybit_device_t *dev, int name) 854{ 855 struct copybit_context_t* ctx = (struct copybit_context_t*)dev; 856 int value; 857 858 if (!ctx) { 859 ALOGE("%s: null context error", __FUNCTION__); 860 return -EINVAL; 861 } 862 863 switch(name) { 864 case COPYBIT_MINIFICATION_LIMIT: 865 value = MAX_SCALE_FACTOR; 866 break; 867 case COPYBIT_MAGNIFICATION_LIMIT: 868 value = MAX_SCALE_FACTOR; 869 break; 870 case COPYBIT_SCALING_FRAC_BITS: 871 value = 32; 872 break; 873 case COPYBIT_ROTATION_STEP_DEG: 874 value = 1; 875 break; 876 default: 877 ALOGE("%s: default case param=0x%x", __FUNCTION__, name); 878 value = -EINVAL; 879 } 880 return value; 881} 882 883static int is_alpha(int cformat) 884{ 885 int alpha = 0; 886 switch (cformat & 0xFF) { 887 case C2D_COLOR_FORMAT_8888_ARGB: 888 case C2D_COLOR_FORMAT_8888_RGBA: 889 case C2D_COLOR_FORMAT_5551_RGBA: 890 case C2D_COLOR_FORMAT_4444_ARGB: 891 alpha = 1; 892 break; 893 default: 894 alpha = 0; 895 break; 896 } 897 898 if(alpha && (cformat&C2D_FORMAT_DISABLE_ALPHA)) 899 alpha = 0; 900 901 return alpha; 902} 903 904/* Function to check if we need a temporary buffer for the blit. 905 * This would happen if the requested destination stride and the 906 * C2D stride do not match. We ignore RGB buffers, since their 907 * stride is always aligned to 32. 908 */ 909static bool need_temp_buffer(struct copybit_image_t const *img) 910{ 911 if (COPYBIT_SUCCESS == is_supported_rgb_format(img->format)) 912 return false; 913 914 struct private_handle_t* handle = (struct private_handle_t*)img->handle; 915 916 // The width parameter in the handle contains the aligned_w. We check if we 917 // need to convert based on this param. YUV formats have bpp=1, so checking 918 // if the requested stride is aligned should suffice. 919 if (0 == (handle->width)%32) { 920 return false; 921 } 922 923 return true; 924} 925 926/* Function to extract the information from the copybit image and set the corresponding 927 * values in the bufferInfo struct. 928 */ 929static void populate_buffer_info(struct copybit_image_t const *img, bufferInfo& info) 930{ 931 info.width = img->w; 932 info.height = img->h; 933 info.format = img->format; 934} 935 936/* Function to get the required size for a particular format, inorder for C2D to perform 937 * the blit operation. 938 */ 939static size_t get_size(const bufferInfo& info) 940{ 941 size_t size = 0; 942 int w = info.width; 943 int h = info.height; 944 int aligned_w = ALIGN(w, 32); 945 switch(info.format) { 946 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: 947 { 948 // Chroma for this format is aligned to 2K. 949 size = ALIGN((aligned_w*h), 2048) + 950 ALIGN(aligned_w/2, 32) * (h/2) *2; 951 size = ALIGN(size, 4096); 952 } break; 953 case HAL_PIXEL_FORMAT_YCbCr_420_SP: 954 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 955 { 956 size = aligned_w * h + 957 ALIGN(aligned_w/2, 32) * (h/2) * 2; 958 size = ALIGN(size, 4096); 959 } break; 960 default: break; 961 } 962 return size; 963} 964 965/* Function to allocate memory for the temporary buffer. This memory is 966 * allocated from Ashmem. It is the caller's responsibility to free this 967 * memory. 968 */ 969static int get_temp_buffer(const bufferInfo& info, alloc_data& data) 970{ 971 ALOGD("%s E", __FUNCTION__); 972 // Alloc memory from system heap 973 data.base = 0; 974 data.fd = -1; 975 data.offset = 0; 976 data.size = get_size(info); 977 data.align = getpagesize(); 978 data.uncached = true; 979 int allocFlags = GRALLOC_USAGE_PRIVATE_SYSTEM_HEAP; 980 981 if (sAlloc == 0) { 982 sAlloc = gralloc::IAllocController::getInstance(); 983 } 984 985 if (sAlloc == 0) { 986 ALOGE("%s: sAlloc is still NULL", __FUNCTION__); 987 return COPYBIT_FAILURE; 988 } 989 990 int err = sAlloc->allocate(data, allocFlags); 991 if (0 != err) { 992 ALOGE("%s: allocate failed", __FUNCTION__); 993 return COPYBIT_FAILURE; 994 } 995 996 ALOGD("%s X", __FUNCTION__); 997 return err; 998} 999 1000/* Function to free the temporary allocated memory.*/ 1001static void free_temp_buffer(alloc_data &data) 1002{ 1003 if (-1 != data.fd) { 1004 IMemAlloc* memalloc = sAlloc->getAllocator(data.allocType); 1005 memalloc->free_buffer(data.base, data.size, 0, data.fd); 1006 } 1007} 1008 1009/* Function to perform the software color conversion. Convert the 1010 * C2D compatible format to the Android compatible format 1011 */ 1012static int copy_image(private_handle_t *src_handle, 1013 struct copybit_image_t const *rhs, 1014 eConversionType conversionType) 1015{ 1016 if (src_handle->fd == -1) { 1017 ALOGE("%s: src_handle fd is invalid", __FUNCTION__); 1018 return COPYBIT_FAILURE; 1019 } 1020 1021 // Copy the info. 1022 int ret = COPYBIT_SUCCESS; 1023 switch(rhs->format) { 1024 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: 1025 case HAL_PIXEL_FORMAT_YCbCr_420_SP: 1026 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 1027 { 1028 if (CONVERT_TO_ANDROID_FORMAT == conversionType) { 1029 return convert_yuv_c2d_to_yuv_android(src_handle, rhs); 1030 } else { 1031 return convert_yuv_android_to_yuv_c2d(src_handle, rhs); 1032 } 1033 1034 } break; 1035 default: { 1036 ALOGE("%s: invalid format 0x%x", __FUNCTION__, rhs->format); 1037 ret = COPYBIT_FAILURE; 1038 } break; 1039 } 1040 return ret; 1041} 1042 1043static void delete_handle(private_handle_t *handle) 1044{ 1045 if (handle) { 1046 delete handle; 1047 handle = 0; 1048 } 1049} 1050 1051static bool need_to_execute_draw(struct copybit_context_t* ctx, 1052 eC2DFlags flags) 1053{ 1054 if (flags & FLAGS_TEMP_SRC_DST) { 1055 return true; 1056 } 1057 if (flags & FLAGS_YUV_DESTINATION) { 1058 return true; 1059 } 1060 return false; 1061} 1062 1063/** do a stretch blit type operation */ 1064static int stretch_copybit_internal( 1065 struct copybit_device_t *dev, 1066 struct copybit_image_t const *dst, 1067 struct copybit_image_t const *src, 1068 struct copybit_rect_t const *dst_rect, 1069 struct copybit_rect_t const *src_rect, 1070 struct copybit_region_t const *region, 1071 bool enableBlend) 1072{ 1073 struct copybit_context_t* ctx = (struct copybit_context_t*)dev; 1074 int status = COPYBIT_SUCCESS; 1075 int flags = 0; 1076 int src_surface_type; 1077 int mapped_src_idx = -1, mapped_dst_idx = -1; 1078 C2D_OBJECT_STR src_surface; 1079 1080 if (!ctx) { 1081 ALOGE("%s: null context error", __FUNCTION__); 1082 return -EINVAL; 1083 } 1084 1085 if (src->w > MAX_DIMENSION || src->h > MAX_DIMENSION) { 1086 ALOGE("%s: src dimension error", __FUNCTION__); 1087 return -EINVAL; 1088 } 1089 1090 if (dst->w > MAX_DIMENSION || dst->h > MAX_DIMENSION) { 1091 ALOGE("%s : dst dimension error dst w %d h %d", __FUNCTION__, dst->w, 1092 dst->h); 1093 return -EINVAL; 1094 } 1095 1096 if (is_valid_destination_format(dst->format) == COPYBIT_FAILURE) { 1097 ALOGE("%s: Invalid destination format format = 0x%x", __FUNCTION__, 1098 dst->format); 1099 return COPYBIT_FAILURE; 1100 } 1101 1102 int dst_surface_type; 1103 if (is_supported_rgb_format(dst->format) == COPYBIT_SUCCESS) { 1104 dst_surface_type = RGB_SURFACE; 1105 flags |= FLAGS_PREMULTIPLIED_ALPHA; 1106 } else if (is_supported_yuv_format(dst->format) == COPYBIT_SUCCESS) { 1107 int num_planes = get_num_planes(dst->format); 1108 flags |= FLAGS_YUV_DESTINATION; 1109 if (num_planes == 2) { 1110 dst_surface_type = YUV_SURFACE_2_PLANES; 1111 } else if (num_planes == 3) { 1112 dst_surface_type = YUV_SURFACE_3_PLANES; 1113 } else { 1114 ALOGE("%s: dst number of YUV planes is invalid dst format = 0x%x", 1115 __FUNCTION__, dst->format); 1116 return COPYBIT_FAILURE; 1117 } 1118 } else { 1119 ALOGE("%s: Invalid dst surface format 0x%x", __FUNCTION__, 1120 dst->format); 1121 return COPYBIT_FAILURE; 1122 } 1123 1124 if (ctx->blit_rgb_count == MAX_RGB_SURFACES || 1125 ctx->blit_yuv_2_plane_count == MAX_YUV_2_PLANE_SURFACES || 1126 ctx->blit_yuv_3_plane_count == MAX_YUV_2_PLANE_SURFACES || 1127 ctx->blit_count == MAX_BLIT_OBJECT_COUNT || 1128 ctx->dst_surface_type != dst_surface_type) { 1129 // we have reached the max. limits of our internal structures or 1130 // changed the target. 1131 // Draw the remaining surfaces. We need to do the finish here since 1132 // we need to free up the surface templates. 1133 finish_copybit(dev); 1134 } 1135 1136 ctx->dst_surface_type = dst_surface_type; 1137 1138 // Update the destination 1139 copybit_image_t dst_image; 1140 dst_image.w = dst->w; 1141 dst_image.h = dst->h; 1142 dst_image.format = dst->format; 1143 dst_image.handle = dst->handle; 1144 // Check if we need a temp. copy for the destination. We'd need this the destination 1145 // width is not aligned to 32. This case occurs for YUV formats. RGB formats are 1146 // aligned to 32. 1147 bool need_temp_dst = need_temp_buffer(dst); 1148 bufferInfo dst_info; 1149 populate_buffer_info(dst, dst_info); 1150 private_handle_t* dst_hnd = new private_handle_t(-1, 0, 0, 0, dst_info.format, 1151 dst_info.width, dst_info.height); 1152 if (dst_hnd == NULL) { 1153 ALOGE("%s: dst_hnd is null", __FUNCTION__); 1154 return COPYBIT_FAILURE; 1155 } 1156 if (need_temp_dst) { 1157 if (get_size(dst_info) != ctx->temp_dst_buffer.size) { 1158 free_temp_buffer(ctx->temp_dst_buffer); 1159 // Create a temp buffer and set that as the destination. 1160 if (COPYBIT_FAILURE == get_temp_buffer(dst_info, ctx->temp_dst_buffer)) { 1161 ALOGE("%s: get_temp_buffer(dst) failed", __FUNCTION__); 1162 delete_handle(dst_hnd); 1163 return COPYBIT_FAILURE; 1164 } 1165 } 1166 dst_hnd->fd = ctx->temp_dst_buffer.fd; 1167 dst_hnd->size = ctx->temp_dst_buffer.size; 1168 dst_hnd->flags = ctx->temp_dst_buffer.allocType; 1169 dst_hnd->base = (int)(ctx->temp_dst_buffer.base); 1170 dst_hnd->offset = ctx->temp_dst_buffer.offset; 1171 dst_hnd->gpuaddr = 0; 1172 dst_image.handle = dst_hnd; 1173 } 1174 1175 status = set_image(ctx, ctx->dst[ctx->dst_surface_type], &dst_image, 1176 (eC2DFlags)flags, mapped_dst_idx); 1177 if(status) { 1178 ALOGE("%s: dst: set_image error", __FUNCTION__); 1179 delete_handle(dst_hnd); 1180 unmap_gpuaddr(ctx, mapped_dst_idx); 1181 return COPYBIT_FAILURE; 1182 } 1183 1184 // Update the source 1185 flags = 0; 1186 if(is_supported_rgb_format(src->format) == COPYBIT_SUCCESS) { 1187 src_surface_type = RGB_SURFACE; 1188 src_surface = ctx->blit_rgb_object[ctx->blit_rgb_count]; 1189 } else if (is_supported_yuv_format(src->format) == COPYBIT_SUCCESS) { 1190 int num_planes = get_num_planes(src->format); 1191 if (num_planes == 2) { 1192 src_surface_type = YUV_SURFACE_2_PLANES; 1193 src_surface = ctx->blit_yuv_2_plane_object[ctx->blit_yuv_2_plane_count]; 1194 } else if (num_planes == 3) { 1195 src_surface_type = YUV_SURFACE_3_PLANES; 1196 src_surface = ctx->blit_yuv_3_plane_object[ctx->blit_yuv_2_plane_count]; 1197 } else { 1198 ALOGE("%s: src number of YUV planes is invalid src format = 0x%x", 1199 __FUNCTION__, src->format); 1200 delete_handle(dst_hnd); 1201 unmap_gpuaddr(ctx, mapped_dst_idx); 1202 return -EINVAL; 1203 } 1204 } else { 1205 ALOGE("%s: Invalid source surface format 0x%x", __FUNCTION__, 1206 src->format); 1207 delete_handle(dst_hnd); 1208 unmap_gpuaddr(ctx, mapped_dst_idx); 1209 return -EINVAL; 1210 } 1211 1212 copybit_image_t src_image; 1213 src_image.w = src->w; 1214 src_image.h = src->h; 1215 src_image.format = src->format; 1216 src_image.handle = src->handle; 1217 1218 bool need_temp_src = need_temp_buffer(src); 1219 bufferInfo src_info; 1220 populate_buffer_info(src, src_info); 1221 private_handle_t* src_hnd = new private_handle_t(-1, 0, 0, 0, src_info.format, 1222 src_info.width, src_info.height); 1223 if (NULL == src_hnd) { 1224 ALOGE("%s: src_hnd is null", __FUNCTION__); 1225 delete_handle(dst_hnd); 1226 unmap_gpuaddr(ctx, mapped_dst_idx); 1227 return COPYBIT_FAILURE; 1228 } 1229 if (need_temp_src) { 1230 if (get_size(src_info) != ctx->temp_src_buffer.size) { 1231 free_temp_buffer(ctx->temp_src_buffer); 1232 // Create a temp buffer and set that as the destination. 1233 if (COPYBIT_SUCCESS != get_temp_buffer(src_info, 1234 ctx->temp_src_buffer)) { 1235 ALOGE("%s: get_temp_buffer(src) failed", __FUNCTION__); 1236 delete_handle(dst_hnd); 1237 delete_handle(src_hnd); 1238 unmap_gpuaddr(ctx, mapped_dst_idx); 1239 return COPYBIT_FAILURE; 1240 } 1241 } 1242 src_hnd->fd = ctx->temp_src_buffer.fd; 1243 src_hnd->size = ctx->temp_src_buffer.size; 1244 src_hnd->flags = ctx->temp_src_buffer.allocType; 1245 src_hnd->base = (int)(ctx->temp_src_buffer.base); 1246 src_hnd->offset = ctx->temp_src_buffer.offset; 1247 src_hnd->gpuaddr = 0; 1248 src_image.handle = src_hnd; 1249 1250 // Copy the source. 1251 status = copy_image((private_handle_t *)src->handle, &src_image, 1252 CONVERT_TO_C2D_FORMAT); 1253 if (status == COPYBIT_FAILURE) { 1254 ALOGE("%s:copy_image failed in temp source",__FUNCTION__); 1255 delete_handle(dst_hnd); 1256 delete_handle(src_hnd); 1257 unmap_gpuaddr(ctx, mapped_dst_idx); 1258 return status; 1259 } 1260 1261 // Clean the cache 1262 IMemAlloc* memalloc = sAlloc->getAllocator(src_hnd->flags); 1263 if (memalloc->clean_buffer((void *)(src_hnd->base), src_hnd->size, 1264 src_hnd->offset, src_hnd->fd, 1265 gralloc::CACHE_CLEAN)) { 1266 ALOGE("%s: clean_buffer failed", __FUNCTION__); 1267 delete_handle(dst_hnd); 1268 delete_handle(src_hnd); 1269 unmap_gpuaddr(ctx, mapped_dst_idx); 1270 return COPYBIT_FAILURE; 1271 } 1272 } 1273 1274 flags |= (ctx->is_premultiplied_alpha) ? FLAGS_PREMULTIPLIED_ALPHA : 0; 1275 flags |= (ctx->dst_surface_type != RGB_SURFACE) ? FLAGS_YUV_DESTINATION : 0; 1276 status = set_image(ctx, src_surface.surface_id, &src_image, 1277 (eC2DFlags)flags, mapped_src_idx); 1278 if(status) { 1279 ALOGE("%s: set_image (src) error", __FUNCTION__); 1280 delete_handle(dst_hnd); 1281 delete_handle(src_hnd); 1282 unmap_gpuaddr(ctx, mapped_dst_idx); 1283 unmap_gpuaddr(ctx, mapped_src_idx); 1284 return COPYBIT_FAILURE; 1285 } 1286 1287 src_surface.config_mask = C2D_NO_ANTIALIASING_BIT | ctx->config_mask; 1288 src_surface.global_alpha = ctx->src_global_alpha; 1289 if (enableBlend) { 1290 if(src_surface.config_mask & C2D_GLOBAL_ALPHA_BIT) { 1291 src_surface.config_mask &= ~C2D_ALPHA_BLEND_NONE; 1292 if(!(src_surface.global_alpha)) { 1293 // src alpha is zero 1294 delete_handle(dst_hnd); 1295 delete_handle(src_hnd); 1296 unmap_gpuaddr(ctx, mapped_dst_idx); 1297 unmap_gpuaddr(ctx, mapped_src_idx); 1298 return COPYBIT_FAILURE; 1299 } 1300 } 1301 } else { 1302 src_surface.config_mask |= C2D_ALPHA_BLEND_NONE; 1303 } 1304 1305 if (src_surface_type == RGB_SURFACE) { 1306 ctx->blit_rgb_object[ctx->blit_rgb_count] = src_surface; 1307 ctx->blit_rgb_count++; 1308 } else if (src_surface_type == YUV_SURFACE_2_PLANES) { 1309 ctx->blit_yuv_2_plane_object[ctx->blit_yuv_2_plane_count] = src_surface; 1310 ctx->blit_yuv_2_plane_count++; 1311 } else { 1312 ctx->blit_yuv_3_plane_object[ctx->blit_yuv_3_plane_count] = src_surface; 1313 ctx->blit_yuv_3_plane_count++; 1314 } 1315 1316 struct copybit_rect_t clip; 1317 while ((status == 0) && region->next(region, &clip)) { 1318 set_rects(ctx, &(src_surface), dst_rect, src_rect, &clip); 1319 if (ctx->blit_count == MAX_BLIT_OBJECT_COUNT) { 1320 ALOGW("Reached end of blit count"); 1321 finish_copybit(dev); 1322 } 1323 ctx->blit_list[ctx->blit_count] = src_surface; 1324 ctx->blit_count++; 1325 } 1326 1327 // Check if we need to perform an early draw-finish. 1328 flags |= (need_temp_dst || need_temp_src) ? FLAGS_TEMP_SRC_DST : 0; 1329 if (need_to_execute_draw(ctx, (eC2DFlags)flags)) 1330 { 1331 finish_copybit(dev); 1332 } 1333 1334 if (need_temp_dst) { 1335 // copy the temp. destination without the alignment to the actual 1336 // destination. 1337 status = copy_image(dst_hnd, dst, CONVERT_TO_ANDROID_FORMAT); 1338 if (status == COPYBIT_FAILURE) { 1339 ALOGE("%s:copy_image failed in temp Dest",__FUNCTION__); 1340 delete_handle(dst_hnd); 1341 delete_handle(src_hnd); 1342 unmap_gpuaddr(ctx, mapped_dst_idx); 1343 unmap_gpuaddr(ctx, mapped_src_idx); 1344 return status; 1345 } 1346 // Clean the cache. 1347 IMemAlloc* memalloc = sAlloc->getAllocator(dst_hnd->flags); 1348 memalloc->clean_buffer((void *)(dst_hnd->base), dst_hnd->size, 1349 dst_hnd->offset, dst_hnd->fd, 1350 gralloc::CACHE_CLEAN); 1351 } 1352 delete_handle(dst_hnd); 1353 delete_handle(src_hnd); 1354 1355 ctx->is_premultiplied_alpha = false; 1356 ctx->fb_width = 0; 1357 ctx->fb_height = 0; 1358 ctx->config_mask = 0; 1359 return status; 1360} 1361 1362 1363static int stretch_copybit( 1364 struct copybit_device_t *dev, 1365 struct copybit_image_t const *dst, 1366 struct copybit_image_t const *src, 1367 struct copybit_rect_t const *dst_rect, 1368 struct copybit_rect_t const *src_rect, 1369 struct copybit_region_t const *region) 1370{ 1371 struct copybit_context_t* ctx = (struct copybit_context_t*)dev; 1372 int status = COPYBIT_SUCCESS; 1373 bool needsBlending = (ctx->src_global_alpha != 0); 1374 pthread_mutex_lock(&ctx->wait_cleanup_lock); 1375 status = stretch_copybit_internal(dev, dst, src, dst_rect, src_rect, 1376 region, needsBlending); 1377 pthread_mutex_unlock(&ctx->wait_cleanup_lock); 1378 return status; 1379} 1380 1381/** Perform a blit type operation */ 1382static int blit_copybit( 1383 struct copybit_device_t *dev, 1384 struct copybit_image_t const *dst, 1385 struct copybit_image_t const *src, 1386 struct copybit_region_t const *region) 1387{ 1388 int status = COPYBIT_SUCCESS; 1389 struct copybit_context_t* ctx = (struct copybit_context_t*)dev; 1390 struct copybit_rect_t dr = { 0, 0, dst->w, dst->h }; 1391 struct copybit_rect_t sr = { 0, 0, src->w, src->h }; 1392 pthread_mutex_lock(&ctx->wait_cleanup_lock); 1393 status = stretch_copybit_internal(dev, dst, src, &dr, &sr, region, false); 1394 pthread_mutex_unlock(&ctx->wait_cleanup_lock); 1395 return status; 1396} 1397 1398/*****************************************************************************/ 1399 1400static void clean_up(copybit_context_t* ctx) 1401{ 1402 void* ret; 1403 if (!ctx) 1404 return; 1405 1406 // stop the wait_cleanup_thread 1407 pthread_mutex_lock(&ctx->wait_cleanup_lock); 1408 ctx->stop_thread = true; 1409 // Signal waiting thread 1410 pthread_cond_signal(&ctx->wait_cleanup_cond); 1411 pthread_mutex_unlock(&ctx->wait_cleanup_lock); 1412 // waits for the cleanup thread to exit 1413 pthread_join(ctx->wait_thread_id, &ret); 1414 pthread_mutex_destroy(&ctx->wait_cleanup_lock); 1415 pthread_cond_destroy (&ctx->wait_cleanup_cond); 1416 1417 for (int i = 0; i < NUM_SURFACE_TYPES; i++) { 1418 if (ctx->dst[i]) 1419 LINK_c2dDestroySurface(ctx->dst[i]); 1420 } 1421 1422 for (int i = 0; i < MAX_RGB_SURFACES; i++) { 1423 if (ctx->blit_rgb_object[i].surface_id) 1424 LINK_c2dDestroySurface(ctx->blit_rgb_object[i].surface_id); 1425 } 1426 1427 for (int i = 0; i < MAX_YUV_2_PLANE_SURFACES; i++) { 1428 if (ctx->blit_yuv_2_plane_object[i].surface_id) 1429 LINK_c2dDestroySurface(ctx->blit_yuv_2_plane_object[i].surface_id); 1430 } 1431 1432 for (int i = 0; i < MAX_YUV_3_PLANE_SURFACES; i++) { 1433 if (ctx->blit_yuv_3_plane_object[i].surface_id) 1434 LINK_c2dDestroySurface(ctx->blit_yuv_3_plane_object[i].surface_id); 1435 } 1436 1437 if (ctx->libc2d2) { 1438 ::dlclose(ctx->libc2d2); 1439 ALOGV("dlclose(libc2d2)"); 1440 } 1441 1442 free(ctx); 1443} 1444 1445/** Close the copybit device */ 1446static int close_copybit(struct hw_device_t *dev) 1447{ 1448 struct copybit_context_t* ctx = (struct copybit_context_t*)dev; 1449 if (ctx) { 1450 free_temp_buffer(ctx->temp_src_buffer); 1451 free_temp_buffer(ctx->temp_dst_buffer); 1452 } 1453 clean_up(ctx); 1454 return 0; 1455} 1456 1457/** Open a new instance of a copybit device using name */ 1458static int open_copybit(const struct hw_module_t* module, const char* name, 1459 struct hw_device_t** device) 1460{ 1461 int status = COPYBIT_SUCCESS; 1462 C2D_RGB_SURFACE_DEF surfDefinition = {0}; 1463 C2D_YUV_SURFACE_DEF yuvSurfaceDef = {0} ; 1464 struct copybit_context_t *ctx; 1465 char fbName[64]; 1466 1467 ctx = (struct copybit_context_t *)malloc(sizeof(struct copybit_context_t)); 1468 if(!ctx) { 1469 ALOGE("%s: malloc failed", __FUNCTION__); 1470 return COPYBIT_FAILURE; 1471 } 1472 1473 /* initialize drawstate */ 1474 memset(ctx, 0, sizeof(*ctx)); 1475 ctx->libc2d2 = ::dlopen("libC2D2.so", RTLD_NOW); 1476 if (!ctx->libc2d2) { 1477 ALOGE("FATAL ERROR: could not dlopen libc2d2.so: %s", dlerror()); 1478 clean_up(ctx); 1479 status = COPYBIT_FAILURE; 1480 *device = NULL; 1481 return status; 1482 } 1483 *(void **)&LINK_c2dCreateSurface = ::dlsym(ctx->libc2d2, 1484 "c2dCreateSurface"); 1485 *(void **)&LINK_c2dUpdateSurface = ::dlsym(ctx->libc2d2, 1486 "c2dUpdateSurface"); 1487 *(void **)&LINK_c2dReadSurface = ::dlsym(ctx->libc2d2, 1488 "c2dReadSurface"); 1489 *(void **)&LINK_c2dDraw = ::dlsym(ctx->libc2d2, "c2dDraw"); 1490 *(void **)&LINK_c2dFlush = ::dlsym(ctx->libc2d2, "c2dFlush"); 1491 *(void **)&LINK_c2dFinish = ::dlsym(ctx->libc2d2, "c2dFinish"); 1492 *(void **)&LINK_c2dWaitTimestamp = ::dlsym(ctx->libc2d2, 1493 "c2dWaitTimestamp"); 1494 *(void **)&LINK_c2dDestroySurface = ::dlsym(ctx->libc2d2, 1495 "c2dDestroySurface"); 1496 *(void **)&LINK_c2dMapAddr = ::dlsym(ctx->libc2d2, 1497 "c2dMapAddr"); 1498 *(void **)&LINK_c2dUnMapAddr = ::dlsym(ctx->libc2d2, 1499 "c2dUnMapAddr"); 1500 *(void **)&LINK_c2dGetDriverCapabilities = ::dlsym(ctx->libc2d2, 1501 "c2dGetDriverCapabilities"); 1502 *(void **)&LINK_c2dCreateFenceFD = ::dlsym(ctx->libc2d2, 1503 "c2dCreateFenceFD"); 1504 *(void **)&LINK_c2dFillSurface = ::dlsym(ctx->libc2d2, 1505 "c2dFillSurface"); 1506 1507 if (!LINK_c2dCreateSurface || !LINK_c2dUpdateSurface || !LINK_c2dReadSurface 1508 || !LINK_c2dDraw || !LINK_c2dFlush || !LINK_c2dWaitTimestamp || 1509 !LINK_c2dFinish || !LINK_c2dDestroySurface || 1510 !LINK_c2dGetDriverCapabilities || !LINK_c2dCreateFenceFD || 1511 !LINK_c2dFillSurface) { 1512 ALOGE("%s: dlsym ERROR", __FUNCTION__); 1513 clean_up(ctx); 1514 status = COPYBIT_FAILURE; 1515 *device = NULL; 1516 return status; 1517 } 1518 1519 ctx->device.common.tag = HARDWARE_DEVICE_TAG; 1520 ctx->device.common.version = 1; 1521 ctx->device.common.module = (hw_module_t*)(module); 1522 ctx->device.common.close = close_copybit; 1523 ctx->device.set_parameter = set_parameter_copybit; 1524 ctx->device.get = get; 1525 ctx->device.blit = blit_copybit; 1526 ctx->device.stretch = stretch_copybit; 1527 ctx->device.finish = finish_copybit; 1528 ctx->device.flush_get_fence = flush_get_fence_copybit; 1529 ctx->device.clear = clear_copybit; 1530 1531 /* Create RGB Surface */ 1532 surfDefinition.buffer = (void*)0xdddddddd; 1533 surfDefinition.phys = (void*)0xdddddddd; 1534 surfDefinition.stride = 1 * 4; 1535 surfDefinition.width = 1; 1536 surfDefinition.height = 1; 1537 surfDefinition.format = C2D_COLOR_FORMAT_8888_ARGB; 1538 if (LINK_c2dCreateSurface(&(ctx->dst[RGB_SURFACE]), C2D_TARGET | C2D_SOURCE, 1539 (C2D_SURFACE_TYPE)(C2D_SURFACE_RGB_HOST | 1540 C2D_SURFACE_WITH_PHYS | 1541 C2D_SURFACE_WITH_PHYS_DUMMY ), 1542 &surfDefinition)) { 1543 ALOGE("%s: create ctx->dst_surface[RGB_SURFACE] failed", __FUNCTION__); 1544 ctx->dst[RGB_SURFACE] = 0; 1545 clean_up(ctx); 1546 status = COPYBIT_FAILURE; 1547 *device = NULL; 1548 return status; 1549 } 1550 1551 unsigned int surface_id = 0; 1552 for (int i = 0; i < MAX_RGB_SURFACES; i++) 1553 { 1554 if (LINK_c2dCreateSurface(&surface_id, C2D_TARGET | C2D_SOURCE, 1555 (C2D_SURFACE_TYPE)(C2D_SURFACE_RGB_HOST | 1556 C2D_SURFACE_WITH_PHYS | 1557 C2D_SURFACE_WITH_PHYS_DUMMY ), 1558 &surfDefinition)) { 1559 ALOGE("%s: create RGB source surface %d failed", __FUNCTION__, i); 1560 ctx->blit_rgb_object[i].surface_id = 0; 1561 status = COPYBIT_FAILURE; 1562 break; 1563 } else { 1564 ctx->blit_rgb_object[i].surface_id = surface_id; 1565 ALOGW("%s i = %d surface_id=%d", __FUNCTION__, i, 1566 ctx->blit_rgb_object[i].surface_id); 1567 } 1568 } 1569 1570 if (status == COPYBIT_FAILURE) { 1571 clean_up(ctx); 1572 status = COPYBIT_FAILURE; 1573 *device = NULL; 1574 return status; 1575 } 1576 1577 // Create 2 plane YUV surfaces 1578 yuvSurfaceDef.format = C2D_COLOR_FORMAT_420_NV12; 1579 yuvSurfaceDef.width = 4; 1580 yuvSurfaceDef.height = 4; 1581 yuvSurfaceDef.plane0 = (void*)0xaaaaaaaa; 1582 yuvSurfaceDef.phys0 = (void*) 0xaaaaaaaa; 1583 yuvSurfaceDef.stride0 = 4; 1584 1585 yuvSurfaceDef.plane1 = (void*)0xaaaaaaaa; 1586 yuvSurfaceDef.phys1 = (void*) 0xaaaaaaaa; 1587 yuvSurfaceDef.stride1 = 4; 1588 if (LINK_c2dCreateSurface(&(ctx->dst[YUV_SURFACE_2_PLANES]), 1589 C2D_TARGET | C2D_SOURCE, 1590 (C2D_SURFACE_TYPE)(C2D_SURFACE_YUV_HOST | 1591 C2D_SURFACE_WITH_PHYS | 1592 C2D_SURFACE_WITH_PHYS_DUMMY), 1593 &yuvSurfaceDef)) { 1594 ALOGE("%s: create ctx->dst[YUV_SURFACE_2_PLANES] failed", __FUNCTION__); 1595 ctx->dst[YUV_SURFACE_2_PLANES] = 0; 1596 clean_up(ctx); 1597 status = COPYBIT_FAILURE; 1598 *device = NULL; 1599 return status; 1600 } 1601 1602 for (int i=0; i < MAX_YUV_2_PLANE_SURFACES; i++) 1603 { 1604 if (LINK_c2dCreateSurface(&surface_id, C2D_TARGET | C2D_SOURCE, 1605 (C2D_SURFACE_TYPE)(C2D_SURFACE_YUV_HOST | 1606 C2D_SURFACE_WITH_PHYS | 1607 C2D_SURFACE_WITH_PHYS_DUMMY ), 1608 &yuvSurfaceDef)) { 1609 ALOGE("%s: create YUV source %d failed", __FUNCTION__, i); 1610 ctx->blit_yuv_2_plane_object[i].surface_id = 0; 1611 status = COPYBIT_FAILURE; 1612 break; 1613 } else { 1614 ctx->blit_yuv_2_plane_object[i].surface_id = surface_id; 1615 ALOGW("%s: 2 Plane YUV i=%d surface_id=%d", __FUNCTION__, i, 1616 ctx->blit_yuv_2_plane_object[i].surface_id); 1617 } 1618 } 1619 1620 if (status == COPYBIT_FAILURE) { 1621 clean_up(ctx); 1622 status = COPYBIT_FAILURE; 1623 *device = NULL; 1624 return status; 1625 } 1626 1627 // Create YUV 3 plane surfaces 1628 yuvSurfaceDef.format = C2D_COLOR_FORMAT_420_YV12; 1629 yuvSurfaceDef.plane2 = (void*)0xaaaaaaaa; 1630 yuvSurfaceDef.phys2 = (void*) 0xaaaaaaaa; 1631 yuvSurfaceDef.stride2 = 4; 1632 1633 if (LINK_c2dCreateSurface(&(ctx->dst[YUV_SURFACE_3_PLANES]), 1634 C2D_TARGET | C2D_SOURCE, 1635 (C2D_SURFACE_TYPE)(C2D_SURFACE_YUV_HOST | 1636 C2D_SURFACE_WITH_PHYS | 1637 C2D_SURFACE_WITH_PHYS_DUMMY), 1638 &yuvSurfaceDef)) { 1639 ALOGE("%s: create ctx->dst[YUV_SURFACE_3_PLANES] failed", __FUNCTION__); 1640 ctx->dst[YUV_SURFACE_3_PLANES] = 0; 1641 clean_up(ctx); 1642 status = COPYBIT_FAILURE; 1643 *device = NULL; 1644 return status; 1645 } 1646 1647 for (int i=0; i < MAX_YUV_3_PLANE_SURFACES; i++) 1648 { 1649 if (LINK_c2dCreateSurface(&(surface_id), 1650 C2D_TARGET | C2D_SOURCE, 1651 (C2D_SURFACE_TYPE)(C2D_SURFACE_YUV_HOST | 1652 C2D_SURFACE_WITH_PHYS | 1653 C2D_SURFACE_WITH_PHYS_DUMMY), 1654 &yuvSurfaceDef)) { 1655 ALOGE("%s: create 3 plane YUV surface %d failed", __FUNCTION__, i); 1656 ctx->blit_yuv_3_plane_object[i].surface_id = 0; 1657 status = COPYBIT_FAILURE; 1658 break; 1659 } else { 1660 ctx->blit_yuv_3_plane_object[i].surface_id = surface_id; 1661 ALOGW("%s: 3 Plane YUV i=%d surface_id=%d", __FUNCTION__, i, 1662 ctx->blit_yuv_3_plane_object[i].surface_id); 1663 } 1664 } 1665 1666 if (status == COPYBIT_FAILURE) { 1667 clean_up(ctx); 1668 status = COPYBIT_FAILURE; 1669 *device = NULL; 1670 return status; 1671 } 1672 1673 if (LINK_c2dGetDriverCapabilities(&(ctx->c2d_driver_info))) { 1674 ALOGE("%s: LINK_c2dGetDriverCapabilities failed", __FUNCTION__); 1675 clean_up(ctx); 1676 status = COPYBIT_FAILURE; 1677 *device = NULL; 1678 return status; 1679 } 1680 // Initialize context variables. 1681 ctx->trg_transform = C2D_TARGET_ROTATE_0; 1682 1683 ctx->temp_src_buffer.fd = -1; 1684 ctx->temp_src_buffer.base = 0; 1685 ctx->temp_src_buffer.size = 0; 1686 1687 ctx->temp_dst_buffer.fd = -1; 1688 ctx->temp_dst_buffer.base = 0; 1689 ctx->temp_dst_buffer.size = 0; 1690 1691 ctx->fb_width = 0; 1692 ctx->fb_height = 0; 1693 1694 ctx->blit_rgb_count = 0; 1695 ctx->blit_yuv_2_plane_count = 0; 1696 ctx->blit_yuv_3_plane_count = 0; 1697 ctx->blit_count = 0; 1698 1699 ctx->wait_timestamp = false; 1700 ctx->stop_thread = false; 1701 pthread_mutex_init(&(ctx->wait_cleanup_lock), NULL); 1702 pthread_cond_init(&(ctx->wait_cleanup_cond), NULL); 1703 /* Start the wait thread */ 1704 pthread_attr_t attr; 1705 pthread_attr_init(&attr); 1706 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); 1707 1708 pthread_create(&ctx->wait_thread_id, &attr, &c2d_wait_loop, 1709 (void *)ctx); 1710 pthread_attr_destroy(&attr); 1711 1712 *device = &ctx->device.common; 1713 return status; 1714} 1715