1 /*
2 * Copyright (c) 2011-2020, The Linux Foundation. All rights reserved.
3
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above
10 * copyright notice, this list of conditions and the following
11 * disclaimer in the documentation and/or other materials provided
12 * with the distribution.
13 * * Neither the name of The Linux Foundation nor the names of its
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #ifndef QMAA
31 #include <media/msm_media_info.h>
32 #endif
33
34 #include <drm/drm_fourcc.h>
35
36 #include <cutils/properties.h>
37 #include <algorithm>
38
39 #include "gr_adreno_info.h"
40 #include "gr_camera_info.h"
41 #include "gr_utils.h"
42
43 #define ASTC_BLOCK_SIZE 16
44
45 namespace gralloc {
46
IsYuvFormat(int format)47 bool IsYuvFormat(int format) {
48 switch (format) {
49 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
50 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
51 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
52 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: // Same as YCbCr_420_SP_VENUS
53 case HAL_PIXEL_FORMAT_NV21_ENCODEABLE:
54 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
55 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
56 case HAL_PIXEL_FORMAT_YCrCb_422_SP:
57 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
58 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
59 case HAL_PIXEL_FORMAT_NV21_ZSL:
60 case HAL_PIXEL_FORMAT_RAW16:
61 case HAL_PIXEL_FORMAT_Y16:
62 case HAL_PIXEL_FORMAT_RAW12:
63 case HAL_PIXEL_FORMAT_RAW10:
64 case HAL_PIXEL_FORMAT_YV12:
65 case HAL_PIXEL_FORMAT_Y8:
66 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
67 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
68 case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
69 case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
70 // Below formats used by camera and VR
71 case HAL_PIXEL_FORMAT_BLOB:
72 case HAL_PIXEL_FORMAT_RAW_OPAQUE:
73 case HAL_PIXEL_FORMAT_NV12_HEIF:
74 case HAL_PIXEL_FORMAT_CbYCrY_422_I:
75 case HAL_PIXEL_FORMAT_NV12_LINEAR_FLEX :
76 case HAL_PIXEL_FORMAT_NV12_UBWC_FLEX:
77 case HAL_PIXEL_FORMAT_NV12_UBWC_FLEX_2_BATCH:
78 case HAL_PIXEL_FORMAT_NV12_UBWC_FLEX_4_BATCH:
79 case HAL_PIXEL_FORMAT_NV12_UBWC_FLEX_8_BATCH:
80 case HAL_PIXEL_FORMAT_MULTIPLANAR_FLEX:
81 return true;
82 default:
83 return false;
84 }
85 }
86
IsUncompressedRGBFormat(int format)87 bool IsUncompressedRGBFormat(int format) {
88 switch (format) {
89 case HAL_PIXEL_FORMAT_RGBA_8888:
90 case HAL_PIXEL_FORMAT_RGBX_8888:
91 case HAL_PIXEL_FORMAT_RGB_888:
92 case HAL_PIXEL_FORMAT_RGB_565:
93 case HAL_PIXEL_FORMAT_BGR_565:
94 case HAL_PIXEL_FORMAT_BGRA_8888:
95 case HAL_PIXEL_FORMAT_RGBA_5551:
96 case HAL_PIXEL_FORMAT_RGBA_4444:
97 case HAL_PIXEL_FORMAT_R_8:
98 case HAL_PIXEL_FORMAT_RG_88:
99 case HAL_PIXEL_FORMAT_BGRX_8888:
100 case HAL_PIXEL_FORMAT_RGBA_1010102:
101 case HAL_PIXEL_FORMAT_ARGB_2101010:
102 case HAL_PIXEL_FORMAT_RGBX_1010102:
103 case HAL_PIXEL_FORMAT_XRGB_2101010:
104 case HAL_PIXEL_FORMAT_BGRA_1010102:
105 case HAL_PIXEL_FORMAT_ABGR_2101010:
106 case HAL_PIXEL_FORMAT_BGRX_1010102:
107 case HAL_PIXEL_FORMAT_XBGR_2101010:
108 case HAL_PIXEL_FORMAT_RGBA_FP16:
109 case HAL_PIXEL_FORMAT_BGR_888:
110 return true;
111 default:
112 break;
113 }
114
115 return false;
116 }
117
IsCompressedRGBFormat(int format)118 bool IsCompressedRGBFormat(int format) {
119 switch (format) {
120 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_4x4_KHR:
121 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
122 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x4_KHR:
123 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
124 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x5_KHR:
125 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
126 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x5_KHR:
127 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
128 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x6_KHR:
129 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
130 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x5_KHR:
131 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
132 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x6_KHR:
133 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
134 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x8_KHR:
135 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
136 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x5_KHR:
137 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
138 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x6_KHR:
139 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
140 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x8_KHR:
141 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
142 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x10_KHR:
143 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
144 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x10_KHR:
145 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
146 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x12_KHR:
147 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
148 return true;
149 default:
150 break;
151 }
152
153 return false;
154 }
155
IsCameraCustomFormat(int format)156 bool IsCameraCustomFormat(int format) {
157 switch (format) {
158 case HAL_PIXEL_FORMAT_NV21_ZSL:
159 case HAL_PIXEL_FORMAT_NV12_LINEAR_FLEX:
160 case HAL_PIXEL_FORMAT_NV12_UBWC_FLEX:
161 case HAL_PIXEL_FORMAT_NV12_UBWC_FLEX_2_BATCH:
162 case HAL_PIXEL_FORMAT_NV12_UBWC_FLEX_4_BATCH:
163 case HAL_PIXEL_FORMAT_NV12_UBWC_FLEX_8_BATCH:
164 case HAL_PIXEL_FORMAT_MULTIPLANAR_FLEX:
165 case HAL_PIXEL_FORMAT_RAW_OPAQUE:
166 case HAL_PIXEL_FORMAT_RAW10:
167 case HAL_PIXEL_FORMAT_RAW12:
168 return true;
169 default:
170 break;
171 }
172
173 return false;
174 }
175
GetBppForUncompressedRGB(int format)176 uint32_t GetBppForUncompressedRGB(int format) {
177 uint32_t bpp = 0;
178 switch (format) {
179 case HAL_PIXEL_FORMAT_RGBA_FP16:
180 bpp = 8;
181 break;
182 case HAL_PIXEL_FORMAT_RGBA_8888:
183 case HAL_PIXEL_FORMAT_RGBX_8888:
184 case HAL_PIXEL_FORMAT_BGRA_8888:
185 case HAL_PIXEL_FORMAT_BGRX_8888:
186 case HAL_PIXEL_FORMAT_RGBA_1010102:
187 case HAL_PIXEL_FORMAT_ARGB_2101010:
188 case HAL_PIXEL_FORMAT_RGBX_1010102:
189 case HAL_PIXEL_FORMAT_XRGB_2101010:
190 case HAL_PIXEL_FORMAT_BGRA_1010102:
191 case HAL_PIXEL_FORMAT_ABGR_2101010:
192 case HAL_PIXEL_FORMAT_BGRX_1010102:
193 case HAL_PIXEL_FORMAT_XBGR_2101010:
194 bpp = 4;
195 break;
196 case HAL_PIXEL_FORMAT_RGB_888:
197 case HAL_PIXEL_FORMAT_BGR_888:
198 bpp = 3;
199 break;
200 case HAL_PIXEL_FORMAT_RGB_565:
201 case HAL_PIXEL_FORMAT_BGR_565:
202 case HAL_PIXEL_FORMAT_RGBA_5551:
203 case HAL_PIXEL_FORMAT_RGBA_4444:
204 case HAL_PIXEL_FORMAT_RG_88:
205 bpp = 2;
206 break;
207 case HAL_PIXEL_FORMAT_R_8:
208 bpp = 1;
209 break;
210 default:
211 ALOGE("Error : %s New format request = 0x%x", __FUNCTION__, format);
212 break;
213 }
214
215 return bpp;
216 }
217
CpuCanAccess(uint64_t usage)218 bool CpuCanAccess(uint64_t usage) {
219 return CpuCanRead(usage) || CpuCanWrite(usage);
220 }
221
CpuCanRead(uint64_t usage)222 bool CpuCanRead(uint64_t usage) {
223 if (usage & BufferUsage::CPU_READ_MASK) {
224 return true;
225 }
226
227 return false;
228 }
229
CpuCanWrite(uint64_t usage)230 bool CpuCanWrite(uint64_t usage) {
231 if (usage & BufferUsage::CPU_WRITE_MASK) {
232 // Application intends to use CPU for rendering
233 return true;
234 }
235
236 return false;
237 }
238
GetDataAlignment(int format,uint64_t usage)239 uint32_t GetDataAlignment(int format, uint64_t usage) {
240 uint32_t align = UINT(getpagesize());
241 if (format == HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED) {
242 align = SIZE_8K;
243 }
244
245 if (usage & BufferUsage::PROTECTED) {
246 if ((usage & BufferUsage::CAMERA_OUTPUT) || (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY)) {
247 // The alignment here reflects qsee mmu V7L/V8L requirement
248 align = SZ_2M;
249 } else {
250 align = SECURE_ALIGN;
251 }
252 }
253
254 return align;
255 }
256
IsGPUFlagSupported(uint64_t usage)257 bool IsGPUFlagSupported(uint64_t usage) {
258 bool ret = true;
259 if ((usage & BufferUsage::GPU_MIPMAP_COMPLETE)) {
260 ALOGE("GPU_MIPMAP_COMPLETE not supported");
261 ret = false;
262 }
263
264 if ((usage & BufferUsage::GPU_CUBE_MAP)) {
265 ALOGE("GPU_CUBE_MAP not supported");
266 ret = false;
267 }
268
269 return ret;
270 }
271
GetBpp(int format)272 int GetBpp(int format) {
273 if (IsUncompressedRGBFormat(format)) {
274 return GetBppForUncompressedRGB(format);
275 }
276 switch (format) {
277 case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_4x4_KHR:
278 case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
279 case HAL_PIXEL_FORMAT_RAW8:
280 case HAL_PIXEL_FORMAT_Y8:
281 return 1;
282 case HAL_PIXEL_FORMAT_RAW16:
283 case HAL_PIXEL_FORMAT_Y16:
284 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
285 case HAL_PIXEL_FORMAT_YCrCb_422_SP:
286 case HAL_PIXEL_FORMAT_YCbCr_422_I:
287 case HAL_PIXEL_FORMAT_YCrCb_422_I:
288 case HAL_PIXEL_FORMAT_CbYCrY_422_I:
289 return 2;
290 case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
291 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
292 return 3;
293 default:
294 return -1;
295 }
296 }
297
298 // Returns the final buffer size meant to be allocated with ion
GetSize(const BufferInfo & info,unsigned int alignedw,unsigned int alignedh)299 unsigned int GetSize(const BufferInfo &info, unsigned int alignedw, unsigned int alignedh) {
300 unsigned int size = 0;
301 int format = info.format;
302 int width = info.width;
303 int height = info.height;
304 uint64_t usage = info.usage;
305
306 if (!IsGPUFlagSupported(usage)) {
307 ALOGE("Unsupported GPU usage flags present 0x%" PRIx64, usage);
308 return 0;
309 }
310
311 if (IsCameraCustomFormat(format) && CameraInfo::GetInstance()) {
312 int result = CameraInfo::GetInstance()->GetBufferSize(format, width, height, &size);
313 if (result != 0) {
314 ALOGE("%s: Failed to get the buffer size through camera library. Error code: %d",
315 __FUNCTION__, result);
316 return 0;
317 }
318 } else if (IsUBwcEnabled(format, usage)) {
319 size = GetUBwcSize(width, height, format, alignedw, alignedh);
320 } else if (IsUncompressedRGBFormat(format)) {
321 uint32_t bpp = GetBppForUncompressedRGB(format);
322 size = alignedw * alignedh * bpp;
323 } else if (IsCompressedRGBFormat(format)) {
324 size = alignedw * alignedh * ASTC_BLOCK_SIZE;
325 } else {
326 // Below switch should be for only YUV/custom formats
327 switch (format) {
328 case HAL_PIXEL_FORMAT_RAW16:
329 case HAL_PIXEL_FORMAT_Y16:size = alignedw * alignedh * 2;
330 break;
331 case HAL_PIXEL_FORMAT_RAW10:
332 case HAL_PIXEL_FORMAT_RAW12:size = ALIGN(alignedw * alignedh, SIZE_4K);
333 break;
334 case HAL_PIXEL_FORMAT_RAW8:
335 case HAL_PIXEL_FORMAT_Y8:size = alignedw * alignedh * 1;
336 break;
337 // adreno formats
338 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO: // NV21
339 size = ALIGN(alignedw * alignedh, SIZE_4K);
340 size += (unsigned int) ALIGN(2 * ALIGN(width / 2, 32) * ALIGN(height / 2, 32), SIZE_4K);
341 break;
342 case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED: // NV12
343 // The chroma plane is subsampled,
344 // but the pitch in bytes is unchanged
345 // The GPU needs 4K alignment, but the video decoder needs 8K
346 size = ALIGN(alignedw * alignedh, SIZE_8K);
347 size += ALIGN(alignedw * (unsigned int) ALIGN(height / 2, 32), SIZE_8K);
348 break;
349 case HAL_PIXEL_FORMAT_YV12:
350 if ((format == HAL_PIXEL_FORMAT_YV12) && ((width & 1) || (height & 1))) {
351 ALOGE("w or h is odd for the YV12 format");
352 return 0;
353 }
354 size = alignedw * alignedh + (ALIGN(alignedw / 2, 16) * (alignedh / 2)) * 2;
355 size = ALIGN(size, (unsigned int) SIZE_4K);
356 break;
357 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
358 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
359 size = ALIGN((alignedw * alignedh) + (alignedw * alignedh) / 2 + 1, SIZE_4K);
360 break;
361 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
362 size = ALIGN((alignedw * alignedh * 2) + (alignedw * alignedh) + 1, SIZE_4K);
363 break;
364 #ifndef QMAA
365 case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
366 size = VENUS_BUFFER_SIZE(COLOR_FMT_P010,
367 width,
368 height);
369 break;
370 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
371 case HAL_PIXEL_FORMAT_YCrCb_422_SP:
372 case HAL_PIXEL_FORMAT_YCbCr_422_I:
373 case HAL_PIXEL_FORMAT_YCrCb_422_I:
374 case HAL_PIXEL_FORMAT_CbYCrY_422_I:
375 if (width & 1) {
376 ALOGE("width is odd for the YUV422_SP format");
377 return 0;
378 }
379 size = ALIGN(alignedw * alignedh * 2, SIZE_4K);
380 break;
381 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
382 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
383 size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height);
384 break;
385 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
386 case HAL_PIXEL_FORMAT_NV21_ENCODEABLE:
387 size = VENUS_BUFFER_SIZE(COLOR_FMT_NV21, width, height);
388 break;
389 case HAL_PIXEL_FORMAT_BLOB:
390 if (height != 1) {
391 ALOGE("%s: Buffers with HAL_PIXEL_FORMAT_BLOB must have height 1 ", __FUNCTION__);
392 return 0;
393 }
394 size = (unsigned int) width;
395 break;
396 case HAL_PIXEL_FORMAT_NV12_HEIF:
397 size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12_512, width, height);
398 break;
399 #endif
400 default:ALOGE("%s: Unrecognized pixel format: 0x%x", __FUNCTION__, format);
401 return 0;
402 }
403 }
404 auto align = GetDataAlignment(format, usage);
405 size = ALIGN(size, align) * info.layer_count;
406 return size;
407 }
408
GetBufferSizeAndDimensions(const BufferInfo & info,unsigned int * size,unsigned int * alignedw,unsigned int * alignedh)409 int GetBufferSizeAndDimensions(const BufferInfo &info, unsigned int *size, unsigned int *alignedw,
410 unsigned int *alignedh) {
411 GraphicsMetadata graphics_metadata = {};
412 return GetBufferSizeAndDimensions(info, size, alignedw, alignedh, &graphics_metadata);
413 }
414
GetBufferSizeAndDimensions(const BufferInfo & info,unsigned int * size,unsigned int * alignedw,unsigned int * alignedh,GraphicsMetadata * graphics_metadata)415 int GetBufferSizeAndDimensions(const BufferInfo &info, unsigned int *size, unsigned int *alignedw,
416 unsigned int *alignedh, GraphicsMetadata *graphics_metadata) {
417 int buffer_type = GetBufferType(info.format);
418 if (CanUseAdrenoForSize(buffer_type, info.usage)) {
419 return GetGpuResourceSizeAndDimensions(info, size, alignedw, alignedh, graphics_metadata);
420 } else {
421 GetAlignedWidthAndHeight(info, alignedw, alignedh);
422 *size = GetSize(info, *alignedw, *alignedh);
423 }
424 return 0;
425 }
426
GetYuvUbwcSPPlaneInfo(uint32_t width,uint32_t height,int color_format,PlaneLayoutInfo * plane_info)427 void GetYuvUbwcSPPlaneInfo(uint32_t width, uint32_t height, int color_format,
428 PlaneLayoutInfo *plane_info) {
429 // UBWC buffer has these 4 planes in the following sequence:
430 // Y_Plane, UV_Plane, Y_Meta_Plane, UV_Meta_Plane
431 unsigned int y_meta_stride = 0, y_meta_height = 0, y_meta_size = 0;
432 unsigned int y_stride = 0, y_height = 0, y_size = 0;
433 unsigned int c_meta_stride = 0, c_meta_height = 0, c_meta_size = 0;
434 unsigned int alignment = 4096;
435 unsigned int c_stride = 0, c_height = 0, c_size = 0;
436 uint64_t yOffset = 0, cOffset = 0, yMetaOffset = 0, cMetaOffset = 0;
437
438 #ifndef QMAA
439 y_meta_stride = VENUS_Y_META_STRIDE(color_format, INT(width));
440 y_meta_height = VENUS_Y_META_SCANLINES(color_format, INT(height));
441 y_meta_size = ALIGN((y_meta_stride * y_meta_height), alignment);
442
443 y_stride = VENUS_Y_STRIDE(color_format, INT(width));
444 y_height = VENUS_Y_SCANLINES(color_format, INT(height));
445 y_size = ALIGN((y_stride * y_height), alignment);
446
447 c_meta_stride = VENUS_UV_META_STRIDE(color_format, INT(width));
448 c_meta_height = VENUS_UV_META_SCANLINES(color_format, INT(height));
449 c_meta_size = ALIGN((c_meta_stride * c_meta_height), alignment);
450
451 c_stride = VENUS_UV_STRIDE(color_format, INT(width));
452 c_height = VENUS_UV_SCANLINES(color_format, INT(height));
453 c_size = ALIGN((c_stride * c_height), alignment);
454 #endif
455 yMetaOffset = 0;
456 yOffset = y_meta_size;
457 cMetaOffset = y_meta_size + y_size;
458 cOffset = y_meta_size + y_size + c_meta_size;
459
460 plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_Y;
461 plane_info[0].offset = (uint32_t)yOffset;
462 plane_info[0].stride = static_cast<int32_t>(UINT(width));
463 plane_info[0].stride_bytes = static_cast<int32_t>(y_stride);
464 plane_info[0].scanlines = static_cast<int32_t>(y_height);
465 plane_info[0].size = static_cast<uint32_t>(y_size);
466
467 plane_info[1].component = (PlaneComponent)(PLANE_COMPONENT_Cb | PLANE_COMPONENT_Cr);
468 plane_info[1].offset = (uint32_t)cOffset;
469 plane_info[1].stride = static_cast<int32_t>(UINT(width));
470 plane_info[1].stride_bytes = static_cast<int32_t>(c_stride);
471 plane_info[1].scanlines = static_cast<int32_t>(c_height);
472 plane_info[1].size = static_cast<uint32_t>(c_size);
473
474 plane_info[2].component = (PlaneComponent)(PLANE_COMPONENT_META | PLANE_COMPONENT_Y);
475 plane_info[2].offset = (uint32_t)yMetaOffset;
476 plane_info[2].stride = static_cast<int32_t>(UINT(width));
477 plane_info[2].stride_bytes = static_cast<int32_t>(y_meta_stride);
478 plane_info[2].scanlines = static_cast<int32_t>(y_meta_height);
479 plane_info[2].size = static_cast<uint32_t>(y_meta_size);
480
481 plane_info[3].component =
482 (PlaneComponent)(PLANE_COMPONENT_META | PLANE_COMPONENT_Cb | PLANE_COMPONENT_Cr);
483 plane_info[3].offset = (uint32_t)cMetaOffset;
484 plane_info[3].stride = static_cast<int32_t>(UINT(width));
485 plane_info[3].stride_bytes = static_cast<int32_t>(c_meta_stride);
486 plane_info[3].scanlines = static_cast<int32_t>(c_meta_height);
487 plane_info[3].size = static_cast<uint32_t>(c_meta_size);
488 }
489
490 // This API gets information about 8 planes (Y_Plane, UV_Plane, Y_Meta_Plane, UV_Meta_Plane,
491 // Y_Plane, UV_Plane, Y_Meta_Plane, UV_Meta_Plane) and it stores the
492 // information in PlaneLayoutInfo array.
GetYuvUbwcInterlacedSPPlaneInfo(uint32_t width,uint32_t height,PlaneLayoutInfo plane_info[8])493 void GetYuvUbwcInterlacedSPPlaneInfo(uint32_t width, uint32_t height,
494 PlaneLayoutInfo plane_info[8]) {
495 // UBWC interlaced has top-bottom field layout with each field as
496 // 8-plane (including meta plane also) NV12_UBWC with width = image_width
497 // & height = image_height / 2.
498 // Client passed plane_info argument is ptr to struct PlaneLayoutInfo[8].
499 // Plane info to be filled for each field separately.
500 height = (height + 1) >> 1;
501
502 #ifndef QMAA
503 GetYuvUbwcSPPlaneInfo(width, height, COLOR_FMT_NV12_UBWC, &plane_info[0]);
504
505 GetYuvUbwcSPPlaneInfo(width, height, COLOR_FMT_NV12_UBWC, &plane_info[4]);
506 #endif
507 }
508
509 // This API gets information about 2 planes (Y_Plane & UV_Plane).
510 // Here width and height are aligned width and aligned height.
511 // bpp: bits per pixel.
GetYuvSPPlaneInfo(const BufferInfo & info,int format,uint32_t width,uint32_t height,uint32_t bpp,PlaneLayoutInfo * plane_info)512 void GetYuvSPPlaneInfo(const BufferInfo &info, int format, uint32_t width, uint32_t height,
513 uint32_t bpp, PlaneLayoutInfo *plane_info) {
514 int unaligned_width = info.width;
515 int unaligned_height = info.height;
516 unsigned int y_stride = 0, y_height = 0, y_size = 0;
517 unsigned int c_stride = 0, c_height = 0, c_size = 0;
518 uint64_t yOffset, cOffset;
519
520 y_stride = c_stride = UINT(width) * bpp;
521 y_height = INT(height);
522 y_size = y_stride * y_height;
523 switch (format) {
524 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
525 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
526 c_size = (width * height) / 2 + 1;
527 c_height = height >> 1;
528 break;
529 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
530 case HAL_PIXEL_FORMAT_YCrCb_422_SP:
531 if (unaligned_width & 1) {
532 ALOGE("width is odd for the YUV422_SP format");
533 return;
534 }
535 c_size = width * height;
536 c_height = height;
537 break;
538 #ifndef QMAA
539 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
540 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
541 c_height = VENUS_UV_SCANLINES(COLOR_FMT_NV12, height);
542 c_size = c_stride * c_height;
543 break;
544 case HAL_PIXEL_FORMAT_NV12_HEIF:
545 c_height = VENUS_UV_SCANLINES(COLOR_FMT_NV12_512, height);
546 c_size = c_stride * c_height;
547 break;
548 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
549 y_size = ALIGN(width * height, 4096);
550 c_size = ALIGN(2 * ALIGN(unaligned_width / 2, 32) * ALIGN(unaligned_height / 2, 32), 4096);
551 break;
552 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
553 case HAL_PIXEL_FORMAT_NV21_ENCODEABLE:
554 c_height = VENUS_UV_SCANLINES(COLOR_FMT_NV21, height);
555 c_size = c_stride * c_height;
556 break;
557 #endif
558 case HAL_PIXEL_FORMAT_Y16:
559 c_size = c_stride = 0;
560 c_height = 0;
561 break;
562 case HAL_PIXEL_FORMAT_Y8:
563 c_size = c_stride = 0;
564 c_height = 0;
565 break;
566 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
567 c_size = (width * height) + 1;
568 c_height = height;
569 break;
570 default:
571 break;
572 }
573
574 yOffset = 0;
575 cOffset = y_size;
576
577 plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_Y;
578 plane_info[0].offset = (uint32_t)yOffset;
579 plane_info[0].step = 1;
580 plane_info[0].stride = static_cast<int32_t>(UINT(width));
581 plane_info[0].stride_bytes = static_cast<int32_t>(y_stride);
582 plane_info[0].scanlines = static_cast<int32_t>(y_height);
583 plane_info[0].size = static_cast<uint32_t>(y_size);
584
585 plane_info[1].component = (PlaneComponent)(PLANE_COMPONENT_Cb | PLANE_COMPONENT_Cr);
586 plane_info[1].offset = (uint32_t)cOffset;
587 plane_info[1].step = 2 * bpp;
588 plane_info[1].stride = static_cast<int32_t>(UINT(width));
589 plane_info[1].stride_bytes = static_cast<int32_t>(c_stride);
590 plane_info[1].scanlines = static_cast<int32_t>(c_height);
591 plane_info[1].size = static_cast<uint32_t>(c_size);
592 }
593
GetYUVPlaneInfo(const private_handle_t * hnd,struct android_ycbcr ycbcr[2])594 int GetYUVPlaneInfo(const private_handle_t *hnd, struct android_ycbcr ycbcr[2]) {
595 int err = 0;
596 uint32_t width = UINT(hnd->width);
597 uint32_t height = UINT(hnd->height);
598 int format = hnd->format;
599 uint64_t usage = hnd->usage;
600 int32_t interlaced = 0;
601 int plane_count = 0;
602 int unaligned_width = INT(hnd->unaligned_width);
603 int unaligned_height = INT(hnd->unaligned_height);
604 BufferInfo info(unaligned_width, unaligned_height, format, usage);
605
606 memset(ycbcr->reserved, 0, sizeof(ycbcr->reserved));
607
608 // Check if UBWC buffer has been rendered in linear format.
609 int linear_format = 0;
610 if (getMetaData(const_cast<private_handle_t *>(hnd), GET_LINEAR_FORMAT, &linear_format) == 0) {
611 format = INT(linear_format);
612 }
613
614 // Check metadata if the geometry has been updated.
615 BufferDim_t buffer_dim;
616 if (getMetaData(const_cast<private_handle_t *>(hnd), GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
617 BufferInfo info(buffer_dim.sliceWidth, buffer_dim.sliceHeight, format, usage);
618 GetAlignedWidthAndHeight(info, &width, &height);
619 }
620
621 // Check metadata for interlaced content.
622 int interlace_flag = 0;
623 if (getMetaData(const_cast<private_handle_t *>(hnd), GET_PP_PARAM_INTERLACED, &interlace_flag) ==
624 0) {
625 if (interlace_flag) {
626 interlaced = LAYOUT_INTERLACED_FLAG;
627 }
628 }
629
630 PlaneLayoutInfo plane_info[8] = {};
631 // Get the chroma offsets from the handle width/height. We take advantage
632 // of the fact the width _is_ the stride
633 err = GetYUVPlaneInfo(info, format, width, height, interlaced, &plane_count, plane_info);
634 if (err == 0) {
635 if (interlaced && format == HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC) {
636 CopyPlaneLayoutInfotoAndroidYcbcr(hnd->base, plane_count, &plane_info[0], &ycbcr[0]);
637 unsigned int uv_stride = 0, uv_height = 0, uv_size = 0;
638 unsigned int alignment = 4096;
639 uint64_t field_base;
640 height = (height + 1) >> 1;
641 #ifndef QMAA
642 uv_stride = VENUS_UV_STRIDE(COLOR_FMT_NV12_UBWC, INT(width));
643 uv_height = VENUS_UV_SCANLINES(COLOR_FMT_NV12_UBWC, INT(height));
644 #endif
645 uv_size = ALIGN((uv_stride * uv_height), alignment);
646 field_base = hnd->base + plane_info[1].offset + uv_size;
647 memset(ycbcr[1].reserved, 0, sizeof(ycbcr[1].reserved));
648 CopyPlaneLayoutInfotoAndroidYcbcr(field_base, plane_count, &plane_info[4], &ycbcr[1]);
649 } else {
650 CopyPlaneLayoutInfotoAndroidYcbcr(hnd->base, plane_count, plane_info, ycbcr);
651 switch (format) {
652 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
653 case HAL_PIXEL_FORMAT_YCrCb_422_SP:
654 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
655 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
656 case HAL_PIXEL_FORMAT_NV21_ZSL:
657 std::swap(ycbcr->cb, ycbcr->cr);
658 }
659 }
660 }
661 return err;
662 }
663
GetRawPlaneInfo(int32_t format,int32_t width,int32_t height,PlaneLayoutInfo * plane_info)664 int GetRawPlaneInfo(int32_t format, int32_t width, int32_t height, PlaneLayoutInfo *plane_info) {
665 int32_t step = 0;
666
667 switch (format) {
668 case HAL_PIXEL_FORMAT_RAW16:
669 step = 2;
670 break;
671 case HAL_PIXEL_FORMAT_RAW8:
672 step = 1;
673 break;
674 case HAL_PIXEL_FORMAT_RAW12:
675 case HAL_PIXEL_FORMAT_RAW10:
676 case HAL_PIXEL_FORMAT_BLOB:
677 step = 0;
678 break;
679 default:
680 ALOGW("RawPlaneInfo is unsupported for format 0x%x", format);
681 return -EINVAL;
682 }
683
684 BufferInfo info(width, height, format);
685 uint32_t alignedWidth, alignedHeight;
686 GetAlignedWidthAndHeight(info, &alignedWidth, &alignedHeight);
687
688 uint32_t size = GetSize(info, alignedWidth, alignedHeight);
689
690 plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_RAW;
691 plane_info[0].h_subsampling = 0;
692 plane_info[0].v_subsampling = 0;
693 plane_info[0].offset = 0;
694 plane_info[0].step = step;
695 plane_info[0].stride = width;
696 plane_info[0].stride_bytes = static_cast<int32_t>(alignedWidth);
697 if (format == HAL_PIXEL_FORMAT_RAW16) {
698 plane_info[0].stride_bytes = static_cast<int32_t>(alignedWidth * GetBpp(format));
699 }
700 plane_info[0].scanlines = height;
701 plane_info[0].size = size;
702
703 return 0;
704 }
705
706 // Explicitly defined UBWC formats
IsUBwcFormat(int format)707 bool IsUBwcFormat(int format) {
708 switch (format) {
709 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
710 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
711 case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
712 return true;
713 default:
714 return false;
715 }
716 }
717
IsUBwcSupported(int format)718 bool IsUBwcSupported(int format) {
719 // Existing HAL formats with UBWC support
720 switch (format) {
721 case HAL_PIXEL_FORMAT_BGR_565:
722 case HAL_PIXEL_FORMAT_RGBA_8888:
723 case HAL_PIXEL_FORMAT_RGBX_8888:
724 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
725 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
726 case HAL_PIXEL_FORMAT_RGBA_1010102:
727 case HAL_PIXEL_FORMAT_RGBX_1010102:
728 case HAL_PIXEL_FORMAT_DEPTH_16:
729 case HAL_PIXEL_FORMAT_DEPTH_24:
730 case HAL_PIXEL_FORMAT_DEPTH_24_STENCIL_8:
731 case HAL_PIXEL_FORMAT_DEPTH_32F:
732 case HAL_PIXEL_FORMAT_STENCIL_8:
733 case HAL_PIXEL_FORMAT_RGBA_FP16:
734 return true;
735 default:
736 break;
737 }
738
739 return false;
740 }
741
IsUBwcPISupported(int format,uint64_t usage)742 bool IsUBwcPISupported(int format, uint64_t usage) {
743 // TODO(user): try and differentiate b/w mdp capability to support PI.
744 if (!(usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC_PI)) {
745 return false;
746 }
747
748 // As of now only two formats
749 switch (format) {
750 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
751 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC: {
752 if ((usage & BufferUsage::GPU_TEXTURE) || (usage & BufferUsage::GPU_RENDER_TARGET)) {
753 if (AdrenoMemInfo::GetInstance()) {
754 return AdrenoMemInfo::GetInstance()->IsPISupportedByGPU(format, usage);
755 }
756 } else {
757 return true;
758 }
759 }
760 }
761
762 return false;
763 }
764
IsUBwcEnabled(int format,uint64_t usage)765 bool IsUBwcEnabled(int format, uint64_t usage) {
766 // Allow UBWC, if client is using an explicitly defined UBWC pixel format.
767 if (IsUBwcFormat(format)) {
768 return true;
769 }
770
771 // Allow UBWC, if an OpenGL client sets UBWC usage flag and GPU plus MDP
772 // support the format. OR if a non-OpenGL client like Rotator, sets UBWC
773 // usage flag and MDP supports the format.
774 if (((usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) ||
775 (usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC_PI) ||
776 (usage & BufferUsage::COMPOSER_CLIENT_TARGET))
777 && IsUBwcSupported(format)) {
778 bool enable = true;
779 // Query GPU for UBWC only if buffer is intended to be used by GPU.
780 if ((usage & BufferUsage::GPU_TEXTURE) || (usage & BufferUsage::GPU_RENDER_TARGET)) {
781 if (AdrenoMemInfo::GetInstance()) {
782 enable = AdrenoMemInfo::GetInstance()->IsUBWCSupportedByGPU(format);
783 }
784 }
785
786 // Allow UBWC, only if CPU usage flags are not set
787 if (enable && !(CpuCanAccess(usage))) {
788 return true;
789 }
790 }
791
792 return false;
793 }
794
GetYuvUBwcWidthAndHeight(int width,int height,int format,unsigned int * aligned_w,unsigned int * aligned_h)795 void GetYuvUBwcWidthAndHeight(int width, int height, int format, unsigned int *aligned_w,
796 unsigned int *aligned_h) {
797 switch (format) {
798 #ifndef QMAA
799 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
800 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
801 *aligned_w = VENUS_Y_STRIDE(COLOR_FMT_NV12, width);
802 *aligned_h = VENUS_Y_SCANLINES(COLOR_FMT_NV12, height);
803 break;
804 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
805 *aligned_w = VENUS_Y_STRIDE(COLOR_FMT_NV12_UBWC, width);
806 *aligned_h = VENUS_Y_SCANLINES(COLOR_FMT_NV12_UBWC, height);
807 break;
808 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
809 // The macro returns the stride which is 4/3 times the width, hence * 3/4
810 *aligned_w = (VENUS_Y_STRIDE(COLOR_FMT_NV12_BPP10_UBWC, width) * 3) / 4;
811 *aligned_h = VENUS_Y_SCANLINES(COLOR_FMT_NV12_BPP10_UBWC, height);
812 break;
813 case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
814 // The macro returns the stride which is 2 times the width, hence / 2
815 *aligned_w = (VENUS_Y_STRIDE(COLOR_FMT_P010_UBWC, width) / 2);
816 *aligned_h = VENUS_Y_SCANLINES(COLOR_FMT_P010_UBWC, height);
817 break;
818 #endif
819 default:
820 ALOGE("%s: Unsupported pixel format: 0x%x", __FUNCTION__, format);
821 *aligned_w = 0;
822 *aligned_h = 0;
823 break;
824 }
825 }
826
GetRgbUBwcBlockSize(uint32_t bpp,int * block_width,int * block_height)827 void GetRgbUBwcBlockSize(uint32_t bpp, int *block_width, int *block_height) {
828 *block_width = 0;
829 *block_height = 0;
830
831 switch (bpp) {
832 case 2:
833 case 4:
834 *block_width = 16;
835 *block_height = 4;
836 break;
837 case 8:
838 *block_width = 8;
839 *block_height = 4;
840 break;
841 case 16:
842 *block_width = 4;
843 *block_height = 4;
844 break;
845 default:
846 ALOGE("%s: Unsupported bpp: %d", __FUNCTION__, bpp);
847 break;
848 }
849 }
850
GetRgbUBwcMetaBufferSize(int width,int height,uint32_t bpp)851 unsigned int GetRgbUBwcMetaBufferSize(int width, int height, uint32_t bpp) {
852 unsigned int size = 0;
853 int meta_width, meta_height;
854 int block_width, block_height;
855
856 GetRgbUBwcBlockSize(bpp, &block_width, &block_height);
857 if (!block_width || !block_height) {
858 ALOGE("%s: Unsupported bpp: %d", __FUNCTION__, bpp);
859 return size;
860 }
861
862 // Align meta buffer height to 16 blocks
863 meta_height = ALIGN(((height + block_height - 1) / block_height), 16);
864
865 // Align meta buffer width to 64 blocks
866 meta_width = ALIGN(((width + block_width - 1) / block_width), 64);
867
868 // Align meta buffer size to 4K
869 size = (unsigned int)ALIGN((meta_width * meta_height), 4096);
870
871 return size;
872 }
873
GetUBwcSize(int width,int height,int format,unsigned int alignedw,unsigned int alignedh)874 unsigned int GetUBwcSize(int width, int height, int format, unsigned int alignedw,
875 unsigned int alignedh) {
876 unsigned int size = 0;
877 uint32_t bpp = 0;
878 switch (format) {
879 case HAL_PIXEL_FORMAT_BGR_565:
880 case HAL_PIXEL_FORMAT_RGBA_8888:
881 case HAL_PIXEL_FORMAT_RGBX_8888:
882 case HAL_PIXEL_FORMAT_RGBA_1010102:
883 case HAL_PIXEL_FORMAT_RGBX_1010102:
884 case HAL_PIXEL_FORMAT_RGBA_FP16:
885 bpp = GetBppForUncompressedRGB(format);
886 size = alignedw * alignedh * bpp;
887 size += GetRgbUBwcMetaBufferSize(width, height, bpp);
888 break;
889 #ifndef QMAA
890 /*
891 * 1. The CtsMediaV2TestCases#CodecEncoderSurfaceTest is a transcode use case and shares
892 * same surface between encoder and decoder.
893 * 2. Configures encoder with Opaque color format thus encoder sets ubwc usage bits and
894 * is configured with NV12_UBWC format.
895 * 3. Configures decoder as 'flexible', thus configuring decoder with NV12 format.
896 * 4. Decoder should produce output to surface that will be fed back to encoder as input.
897 * 5. Though UBWC is enabled, we need to compute the actual buffer size (including aligned
898 * width and height) based on pixel format that is set.
899 */
900 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
901 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
902 size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height);
903 break;
904 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
905 size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12_UBWC, width, height);
906 break;
907 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
908 size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12_BPP10_UBWC, width, height);
909 break;
910 case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
911 size = VENUS_BUFFER_SIZE(COLOR_FMT_P010_UBWC, width, height);
912 break;
913 #endif
914 default:
915 ALOGE("%s: Unsupported pixel format: 0x%x", __FUNCTION__, format);
916 break;
917 }
918
919 return size;
920 }
921
GetRgbMetaSize(int format,uint32_t width,uint32_t height,uint64_t usage)922 unsigned int GetRgbMetaSize(int format, uint32_t width, uint32_t height, uint64_t usage) {
923 unsigned int meta_size = 0;
924 if (!IsUBwcEnabled(format, usage)) {
925 return meta_size;
926 }
927 uint32_t bpp = GetBppForUncompressedRGB(format);
928 switch (format) {
929 case HAL_PIXEL_FORMAT_BGR_565:
930 case HAL_PIXEL_FORMAT_RGBA_8888:
931 case HAL_PIXEL_FORMAT_RGBX_8888:
932 case HAL_PIXEL_FORMAT_RGBA_1010102:
933 case HAL_PIXEL_FORMAT_RGBX_1010102:
934 case HAL_PIXEL_FORMAT_RGBA_FP16:
935 meta_size = GetRgbUBwcMetaBufferSize(width, height, bpp);
936 break;
937 default:
938 ALOGE("%s:Unsupported RGB format: 0x%x", __FUNCTION__, format);
939 break;
940 }
941 return meta_size;
942 }
943
GetRgbDataAddress(private_handle_t * hnd,void ** rgb_data)944 int GetRgbDataAddress(private_handle_t *hnd, void **rgb_data) {
945 int err = 0;
946
947 // This api is for RGB* formats
948 if (!IsUncompressedRGBFormat(hnd->format)) {
949 return -EINVAL;
950 }
951
952 // linear buffer, nothing to do further
953 if (!(hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED)) {
954 *rgb_data = reinterpret_cast<void *>(hnd->base);
955 return err;
956 }
957 unsigned int meta_size = GetRgbMetaSize(hnd->format, hnd->width, hnd->height, hnd->usage);
958
959 *rgb_data = reinterpret_cast<void *>(hnd->base + meta_size);
960
961 return err;
962 }
963
GetCustomDimensions(private_handle_t * hnd,int * stride,int * height)964 void GetCustomDimensions(private_handle_t *hnd, int *stride, int *height) {
965 BufferDim_t buffer_dim;
966 int interlaced = 0;
967
968 *stride = hnd->width;
969 *height = hnd->height;
970 if (getMetaData(hnd, GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
971 *stride = buffer_dim.sliceWidth;
972 *height = buffer_dim.sliceHeight;
973 } else if (getMetaData(hnd, GET_PP_PARAM_INTERLACED, &interlaced) == 0) {
974 if (interlaced && IsUBwcFormat(hnd->format)) {
975 unsigned int alignedw = 0, alignedh = 0;
976 // Get re-aligned height for single ubwc interlaced field and
977 // multiply by 2 to get frame height.
978 BufferInfo info(hnd->width, ((hnd->height + 1) >> 1), hnd->format);
979 GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
980 *stride = static_cast<int>(alignedw);
981 *height = static_cast<int>(alignedh * 2);
982 }
983 }
984 }
985
GetColorSpaceFromMetadata(private_handle_t * hnd,int * color_space)986 void GetColorSpaceFromMetadata(private_handle_t *hnd, int *color_space) {
987 ColorMetaData color_metadata;
988 if (getMetaData(hnd, GET_COLOR_METADATA, &color_metadata) == 0) {
989 switch (color_metadata.colorPrimaries) {
990 case ColorPrimaries_BT709_5:
991 *color_space = HAL_CSC_ITU_R_709;
992 break;
993 case ColorPrimaries_BT601_6_525:
994 case ColorPrimaries_BT601_6_625:
995 *color_space = ((color_metadata.range) ? HAL_CSC_ITU_R_601_FR : HAL_CSC_ITU_R_601);
996 break;
997 case ColorPrimaries_BT2020:
998 *color_space = (color_metadata.range) ? HAL_CSC_ITU_R_2020_FR : HAL_CSC_ITU_R_2020;
999 break;
1000 default:
1001 ALOGW("Unknown Color primary = %d", color_metadata.colorPrimaries);
1002 break;
1003 }
1004 } else if (getMetaData(hnd, GET_COLOR_SPACE, color_space) != 0) {
1005 *color_space = 0;
1006 }
1007 }
1008
GetAlignedWidthAndHeight(const BufferInfo & info,unsigned int * alignedw,unsigned int * alignedh)1009 void GetAlignedWidthAndHeight(const BufferInfo &info, unsigned int *alignedw,
1010 unsigned int *alignedh) {
1011 int width = info.width;
1012 int height = info.height;
1013 int format = info.format;
1014 uint64_t usage = info.usage;
1015
1016 // Currently surface padding is only computed for RGB* surfaces.
1017 bool ubwc_enabled = IsUBwcEnabled(format, usage);
1018 int tile = ubwc_enabled;
1019
1020 // Use of aligned width and aligned height is to calculate the size of buffer,
1021 // but in case of camera custom format size is being calculated from given width
1022 // and given height.
1023 if (IsCameraCustomFormat(format) && CameraInfo::GetInstance()) {
1024 int aligned_w = width;
1025 int aligned_h = height;
1026 int result = CameraInfo::GetInstance()->GetStrideInBytes(
1027 format, (PlaneComponent)PLANE_COMPONENT_Y, width, &aligned_w);
1028 if (result != 0) {
1029 ALOGE(
1030 "%s: Failed to get the aligned width for camera custom format. width: %d, height: %d,"
1031 "format: %d, Error code: %d",
1032 __FUNCTION__, width, height, format, result);
1033 *alignedw = width;
1034 *alignedh = aligned_h;
1035 return;
1036 }
1037
1038 result = CameraInfo::GetInstance()->GetScanline(format, (PlaneComponent)PLANE_COMPONENT_Y,
1039 height, &aligned_h);
1040 if (result != 0) {
1041 ALOGE(
1042 "%s: Failed to get the aligned height for camera custom format. width: %d,"
1043 "height: %d, format: %d, Error code: %d",
1044 __FUNCTION__, width, height, format, result);
1045 *alignedw = aligned_w;
1046 *alignedh = height;
1047 return;
1048 }
1049
1050 *alignedw = aligned_w;
1051 *alignedh = aligned_h;
1052 return;
1053 }
1054
1055 if (IsUncompressedRGBFormat(format)) {
1056 if (AdrenoMemInfo::GetInstance()) {
1057 AdrenoMemInfo::GetInstance()->AlignUnCompressedRGB(width, height, format, tile, alignedw,
1058 alignedh);
1059 }
1060 return;
1061 }
1062
1063 if (ubwc_enabled) {
1064 GetYuvUBwcWidthAndHeight(width, height, format, alignedw, alignedh);
1065 return;
1066 }
1067
1068 if (IsCompressedRGBFormat(format)) {
1069 if (AdrenoMemInfo::GetInstance()) {
1070 AdrenoMemInfo::GetInstance()->AlignCompressedRGB(width, height, format, alignedw, alignedh);
1071 }
1072 return;
1073 }
1074
1075 int aligned_w = width;
1076 int aligned_h = height;
1077 unsigned int alignment = 32;
1078
1079 // Below should be only YUV family
1080 switch (format) {
1081 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1082 /*
1083 * Todo: relook this alignment again
1084 * Change made to unblock the software EIS feature from camera
1085 * Currently using same alignment as camera doing
1086 */
1087 aligned_w = INT(VENUS_Y_STRIDE(COLOR_FMT_NV21, width));
1088 aligned_h = INT(VENUS_Y_SCANLINES(COLOR_FMT_NV21, height));
1089 break;
1090 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
1091 aligned_w = INT(VENUS_Y_STRIDE(COLOR_FMT_NV12, width));
1092 aligned_h = INT(VENUS_Y_SCANLINES(COLOR_FMT_NV12, height));
1093 break;
1094 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
1095 aligned_w = ALIGN(width, alignment);
1096 break;
1097 case HAL_PIXEL_FORMAT_RAW16:
1098 case HAL_PIXEL_FORMAT_Y16:
1099 case HAL_PIXEL_FORMAT_Y8:
1100 aligned_w = ALIGN(width, 16);
1101 break;
1102 case HAL_PIXEL_FORMAT_RAW12:
1103 aligned_w = ALIGN(width * 12 / 8, 16);
1104 break;
1105 case HAL_PIXEL_FORMAT_RAW10:
1106 {
1107 const unsigned int gpu_alignment =
1108 AdrenoMemInfo::GetInstance()->GetGpuPixelAlignment();
1109 // gpu_alignment can return 1. Make sure it's at least 64.
1110 const unsigned int raw10_alignment = std::max(gpu_alignment, 64u);
1111 aligned_w = ALIGN(width * 10 / 8, raw10_alignment);
1112 }
1113 break;
1114 case HAL_PIXEL_FORMAT_RAW8:
1115 aligned_w = ALIGN(width, 16);
1116 break;
1117 case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
1118 aligned_w = ALIGN(width, 128);
1119 break;
1120 case HAL_PIXEL_FORMAT_YV12:
1121 if ((usage & BufferUsage::GPU_TEXTURE) || (usage & BufferUsage::GPU_RENDER_TARGET)) {
1122 if (AdrenoMemInfo::GetInstance() == nullptr) {
1123 return;
1124 }
1125 alignment = AdrenoMemInfo::GetInstance()->GetGpuPixelAlignment();
1126 aligned_w = ALIGN(width, alignment);
1127 } else {
1128 aligned_w = ALIGN(width, 16);
1129 }
1130 break;
1131 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1132 case HAL_PIXEL_FORMAT_YCrCb_422_SP:
1133 case HAL_PIXEL_FORMAT_YCbCr_422_I:
1134 case HAL_PIXEL_FORMAT_YCrCb_422_I:
1135 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
1136 aligned_w = ALIGN(width, 16);
1137 break;
1138 #ifndef QMAA
1139 case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
1140 aligned_w = INT(VENUS_Y_STRIDE(COLOR_FMT_P010, width) / 2);
1141 aligned_h = INT(VENUS_Y_SCANLINES(COLOR_FMT_P010, height));
1142 break;
1143 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
1144 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
1145 aligned_w = INT(VENUS_Y_STRIDE(COLOR_FMT_NV12, width));
1146 aligned_h = INT(VENUS_Y_SCANLINES(COLOR_FMT_NV12, height));
1147 break;
1148 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
1149 case HAL_PIXEL_FORMAT_NV21_ENCODEABLE:
1150 aligned_w = INT(VENUS_Y_STRIDE(COLOR_FMT_NV21, width));
1151 aligned_h = INT(VENUS_Y_SCANLINES(COLOR_FMT_NV21, height));
1152 break;
1153 case HAL_PIXEL_FORMAT_BLOB:
1154 break;
1155 case HAL_PIXEL_FORMAT_NV12_HEIF:
1156 aligned_w = INT(VENUS_Y_STRIDE(COLOR_FMT_NV12_512, width));
1157 aligned_h = INT(VENUS_Y_SCANLINES(COLOR_FMT_NV12_512, height));
1158 break;
1159 #endif
1160 default:
1161 break;
1162 }
1163
1164 *alignedw = (unsigned int)aligned_w;
1165 *alignedh = (unsigned int)aligned_h;
1166 }
1167
GetBufferLayout(private_handle_t * hnd,uint32_t stride[4],uint32_t offset[4],uint32_t * num_planes)1168 int GetBufferLayout(private_handle_t *hnd, uint32_t stride[4], uint32_t offset[4],
1169 uint32_t *num_planes) {
1170 if (!hnd || !stride || !offset || !num_planes) {
1171 return -EINVAL;
1172 }
1173
1174 struct android_ycbcr yuvPlaneInfo[2] = {};
1175 *num_planes = 1;
1176
1177 if (IsUncompressedRGBFormat(hnd->format)) {
1178 uint32_t bpp = GetBppForUncompressedRGB(hnd->format);
1179 stride[0] = static_cast<uint32_t>(hnd->width * bpp);
1180 return 0;
1181 }
1182
1183 (*num_planes)++;
1184 int ret = GetYUVPlaneInfo(hnd, yuvPlaneInfo);
1185 if (ret < 0) {
1186 ALOGE("%s failed", __FUNCTION__);
1187 return ret;
1188 }
1189
1190 // We are only returning buffer layout for progressive or single field formats.
1191 struct android_ycbcr yuvInfo = yuvPlaneInfo[0];
1192 stride[0] = static_cast<uint32_t>(yuvInfo.ystride);
1193 offset[0] = static_cast<uint32_t>(reinterpret_cast<uint64_t>(yuvInfo.y) - hnd->base);
1194 stride[1] = static_cast<uint32_t>(yuvInfo.cstride);
1195 switch (hnd->format) {
1196 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
1197 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1198 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
1199 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
1200 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
1201 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
1202 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
1203 case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
1204 case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
1205 case HAL_PIXEL_FORMAT_NV12_HEIF:
1206 offset[1] = static_cast<uint32_t>(reinterpret_cast<uint64_t>(yuvInfo.cb) - hnd->base);
1207 break;
1208 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1209 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
1210 case HAL_PIXEL_FORMAT_YCrCb_422_SP:
1211 case HAL_PIXEL_FORMAT_NV21_ENCODEABLE:
1212 offset[1] = static_cast<uint32_t>(reinterpret_cast<uint64_t>(yuvInfo.cr) - hnd->base);
1213 break;
1214 case HAL_PIXEL_FORMAT_YV12:
1215 offset[1] = static_cast<uint32_t>(reinterpret_cast<uint64_t>(yuvInfo.cr) - hnd->base);
1216 stride[2] = static_cast<uint32_t>(yuvInfo.cstride);
1217 offset[2] = static_cast<uint32_t>(reinterpret_cast<uint64_t>(yuvInfo.cb) - hnd->base);
1218 (*num_planes)++;
1219 break;
1220 case HAL_PIXEL_FORMAT_CbYCrY_422_I:
1221 *num_planes = 1;
1222 break;
1223 default:
1224 ALOGW("%s: Unsupported format", __FUNCTION__);
1225 ret = -EINVAL;
1226 }
1227
1228 if (hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
1229 std::fill(offset, offset + 4, 0);
1230 }
1231
1232 return 0;
1233 }
1234
GetGpuResourceSizeAndDimensions(const BufferInfo & info,unsigned int * size,unsigned int * alignedw,unsigned int * alignedh,GraphicsMetadata * graphics_metadata)1235 int GetGpuResourceSizeAndDimensions(const BufferInfo &info, unsigned int *size,
1236 unsigned int *alignedw, unsigned int *alignedh,
1237 GraphicsMetadata *graphics_metadata) {
1238 GetAlignedWidthAndHeight(info, alignedw, alignedh);
1239 AdrenoMemInfo* adreno_mem_info = AdrenoMemInfo::GetInstance();
1240 graphics_metadata->size = adreno_mem_info->AdrenoGetMetadataBlobSize();
1241 uint64_t adreno_usage = info.usage;
1242 // If gralloc disables UBWC based on any of the checks,
1243 // we pass modified usage flag to adreno to convey this.
1244 int is_ubwc_enabled = IsUBwcEnabled(info.format, info.usage);
1245 if (!is_ubwc_enabled) {
1246 adreno_usage &= ~(GRALLOC_USAGE_PRIVATE_ALLOC_UBWC);
1247 } else {
1248 adreno_usage |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
1249 }
1250
1251 // Call adreno api for populating metadata blob
1252 // Layer count is for 2D/Cubemap arrays and depth is used for 3D slice
1253 // Using depth to pass layer_count here
1254 int ret = adreno_mem_info->AdrenoInitMemoryLayout(graphics_metadata->data, info.width,
1255 info.height, info.layer_count, /* depth */
1256 info.format, 1, is_ubwc_enabled,
1257 adreno_usage, 1);
1258 if (ret != 0) {
1259 ALOGE("%s Graphics metadata init failed", __FUNCTION__);
1260 *size = 0;
1261 return -EINVAL;
1262 }
1263 // Call adreno api with the metadata blob to get buffer size
1264 *size = adreno_mem_info->AdrenoGetAlignedGpuBufferSize(graphics_metadata->data);
1265 return 0;
1266 }
1267
CanUseAdrenoForSize(int buffer_type,uint64_t usage)1268 bool CanUseAdrenoForSize(int buffer_type, uint64_t usage) {
1269 if (buffer_type == BUFFER_TYPE_VIDEO || !GetAdrenoSizeAPIStatus()) {
1270 return false;
1271 }
1272
1273 if ((usage & BufferUsage::PROTECTED) && ((usage & BufferUsage::CAMERA_OUTPUT) ||
1274 (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY))) {
1275 return false;
1276 }
1277
1278 return true;
1279 }
1280
GetAdrenoSizeAPIStatus()1281 bool GetAdrenoSizeAPIStatus() {
1282 AdrenoMemInfo* adreno_mem_info = AdrenoMemInfo::GetInstance();
1283 if (adreno_mem_info) {
1284 return adreno_mem_info->AdrenoSizeAPIAvaliable();
1285 }
1286 return false;
1287 }
1288
UseUncached(int format,uint64_t usage)1289 bool UseUncached(int format, uint64_t usage) {
1290 if ((usage & GRALLOC_USAGE_PRIVATE_UNCACHED) || (usage & BufferUsage::PROTECTED)) {
1291 return true;
1292 }
1293
1294 // CPU read rarely
1295 if ((usage & BufferUsage::CPU_READ_MASK) == static_cast<uint64_t>(BufferUsage::CPU_READ_RARELY)) {
1296 return true;
1297 }
1298
1299 // CPU write rarely
1300 if ((usage & BufferUsage::CPU_WRITE_MASK) ==
1301 static_cast<uint64_t>(BufferUsage::CPU_WRITE_RARELY)) {
1302 return true;
1303 }
1304
1305 if ((usage & BufferUsage::SENSOR_DIRECT_DATA) || (usage & BufferUsage::GPU_DATA_BUFFER)) {
1306 return true;
1307 }
1308
1309 if (format && IsUBwcEnabled(format, usage)) {
1310 return true;
1311 }
1312
1313 return false;
1314 }
1315
GetHandleFlags(int format,uint64_t usage)1316 uint64_t GetHandleFlags(int format, uint64_t usage) {
1317 uint64_t priv_flags = 0;
1318
1319 if (usage & BufferUsage::VIDEO_ENCODER) {
1320 priv_flags |= private_handle_t::PRIV_FLAGS_VIDEO_ENCODER;
1321 }
1322
1323 if (usage & BufferUsage::CAMERA_OUTPUT) {
1324 priv_flags |= private_handle_t::PRIV_FLAGS_CAMERA_WRITE;
1325 }
1326
1327 if (usage & BufferUsage::CAMERA_INPUT) {
1328 priv_flags |= private_handle_t::PRIV_FLAGS_CAMERA_READ;
1329 }
1330
1331 if (usage & BufferUsage::COMPOSER_OVERLAY) {
1332 priv_flags |= private_handle_t::PRIV_FLAGS_DISP_CONSUMER;
1333 }
1334
1335 if (usage & BufferUsage::GPU_TEXTURE) {
1336 priv_flags |= private_handle_t::PRIV_FLAGS_HW_TEXTURE;
1337 }
1338
1339 if (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) {
1340 priv_flags |= private_handle_t::PRIV_FLAGS_SECURE_DISPLAY;
1341 }
1342
1343 if (IsUBwcEnabled(format, usage)) {
1344 priv_flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
1345 if (IsUBwcPISupported(format, usage)) {
1346 priv_flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED_PI;
1347 }
1348 }
1349
1350 if (usage & (BufferUsage::CPU_READ_MASK | BufferUsage::CPU_WRITE_MASK)) {
1351 priv_flags |= private_handle_t::PRIV_FLAGS_CPU_RENDERED;
1352 }
1353
1354 if ((usage & (BufferUsage::VIDEO_ENCODER | BufferUsage::VIDEO_DECODER |
1355 BufferUsage::CAMERA_OUTPUT | BufferUsage::GPU_RENDER_TARGET))) {
1356 priv_flags |= private_handle_t::PRIV_FLAGS_NON_CPU_WRITER;
1357 }
1358
1359 if (!UseUncached(format, usage)) {
1360 priv_flags |= private_handle_t::PRIV_FLAGS_CACHED;
1361 }
1362
1363 return priv_flags;
1364 }
1365
GetImplDefinedFormat(uint64_t usage,int format)1366 int GetImplDefinedFormat(uint64_t usage, int format) {
1367 int gr_format = format;
1368
1369 // If input format is HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED then based on
1370 // the usage bits, gralloc assigns a format.
1371 if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
1372 format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
1373 if ((usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC || usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC_PI)
1374 && format != HAL_PIXEL_FORMAT_YCbCr_420_888) {
1375 gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
1376 } else if (usage & BufferUsage::VIDEO_ENCODER) {
1377 if (usage & GRALLOC_USAGE_PRIVATE_VIDEO_NV21_ENCODER) {
1378 gr_format = HAL_PIXEL_FORMAT_NV21_ENCODEABLE; // NV21
1379 } else if (usage & GRALLOC_USAGE_PRIVATE_HEIF) {
1380 gr_format = HAL_PIXEL_FORMAT_NV12_HEIF;
1381 } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
1382 gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;
1383 } else {
1384 gr_format = HAL_PIXEL_FORMAT_NV12_ENCODEABLE; // NV12
1385 }
1386 } else if (usage & BufferUsage::CAMERA_INPUT) {
1387 if (usage & BufferUsage::CAMERA_OUTPUT) {
1388 // Assumed ZSL if both producer and consumer camera flags set
1389 gr_format = HAL_PIXEL_FORMAT_NV21_ZSL; // NV21
1390 } else {
1391 gr_format = HAL_PIXEL_FORMAT_YCrCb_420_SP; // NV21
1392 }
1393 } else if (usage & BufferUsage::CAMERA_OUTPUT) {
1394 if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
1395 if ((usage & BufferUsage::PROTECTED) && (!CanAllocateZSLForSecureCamera())) {
1396 gr_format = HAL_PIXEL_FORMAT_YCrCb_420_SP; // NV21
1397 } else {
1398 gr_format = HAL_PIXEL_FORMAT_NV21_ZSL; // NV21
1399 }
1400 } else {
1401 gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS; // NV12 preview
1402 }
1403 } else if (usage & BufferUsage::COMPOSER_OVERLAY) {
1404 // XXX: If we still haven't set a format, default to RGBA8888
1405 gr_format = HAL_PIXEL_FORMAT_RGBA_8888;
1406 } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
1407 // If no other usage flags are detected, default the
1408 // flexible YUV format to YCrCb_420_SP
1409 gr_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;
1410 }
1411 }
1412
1413 return gr_format;
1414 }
1415
GetCustomFormatFlags(int format,uint64_t usage,int * custom_format,uint64_t * priv_flags)1416 int GetCustomFormatFlags(int format, uint64_t usage,
1417 int *custom_format, uint64_t *priv_flags) {
1418 *custom_format = GetImplDefinedFormat(usage, format);
1419 *priv_flags = GetHandleFlags(*custom_format, usage);
1420
1421 if (usage & GRALLOC_USAGE_PROTECTED) {
1422 *priv_flags |= private_handle_t::PRIV_FLAGS_SECURE_BUFFER;
1423 }
1424
1425 *priv_flags |= private_handle_t::PRIV_FLAGS_USES_ION;
1426
1427 return 0;
1428 }
1429
GetBufferType(int inputFormat)1430 int GetBufferType(int inputFormat) {
1431 return IsYuvFormat(inputFormat) ? BUFFER_TYPE_VIDEO : BUFFER_TYPE_UI;
1432 }
1433
1434 // Here width and height are aligned width and aligned height.
GetYUVPlaneInfo(const BufferInfo & info,int32_t format,int32_t width,int32_t height,int32_t flags,int * plane_count,PlaneLayoutInfo * plane_info)1435 int GetYUVPlaneInfo(const BufferInfo &info, int32_t format, int32_t width, int32_t height,
1436 int32_t flags, int *plane_count, PlaneLayoutInfo *plane_info) {
1437 int err = 0;
1438 unsigned int y_stride, c_stride, y_height, c_height, y_size, c_size;
1439 uint64_t yOffset, cOffset, crOffset, cbOffset;
1440 int h_subsampling = 0, v_subsampling = 0;
1441 if (IsCameraCustomFormat(format) && CameraInfo::GetInstance()) {
1442 int result = CameraInfo::GetInstance()->GetCameraFormatPlaneInfo(
1443 format, info.width, info.height, plane_count, plane_info);
1444 if (result != 0) {
1445 ALOGE(
1446 "%s: Failed to get the plane info through camera library. width: %d, height: %d,"
1447 "format: %d, Error code: %d",
1448 __FUNCTION__, width, height, format, result);
1449 }
1450 return result;
1451 }
1452
1453 switch (format) {
1454 // Semiplanar
1455 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
1456 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1457 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
1458 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: // Same as YCbCr_420_SP_VENUS
1459 case HAL_PIXEL_FORMAT_NV21_ENCODEABLE:
1460 case HAL_PIXEL_FORMAT_NV12_HEIF:
1461 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1462 case HAL_PIXEL_FORMAT_YCrCb_422_SP:
1463 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
1464 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
1465 *plane_count = 2;
1466 GetYuvSPPlaneInfo(info, format, width, height, 1, plane_info);
1467 GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
1468 plane_info[0].h_subsampling = 0;
1469 plane_info[0].v_subsampling = 0;
1470 plane_info[1].h_subsampling = h_subsampling;
1471 plane_info[1].v_subsampling = v_subsampling;
1472 break;
1473
1474 case HAL_PIXEL_FORMAT_RAW16:
1475 case HAL_PIXEL_FORMAT_RAW12:
1476 case HAL_PIXEL_FORMAT_RAW10:
1477 case HAL_PIXEL_FORMAT_RAW8:
1478 case HAL_PIXEL_FORMAT_BLOB:
1479 *plane_count = 1;
1480 GetRawPlaneInfo(format, info.width, info.height, plane_info);
1481 break;
1482
1483 case HAL_PIXEL_FORMAT_Y8:
1484 *plane_count = 1;
1485 GetYuvSPPlaneInfo(info, format, width, height, 1, plane_info);
1486 GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
1487 plane_info[0].h_subsampling = h_subsampling;
1488 plane_info[0].v_subsampling = v_subsampling;
1489 break;
1490
1491 case HAL_PIXEL_FORMAT_Y16:
1492 *plane_count = 1;
1493 GetYuvSPPlaneInfo(info, format, width, height, 2, plane_info);
1494 GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
1495 plane_info[0].h_subsampling = h_subsampling;
1496 plane_info[0].v_subsampling = v_subsampling;
1497 break;
1498
1499 #ifndef QMAA
1500 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
1501 GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
1502 if (flags & LAYOUT_INTERLACED_FLAG) {
1503 *plane_count = 8;
1504 GetYuvUbwcInterlacedSPPlaneInfo(width, height, plane_info);
1505 plane_info[0].step = plane_info[4].step = 1;
1506 plane_info[1].step = plane_info[5].step = 2;
1507 plane_info[0].h_subsampling = plane_info[4].h_subsampling = 0;
1508 plane_info[0].v_subsampling = plane_info[4].v_subsampling = 0;
1509 plane_info[1].h_subsampling = plane_info[5].h_subsampling = h_subsampling;
1510 plane_info[1].v_subsampling = plane_info[5].v_subsampling = v_subsampling;
1511 plane_info[2].h_subsampling = plane_info[3].h_subsampling = 0;
1512 plane_info[2].v_subsampling = plane_info[3].v_subsampling = 0;
1513 plane_info[2].step = plane_info[3].step = 0;
1514 plane_info[6].h_subsampling = plane_info[7].h_subsampling = 0;
1515 plane_info[6].v_subsampling = plane_info[7].v_subsampling = 0;
1516 plane_info[6].step = plane_info[7].step = 0;
1517 } else {
1518 *plane_count = 4;
1519 GetYuvUbwcSPPlaneInfo(width, height, COLOR_FMT_NV12_UBWC, plane_info);
1520 plane_info[0].h_subsampling = 0;
1521 plane_info[0].v_subsampling = 0;
1522 plane_info[0].step = 1;
1523 plane_info[1].h_subsampling = h_subsampling;
1524 plane_info[1].v_subsampling = v_subsampling;
1525 plane_info[1].step = 2;
1526 plane_info[2].h_subsampling = plane_info[3].h_subsampling = 0;
1527 plane_info[2].v_subsampling = plane_info[3].v_subsampling = 0;
1528 plane_info[2].step = plane_info[3].step = 0;
1529 }
1530 break;
1531
1532 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
1533 *plane_count = 2;
1534 GetYuvSPPlaneInfo(info, format, width, height, 2, plane_info);
1535 GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
1536 plane_info[0].h_subsampling = 0;
1537 plane_info[0].v_subsampling = 0;
1538 plane_info[1].h_subsampling = h_subsampling;
1539 plane_info[1].v_subsampling = v_subsampling;
1540 break;
1541
1542 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
1543 *plane_count = 4;
1544 GetYuvUbwcSPPlaneInfo(width, height, COLOR_FMT_NV12_BPP10_UBWC, plane_info);
1545 GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
1546 plane_info[0].h_subsampling = 0;
1547 plane_info[0].v_subsampling = 0;
1548 plane_info[1].step = 1;
1549 plane_info[1].h_subsampling = h_subsampling;
1550 plane_info[1].v_subsampling = v_subsampling;
1551 plane_info[1].step = 3;
1552 plane_info[2].h_subsampling = plane_info[3].h_subsampling = 0;
1553 plane_info[2].v_subsampling = plane_info[3].v_subsampling = 0;
1554 plane_info[2].step = plane_info[3].step = 0;
1555 break;
1556
1557 case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
1558 *plane_count = 4;
1559 GetYuvUbwcSPPlaneInfo(width, height, COLOR_FMT_P010_UBWC, plane_info);
1560 GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
1561 plane_info[0].h_subsampling = 0;
1562 plane_info[0].v_subsampling = 0;
1563 plane_info[1].step = 1;
1564 plane_info[1].h_subsampling = h_subsampling;
1565 plane_info[1].v_subsampling = v_subsampling;
1566 plane_info[1].step = 4;
1567 plane_info[2].h_subsampling = plane_info[3].h_subsampling = 0;
1568 plane_info[2].v_subsampling = plane_info[3].v_subsampling = 0;
1569 plane_info[2].step = plane_info[3].step = 0;
1570 break;
1571
1572 case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
1573 *plane_count = 2;
1574 y_stride = VENUS_Y_STRIDE(COLOR_FMT_P010, width);
1575 c_stride = VENUS_UV_STRIDE(COLOR_FMT_P010, width);
1576 y_height = VENUS_Y_SCANLINES(COLOR_FMT_P010, height);
1577 y_size = y_stride * y_height;
1578 yOffset = 0;
1579 cOffset = y_size;
1580 c_height = VENUS_UV_SCANLINES(COLOR_FMT_P010, INT(height));
1581 c_size = c_stride * c_height;
1582 GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
1583
1584 plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_Y;
1585 plane_info[0].offset = (uint32_t)yOffset;
1586 plane_info[0].stride = static_cast<int32_t>(UINT(width));
1587 plane_info[0].stride_bytes = static_cast<int32_t>(y_stride);
1588 plane_info[0].scanlines = static_cast<int32_t>(y_height);
1589 plane_info[0].size = static_cast<uint32_t>(y_size);
1590 plane_info[0].step = 1;
1591 plane_info[0].h_subsampling = 0;
1592 plane_info[0].v_subsampling = 0;
1593
1594 plane_info[1].component = (PlaneComponent)(PLANE_COMPONENT_Cb | PLANE_COMPONENT_Cr);
1595 plane_info[1].offset = (uint32_t)cOffset;
1596 plane_info[1].stride = static_cast<int32_t>(UINT(width));
1597 plane_info[1].stride_bytes = static_cast<int32_t>(c_stride);
1598 plane_info[1].scanlines = static_cast<int32_t>(c_height);
1599 plane_info[1].size = static_cast<uint32_t>(c_size);
1600 plane_info[1].step = 4;
1601 plane_info[1].h_subsampling = h_subsampling;
1602 plane_info[1].v_subsampling = v_subsampling;
1603 break;
1604 #endif
1605 // Planar
1606 case HAL_PIXEL_FORMAT_YV12:
1607 if ((info.width & 1) || (info.height & 1)) {
1608 ALOGE("w or h is odd for the YV12 format");
1609 err = -EINVAL;
1610 return err;
1611 }
1612 *plane_count = 3;
1613 y_stride = width;
1614 c_stride = ALIGN(width / 2, 16);
1615 y_height = UINT(height);
1616 y_size = (y_stride * y_height);
1617 height = height >> 1;
1618 c_height = UINT(height);
1619 c_size = (c_stride * c_height);
1620 yOffset = 0;
1621 crOffset = y_size;
1622 cbOffset = (y_size + c_size);
1623 GetYuvSubSamplingFactor(format, &h_subsampling, &v_subsampling);
1624
1625 plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_Y;
1626 plane_info[0].offset = (uint32_t)yOffset;
1627 plane_info[0].stride = static_cast<int32_t>(UINT(width));
1628 plane_info[0].stride_bytes = static_cast<int32_t>(y_stride);
1629 plane_info[0].scanlines = static_cast<int32_t>(y_height);
1630 plane_info[0].size = static_cast<uint32_t>(y_size);
1631 plane_info[0].step = 1;
1632 plane_info[0].h_subsampling = 0;
1633 plane_info[0].v_subsampling = 0;
1634
1635 plane_info[1].component = (PlaneComponent)PLANE_COMPONENT_Cb;
1636 plane_info[1].offset = (uint32_t)cbOffset;
1637 plane_info[2].component = (PlaneComponent)PLANE_COMPONENT_Cr;
1638 plane_info[2].offset = (uint32_t)crOffset;
1639 for (int i = 1; i < 3; i++) {
1640 plane_info[i].stride = static_cast<int32_t>(UINT(width));
1641 plane_info[i].stride_bytes = static_cast<int32_t>(c_stride);
1642 plane_info[i].scanlines = static_cast<int32_t>(c_height);
1643 plane_info[i].size = static_cast<uint32_t>(c_size);
1644 plane_info[i].step = 1;
1645 plane_info[i].h_subsampling = h_subsampling;
1646 plane_info[i].v_subsampling = v_subsampling;
1647 }
1648 break;
1649 case HAL_PIXEL_FORMAT_CbYCrY_422_I:
1650 if (info.width & 1) {
1651 ALOGE("width is odd for the YUV422_SP format");
1652 err = -EINVAL;
1653 return err;
1654 }
1655 *plane_count = 1;
1656 y_stride = width * 2;
1657 y_height = UINT(height);
1658 y_size = y_stride * y_height;
1659 yOffset = 0;
1660 plane_info[0].component = (PlaneComponent)PLANE_COMPONENT_Y;
1661 plane_info[0].offset = (uint32_t)yOffset;
1662 plane_info[0].stride = static_cast<int32_t>(UINT(width));
1663 plane_info[0].stride_bytes = static_cast<int32_t>(y_stride);
1664 plane_info[0].scanlines = static_cast<int32_t>(y_height);
1665 plane_info[0].size = static_cast<uint32_t>(y_size);
1666 plane_info[0].step = 1;
1667 plane_info[0].h_subsampling = 0;
1668 plane_info[0].v_subsampling = 0;
1669 break;
1670
1671 // Unsupported formats
1672 case HAL_PIXEL_FORMAT_YCbCr_422_I:
1673 case HAL_PIXEL_FORMAT_YCrCb_422_I:
1674 case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
1675 default:
1676 *plane_count = 0;
1677 ALOGD("%s: Invalid format passed: 0x%x", __FUNCTION__, format);
1678 err = -EINVAL;
1679 }
1680 return err;
1681 }
1682
GetYuvSubSamplingFactor(int32_t format,int * h_subsampling,int * v_subsampling)1683 void GetYuvSubSamplingFactor(int32_t format, int *h_subsampling, int *v_subsampling) {
1684 switch (format) {
1685 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
1686 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
1687 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
1688 case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
1689 case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
1690 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
1691 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
1692 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
1693 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
1694 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1695 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: // Same as YCbCr_420_SP_VENUS
1696 case HAL_PIXEL_FORMAT_NV21_ENCODEABLE:
1697 case HAL_PIXEL_FORMAT_YV12:
1698 case HAL_PIXEL_FORMAT_NV12_HEIF:
1699 *h_subsampling = 1;
1700 *v_subsampling = 1;
1701 break;
1702 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1703 case HAL_PIXEL_FORMAT_YCrCb_422_SP:
1704 case HAL_PIXEL_FORMAT_CbYCrY_422_I:
1705 *h_subsampling = 1;
1706 *v_subsampling = 0;
1707 break;
1708 case HAL_PIXEL_FORMAT_Y16:
1709 case HAL_PIXEL_FORMAT_Y8:
1710 case HAL_PIXEL_FORMAT_BLOB:
1711 default:
1712 *h_subsampling = 0;
1713 *v_subsampling = 0;
1714 break;
1715 }
1716 }
1717
CopyPlaneLayoutInfotoAndroidYcbcr(uint64_t base,int plane_count,PlaneLayoutInfo * plane_info,struct android_ycbcr * ycbcr)1718 void CopyPlaneLayoutInfotoAndroidYcbcr(uint64_t base, int plane_count, PlaneLayoutInfo *plane_info,
1719 struct android_ycbcr *ycbcr) {
1720 ycbcr->y = reinterpret_cast<void *>(base + plane_info[0].offset);
1721 ycbcr->ystride = plane_info[0].stride_bytes;
1722 if (plane_count == 1) {
1723 ycbcr->cb = NULL;
1724 ycbcr->cr = NULL;
1725 ycbcr->cstride = 0;
1726 ycbcr->chroma_step = 0;
1727 } else if (plane_count == 2 || plane_count == 4 || plane_count == 8) {
1728 /* For YUV semiplanar :-
1729 * - In progressive & linear case plane count is 2 and plane_info[0] will
1730 * contain info about Y plane and plane_info[1] will contain info about UV plane.
1731 * - In progressive & compressed case plane count is 4 then plane_info[0] will
1732 * contain info about Y plane and plane_info[1] will contain info about UV plane.
1733 * Remaining two plane (plane_info[2] & plane_info[3]) contain info about the
1734 * Y_Meta_Plane and UV_Meta_Plane.
1735 * - In interlaced & compressed case plane count is 8 then plane_info[0], plane_info[1],
1736 * plane_info[4] & plane_info[5] will contain info about Y_plane, UV_plane, Y_plane
1737 * & UV_plane. Remaining plane will contain info about the meta planes. As in this case
1738 * this API is called twice through GetYUVPlaneInfo() with address of plane_info[0] &
1739 * plane_info[4], so this will calculate the information accordingly and will fill the
1740 * ycbcr structure with interlaced plane info only.
1741 */
1742 ycbcr->cb = reinterpret_cast<void *>(base + plane_info[1].offset);
1743 ycbcr->cr = reinterpret_cast<void *>(base + plane_info[1].offset + 1);
1744 ycbcr->cstride = plane_info[1].stride_bytes;
1745 ycbcr->chroma_step = plane_info[1].step;
1746 } else if (plane_count == 3) {
1747 /* For YUV planar :-
1748 * Plane size is 3 and plane_info[0], plane_info[1], plane_info[2] will
1749 * contain info about y_plane, cb_plane and cr_plane accordingly.
1750 */
1751 ycbcr->cb = reinterpret_cast<void *>(base + plane_info[1].offset);
1752 ycbcr->cr = reinterpret_cast<void *>(base + plane_info[2].offset);
1753 ycbcr->cstride = plane_info[1].stride_bytes;
1754 ycbcr->chroma_step = plane_info[1].step;
1755 }
1756 }
1757
HasAlphaComponent(int32_t format)1758 bool HasAlphaComponent(int32_t format) {
1759 switch (format) {
1760 case HAL_PIXEL_FORMAT_RGBA_8888:
1761 case HAL_PIXEL_FORMAT_BGRA_8888:
1762 case HAL_PIXEL_FORMAT_RGBA_5551:
1763 case HAL_PIXEL_FORMAT_RGBA_4444:
1764 case HAL_PIXEL_FORMAT_RGBA_1010102:
1765 case HAL_PIXEL_FORMAT_ARGB_2101010:
1766 case HAL_PIXEL_FORMAT_BGRA_1010102:
1767 case HAL_PIXEL_FORMAT_ABGR_2101010:
1768 case HAL_PIXEL_FORMAT_RGBA_FP16:
1769 return true;
1770 default:
1771 return false;
1772 }
1773 }
1774
GetRGBPlaneInfo(const BufferInfo & info,int32_t format,int32_t width,int32_t height,int32_t,int * plane_count,PlaneLayoutInfo * plane_info)1775 void GetRGBPlaneInfo(const BufferInfo &info, int32_t format, int32_t width, int32_t height,
1776 int32_t /* flags */, int *plane_count, PlaneLayoutInfo *plane_info) {
1777 uint64_t usage = info.usage;
1778 *plane_count = 1;
1779 plane_info->component =
1780 (PlaneComponent)(PLANE_COMPONENT_R | PLANE_COMPONENT_G | PLANE_COMPONENT_B);
1781 if (HasAlphaComponent(format)) {
1782 plane_info->component = (PlaneComponent)(plane_info->component | PLANE_COMPONENT_A);
1783 }
1784 GetBufferSizeAndDimensions(info, &(plane_info->size), (unsigned int *) &width,
1785 (unsigned int *) &height);
1786 plane_info->step = GetBpp(format);
1787 plane_info->offset = GetRgbMetaSize(format, width, height, usage);
1788 plane_info->h_subsampling = 0;
1789 plane_info->v_subsampling = 0;
1790 plane_info->stride = width;
1791 plane_info->stride_bytes = width * plane_info->step;
1792 plane_info->scanlines = height;
1793 }
1794
1795 // TODO(tbalacha): tile vs ubwc -- may need to find a diff way to differentiate
GetDRMFormat(uint32_t format,uint32_t flags,uint32_t * drm_format,uint64_t * drm_format_modifier)1796 void GetDRMFormat(uint32_t format, uint32_t flags, uint32_t *drm_format,
1797 uint64_t *drm_format_modifier) {
1798 bool compressed = (flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) ? true : false;
1799 switch (format) {
1800 case HAL_PIXEL_FORMAT_RGBA_8888:
1801 *drm_format = DRM_FORMAT_ABGR8888;
1802 break;
1803 case HAL_PIXEL_FORMAT_RGBA_5551:
1804 *drm_format = DRM_FORMAT_ABGR1555;
1805 break;
1806 case HAL_PIXEL_FORMAT_RGBA_4444:
1807 *drm_format = DRM_FORMAT_ABGR4444;
1808 break;
1809 case HAL_PIXEL_FORMAT_BGRA_8888:
1810 *drm_format = DRM_FORMAT_ARGB8888;
1811 break;
1812 case HAL_PIXEL_FORMAT_RGBX_8888:
1813 *drm_format = DRM_FORMAT_XBGR8888;
1814 if (compressed)
1815 *drm_format_modifier = DRM_FORMAT_MOD_QCOM_COMPRESSED;
1816 break;
1817 case HAL_PIXEL_FORMAT_BGRX_8888:
1818 *drm_format = DRM_FORMAT_XRGB8888;
1819 break;
1820 case HAL_PIXEL_FORMAT_RGB_888:
1821 *drm_format = DRM_FORMAT_BGR888;
1822 break;
1823 case HAL_PIXEL_FORMAT_RGB_565:
1824 *drm_format = DRM_FORMAT_BGR565;
1825 break;
1826 case HAL_PIXEL_FORMAT_BGR_565:
1827 *drm_format = DRM_FORMAT_BGR565;
1828 if (compressed)
1829 *drm_format_modifier = DRM_FORMAT_MOD_QCOM_COMPRESSED;
1830 break;
1831 case HAL_PIXEL_FORMAT_RGBA_1010102:
1832 *drm_format = DRM_FORMAT_ABGR2101010;
1833 if (compressed)
1834 *drm_format_modifier = DRM_FORMAT_MOD_QCOM_COMPRESSED;
1835 break;
1836 case HAL_PIXEL_FORMAT_ARGB_2101010:
1837 *drm_format = DRM_FORMAT_BGRA1010102;
1838 break;
1839 case HAL_PIXEL_FORMAT_RGBX_1010102:
1840 *drm_format = DRM_FORMAT_XBGR2101010;
1841 if (compressed)
1842 *drm_format_modifier = DRM_FORMAT_MOD_QCOM_COMPRESSED;
1843 break;
1844 case HAL_PIXEL_FORMAT_XRGB_2101010:
1845 *drm_format = DRM_FORMAT_BGRX1010102;
1846 break;
1847 case HAL_PIXEL_FORMAT_BGRA_1010102:
1848 *drm_format = DRM_FORMAT_ARGB2101010;
1849 break;
1850 case HAL_PIXEL_FORMAT_ABGR_2101010:
1851 *drm_format = DRM_FORMAT_RGBA1010102;
1852 break;
1853 case HAL_PIXEL_FORMAT_BGRX_1010102:
1854 *drm_format = DRM_FORMAT_XRGB2101010;
1855 break;
1856 case HAL_PIXEL_FORMAT_XBGR_2101010:
1857 *drm_format = DRM_FORMAT_RGBX1010102;
1858 break;
1859 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
1860 *drm_format = DRM_FORMAT_NV12;
1861 break;
1862 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
1863 *drm_format = DRM_FORMAT_NV12;
1864 if (compressed) {
1865 *drm_format_modifier = DRM_FORMAT_MOD_QCOM_COMPRESSED;
1866 } else {
1867 *drm_format_modifier = DRM_FORMAT_MOD_QCOM_TILE;
1868 }
1869 break;
1870 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1871 *drm_format = DRM_FORMAT_NV21;
1872 break;
1873 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
1874 *drm_format = DRM_FORMAT_NV21;
1875 break;
1876 case HAL_PIXEL_FORMAT_YCbCr_420_P010:
1877 case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
1878 *drm_format = DRM_FORMAT_NV12;
1879 *drm_format_modifier = DRM_FORMAT_MOD_QCOM_DX;
1880 break;
1881 case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
1882 *drm_format = DRM_FORMAT_NV12;
1883 if (compressed) {
1884 *drm_format_modifier = DRM_FORMAT_MOD_QCOM_COMPRESSED | DRM_FORMAT_MOD_QCOM_DX;
1885 } else {
1886 *drm_format_modifier = DRM_FORMAT_MOD_QCOM_TILE | DRM_FORMAT_MOD_QCOM_DX;
1887 }
1888 break;
1889 case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
1890 *drm_format = DRM_FORMAT_NV12;
1891 if (compressed) {
1892 *drm_format_modifier =
1893 DRM_FORMAT_MOD_QCOM_COMPRESSED | DRM_FORMAT_MOD_QCOM_DX | DRM_FORMAT_MOD_QCOM_TIGHT;
1894 } else {
1895 *drm_format_modifier =
1896 DRM_FORMAT_MOD_QCOM_TILE | DRM_FORMAT_MOD_QCOM_DX | DRM_FORMAT_MOD_QCOM_TIGHT;
1897 }
1898 break;
1899 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1900 *drm_format = DRM_FORMAT_NV16;
1901 break;
1902 /*
1903 TODO: No HAL_PIXEL_FORMAT equivalent?
1904 case kFormatYCrCb422H2V1SemiPlanar:
1905 *drm_format = DRM_FORMAT_NV61;
1906 break;*/
1907 case HAL_PIXEL_FORMAT_YV12:
1908 *drm_format = DRM_FORMAT_YVU420;
1909 break;
1910 default:
1911 ALOGE("Unsupported format %d", format);
1912 }
1913 }
1914
CanAllocateZSLForSecureCamera()1915 bool CanAllocateZSLForSecureCamera() {
1916 static bool inited = false;
1917 static bool can_allocate = true;
1918 if (inited) {
1919 return can_allocate;
1920 }
1921 char property[PROPERTY_VALUE_MAX];
1922 property_get("vendor.gralloc.secure_preview_buffer_format", property, "0");
1923 if (!(strncmp(property, "420_sp", PROPERTY_VALUE_MAX))) {
1924 can_allocate = false;
1925 }
1926 inited = true;
1927 ALOGI("CanAllocateZSLForSecureCamera: %d", can_allocate);
1928
1929 return can_allocate;
1930 }
1931 } // namespace gralloc
1932