1 /*
2  * Copyright (c) 2011-2018, 2020, 2022 The Linux Foundation. All rights reserved.
3  * Not a Contribution
4  *
5  * Copyright (C) 2010 The Android Open Source Project
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  */
19 
20 /*
21 * Changes from Qualcomm Innovation Center are provided under the following license:
22 *
23 * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
24 *
25 * Redistribution and use in source and binary forms, with or without
26 * modification, are permitted (subject to the limitations in the
27 * disclaimer below) provided that the following conditions are met:
28 *
29 *    * Redistributions of source code must retain the above copyright
30 *      notice, this list of conditions and the following disclaimer.
31 *
32 *    * Redistributions in binary form must reproduce the above
33 *      copyright notice, this list of conditions and the following
34 *      disclaimer in the documentation and/or other materials provided
35 *      with the distribution.
36 *
37 *    * Neither the name of Qualcomm Innovation Center, Inc. nor the names of its
38 *      contributors may be used to endorse or promote products derived
39 *      from this software without specific prior written permission.
40 *
41 * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
42 * GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
43 * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
44 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
45 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
46 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
47 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
49 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
50 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
51 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
52 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
53 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54 */
55 
56 #define DEBUG 0
57 
58 #include "gr_buf_mgr.h"
59 
60 #include <QtiGralloc.h>
61 #include <QtiGrallocPriv.h>
62 #include <gralloctypes/Gralloc4.h>
63 #include <sys/mman.h>
64 
65 #include <algorithm>
66 #include <iomanip>
67 #include <sstream>
68 #include <string>
69 #include <utility>
70 #include <vector>
71 #include <fstream>
72 #include "gr_adreno_info.h"
73 #include "gr_buf_descriptor.h"
74 #include "gr_priv_handle.h"
75 #include "gr_utils.h"
76 #include "qdMetaData.h"
77 #include "qd_utils.h"
78 
79 namespace gralloc {
80 
81 using aidl::android::hardware::graphics::common::BlendMode;
82 using aidl::android::hardware::graphics::common::Cta861_3;
83 using aidl::android::hardware::graphics::common::Dataspace;
84 using aidl::android::hardware::graphics::common::PlaneLayout;
85 using aidl::android::hardware::graphics::common::PlaneLayoutComponent;
86 using aidl::android::hardware::graphics::common::Rect;
87 using aidl::android::hardware::graphics::common::Smpte2086;
88 using aidl::android::hardware::graphics::common::StandardMetadataType;
89 using aidl::android::hardware::graphics::common::XyColor;
90 using ::android::hardware::graphics::common::V1_2::PixelFormat;
91 using IMapper_4_0_Error =  ::android::hardware::graphics::mapper::V4_0::Error;
92 
GetBufferInfo(const BufferDescriptor & descriptor)93 static BufferInfo GetBufferInfo(const BufferDescriptor &descriptor) {
94   return BufferInfo(descriptor.GetWidth(), descriptor.GetHeight(), descriptor.GetFormat(),
95                     descriptor.GetUsage());
96 }
97 
getMetaDataSize(uint64_t reserved_region_size)98 static uint64_t getMetaDataSize(uint64_t reserved_region_size) {
99 // Only include the reserved region size when using Metadata_t V2
100 #ifndef METADATA_V2
101   reserved_region_size = 0;
102 #endif
103   return static_cast<uint64_t>(ROUND_UP_PAGESIZE(sizeof(MetaData_t) + reserved_region_size));
104 }
105 
unmapAndReset(private_handle_t * handle)106 static void unmapAndReset(private_handle_t *handle) {
107   uint64_t reserved_region_size = handle->reserved_size;
108   if (private_handle_t::validate(handle) == 0 && handle->base_metadata) {
109     munmap(reinterpret_cast<void *>(handle->base_metadata), getMetaDataSize(reserved_region_size));
110     handle->base_metadata = 0;
111   }
112 }
113 
validateAndMap(private_handle_t * handle)114 static int validateAndMap(private_handle_t *handle) {
115   if (private_handle_t::validate(handle)) {
116     ALOGE("%s: Private handle is invalid - handle:%p", __func__, handle);
117     return -1;
118   }
119   if (handle->fd_metadata < 0) {
120     // Silently return, metadata cannot be used
121     return -1;
122   }
123 
124   if (!handle->base_metadata) {
125     uint64_t reserved_region_size = handle->reserved_size;
126     uint64_t size = getMetaDataSize(reserved_region_size);
127     void *base = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd_metadata, 0);
128     if (base == reinterpret_cast<void *>(MAP_FAILED)) {
129       ALOGE("%s: metadata mmap failed - handle:%p fd: %d err: %s", __func__, handle,
130             handle->fd_metadata, strerror(errno));
131       return -1;
132     }
133     handle->base_metadata = (uintptr_t)base;
134   }
135   return 0;
136 }
137 
dataspaceToColorMetadata(Dataspace dataspace,ColorMetaData * color_metadata)138 static Error dataspaceToColorMetadata(Dataspace dataspace, ColorMetaData *color_metadata) {
139   ColorMetaData out;
140   uint32_t primaries = (uint32_t)dataspace & (uint32_t)Dataspace::STANDARD_MASK;
141   uint32_t transfer = (uint32_t)dataspace & (uint32_t)Dataspace::TRANSFER_MASK;
142   uint32_t range = (uint32_t)dataspace & (uint32_t)Dataspace::RANGE_MASK;
143 
144   switch (primaries) {
145     case (uint32_t)Dataspace::STANDARD_BT709:
146       out.colorPrimaries = ColorPrimaries_BT709_5;
147       break;
148     // TODO(tbalacha): verify this is equivalent
149     case (uint32_t)Dataspace::STANDARD_BT470M:
150       out.colorPrimaries = ColorPrimaries_BT470_6M;
151       break;
152     case (uint32_t)Dataspace::STANDARD_BT601_625:
153     case (uint32_t)Dataspace::STANDARD_BT601_625_UNADJUSTED:
154       out.colorPrimaries = ColorPrimaries_BT601_6_625;
155       break;
156     case (uint32_t)Dataspace::STANDARD_BT601_525:
157     case (uint32_t)Dataspace::STANDARD_BT601_525_UNADJUSTED:
158       out.colorPrimaries = ColorPrimaries_BT601_6_525;
159       break;
160     case (uint32_t)Dataspace::STANDARD_FILM:
161       out.colorPrimaries = ColorPrimaries_GenericFilm;
162       break;
163     case (uint32_t)Dataspace::STANDARD_BT2020:
164       out.colorPrimaries = ColorPrimaries_BT2020;
165       break;
166     case (uint32_t)Dataspace::STANDARD_ADOBE_RGB:
167       out.colorPrimaries = ColorPrimaries_AdobeRGB;
168       break;
169     case (uint32_t)Dataspace::STANDARD_DCI_P3:
170       out.colorPrimaries = ColorPrimaries_DCIP3;
171       break;
172     default:
173       return Error::UNSUPPORTED;
174       /*
175        ColorPrimaries_SMPTE_240M;
176        ColorPrimaries_SMPTE_ST428;
177        ColorPrimaries_EBU3213;
178       */
179   }
180 
181   switch (transfer) {
182     case (uint32_t)Dataspace::TRANSFER_SRGB:
183       out.transfer = Transfer_sRGB;
184       break;
185     case (uint32_t)Dataspace::TRANSFER_GAMMA2_2:
186       out.transfer = Transfer_Gamma2_2;
187       break;
188     case (uint32_t)Dataspace::TRANSFER_GAMMA2_8:
189       out.transfer = Transfer_Gamma2_8;
190       break;
191     case (uint32_t)Dataspace::TRANSFER_SMPTE_170M:
192       out.transfer = Transfer_SMPTE_170M;
193       break;
194     case (uint32_t)Dataspace::TRANSFER_LINEAR:
195       out.transfer = Transfer_Linear;
196       break;
197     case (uint32_t)Dataspace::TRANSFER_HLG:
198       out.transfer = Transfer_HLG;
199       break;
200     default:
201       return Error::UNSUPPORTED;
202       /*
203       Transfer_SMPTE_240M
204       Transfer_Log
205       Transfer_Log_Sqrt
206       Transfer_XvYCC
207       Transfer_BT1361
208       Transfer_sYCC
209       Transfer_BT2020_2_1
210       Transfer_BT2020_2_2
211       Transfer_SMPTE_ST2084
212       Transfer_ST_428
213       */
214   }
215 
216   switch (range) {
217     case (uint32_t)Dataspace::RANGE_FULL:
218       out.range = Range_Full;
219       break;
220     case (uint32_t)Dataspace::RANGE_LIMITED:
221       out.range = Range_Limited;
222       break;
223     case (uint32_t)Dataspace::RANGE_EXTENDED:
224       out.range = Range_Extended;
225       break;
226     default:
227       return Error::UNSUPPORTED;
228   }
229 
230   color_metadata->colorPrimaries = out.colorPrimaries;
231   color_metadata->transfer = out.transfer;
232   color_metadata->range = out.range;
233   return Error::NONE;
234 }
colorMetadataToDataspace(ColorMetaData color_metadata,Dataspace * dataspace)235 static Error colorMetadataToDataspace(ColorMetaData color_metadata, Dataspace *dataspace) {
236   Dataspace primaries, transfer, range = Dataspace::UNKNOWN;
237 
238   switch (color_metadata.colorPrimaries) {
239     case ColorPrimaries_BT709_5:
240       primaries = Dataspace::STANDARD_BT709;
241       break;
242     // TODO(tbalacha): verify this is equivalent
243     case ColorPrimaries_BT470_6M:
244       primaries = Dataspace::STANDARD_BT470M;
245       break;
246     case ColorPrimaries_BT601_6_625:
247       primaries = Dataspace::STANDARD_BT601_625;
248       break;
249     case ColorPrimaries_BT601_6_525:
250       primaries = Dataspace::STANDARD_BT601_525;
251       break;
252     case ColorPrimaries_GenericFilm:
253       primaries = Dataspace::STANDARD_FILM;
254       break;
255     case ColorPrimaries_BT2020:
256       primaries = Dataspace::STANDARD_BT2020;
257       break;
258     case ColorPrimaries_AdobeRGB:
259       primaries = Dataspace::STANDARD_ADOBE_RGB;
260       break;
261     case ColorPrimaries_DCIP3:
262       primaries = Dataspace::STANDARD_DCI_P3;
263       break;
264     default:
265       return Error::UNSUPPORTED;
266       /*
267        ColorPrimaries_SMPTE_240M;
268        ColorPrimaries_SMPTE_ST428;
269        ColorPrimaries_EBU3213;
270       */
271   }
272 
273   switch (color_metadata.transfer) {
274     case Transfer_sRGB:
275       transfer = Dataspace::TRANSFER_SRGB;
276       break;
277     case Transfer_Gamma2_2:
278       transfer = Dataspace::TRANSFER_GAMMA2_2;
279       break;
280     case Transfer_Gamma2_8:
281       transfer = Dataspace::TRANSFER_GAMMA2_8;
282       break;
283     case Transfer_SMPTE_170M:
284       transfer = Dataspace::TRANSFER_SMPTE_170M;
285       break;
286     case Transfer_Linear:
287       transfer = Dataspace::TRANSFER_LINEAR;
288       break;
289     case Transfer_HLG:
290       transfer = Dataspace::TRANSFER_HLG;
291       break;
292     default:
293       return Error::UNSUPPORTED;
294       /*
295       Transfer_SMPTE_240M
296       Transfer_Log
297       Transfer_Log_Sqrt
298       Transfer_XvYCC
299       Transfer_BT1361
300       Transfer_sYCC
301       Transfer_BT2020_2_1
302       Transfer_BT2020_2_2
303       Transfer_SMPTE_ST2084
304       Transfer_ST_428
305       */
306   }
307 
308   switch (color_metadata.range) {
309     case Range_Full:
310       range = Dataspace::RANGE_FULL;
311       break;
312     case Range_Limited:
313       range = Dataspace::RANGE_LIMITED;
314       break;
315     case Range_Extended:
316       range = Dataspace::RANGE_EXTENDED;
317       break;
318     default:
319       return Error::UNSUPPORTED;
320   }
321 
322   *dataspace = (Dataspace)((uint32_t)primaries | (uint32_t)transfer | (uint32_t)range);
323   return Error::NONE;
324 }
325 
getComponentSizeAndOffset(int32_t format,PlaneLayoutComponent & comp)326 static Error getComponentSizeAndOffset(int32_t format, PlaneLayoutComponent &comp) {
327   switch (format) {
328     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RGBA_8888):
329     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RGBX_8888):
330     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RGB_888):
331       comp.sizeInBits = 8;
332       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
333         comp.offsetInBits = 0;
334       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
335         comp.offsetInBits = 8;
336       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
337         comp.offsetInBits = 16;
338       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_A.value &&
339                  format != HAL_PIXEL_FORMAT_RGB_888) {
340         comp.offsetInBits = 24;
341       } else {
342         return Error::BAD_VALUE;
343       }
344       break;
345     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RGB_565):
346       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
347         comp.offsetInBits = 0;
348         comp.sizeInBits = 5;
349       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
350         comp.offsetInBits = 5;
351         comp.sizeInBits = 6;
352       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
353         comp.offsetInBits = 11;
354         comp.sizeInBits = 5;
355       } else {
356         return Error::BAD_VALUE;
357       }
358       break;
359     case static_cast<int32_t>(HAL_PIXEL_FORMAT_BGR_565):
360       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
361         comp.offsetInBits = 11;
362         comp.sizeInBits = 5;
363       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
364         comp.offsetInBits = 5;
365         comp.sizeInBits = 6;
366       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
367         comp.offsetInBits = 0;
368         comp.sizeInBits = 5;
369       } else {
370         return Error::BAD_VALUE;
371       }
372       break;
373     case static_cast<int32_t>(HAL_PIXEL_FORMAT_BGRA_8888):
374     case static_cast<int32_t>(HAL_PIXEL_FORMAT_BGRX_8888):
375     case static_cast<int32_t>(HAL_PIXEL_FORMAT_BGR_888):
376       comp.sizeInBits = 8;
377       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
378         comp.offsetInBits = 16;
379       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
380         comp.offsetInBits = 8;
381       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
382         comp.offsetInBits = 0;
383       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_A.value &&
384                  format != HAL_PIXEL_FORMAT_BGR_888) {
385         comp.offsetInBits = 24;
386       } else {
387         return Error::BAD_VALUE;
388       }
389       break;
390     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RGBA_5551):
391       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
392         comp.sizeInBits = 5;
393         comp.offsetInBits = 0;
394       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
395         comp.sizeInBits = 5;
396         comp.offsetInBits = 5;
397       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
398         comp.sizeInBits = 5;
399         comp.offsetInBits = 10;
400       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_A.value) {
401         comp.sizeInBits = 1;
402         comp.offsetInBits = 15;
403       } else {
404         return Error::BAD_VALUE;
405       }
406       break;
407     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RGBA_4444):
408       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
409         comp.sizeInBits = 4;
410         comp.offsetInBits = 0;
411       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
412         comp.sizeInBits = 4;
413         comp.offsetInBits = 4;
414       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
415         comp.sizeInBits = 4;
416         comp.offsetInBits = 8;
417       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_A.value) {
418         comp.sizeInBits = 4;
419         comp.offsetInBits = 12;
420       } else {
421         return Error::BAD_VALUE;
422       }
423       break;
424     case static_cast<int32_t>(HAL_PIXEL_FORMAT_R_8):
425     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RG_88):
426       comp.sizeInBits = 8;
427       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
428         comp.offsetInBits = 0;
429       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value &&
430                  format != HAL_PIXEL_FORMAT_R_8) {
431         comp.offsetInBits = 8;
432       } else {
433         return Error::BAD_VALUE;
434       }
435       break;
436     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RGBA_1010102):
437     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RGBX_1010102):
438       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
439         comp.sizeInBits = 10;
440         comp.offsetInBits = 0;
441       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
442         comp.sizeInBits = 10;
443         comp.offsetInBits = 10;
444       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
445         comp.sizeInBits = 10;
446         comp.offsetInBits = 20;
447       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_A.value) {
448         comp.sizeInBits = 2;
449         comp.offsetInBits = 30;
450       } else {
451         return Error::BAD_VALUE;
452       }
453       break;
454     case static_cast<int32_t>(HAL_PIXEL_FORMAT_ARGB_2101010):
455     case static_cast<int32_t>(HAL_PIXEL_FORMAT_XRGB_2101010):
456       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
457         comp.sizeInBits = 10;
458         comp.offsetInBits = 2;
459       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
460         comp.sizeInBits = 10;
461         comp.offsetInBits = 12;
462       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
463         comp.sizeInBits = 10;
464         comp.offsetInBits = 22;
465       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_A.value) {
466         comp.sizeInBits = 2;
467         comp.offsetInBits = 0;
468       } else {
469         return Error::BAD_VALUE;
470       }
471       break;
472     case static_cast<int32_t>(HAL_PIXEL_FORMAT_BGRA_1010102):
473     case static_cast<int32_t>(HAL_PIXEL_FORMAT_BGRX_1010102):
474       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
475         comp.sizeInBits = 10;
476         comp.offsetInBits = 20;
477       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
478         comp.sizeInBits = 10;
479         comp.offsetInBits = 10;
480       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
481         comp.sizeInBits = 10;
482         comp.offsetInBits = 0;
483       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_A.value) {
484         comp.sizeInBits = 2;
485         comp.offsetInBits = 30;
486       } else {
487         return Error::BAD_VALUE;
488       }
489       break;
490     case static_cast<int32_t>(HAL_PIXEL_FORMAT_ABGR_2101010):
491     case static_cast<int32_t>(HAL_PIXEL_FORMAT_XBGR_2101010):
492       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
493         comp.sizeInBits = 10;
494         comp.offsetInBits = 22;
495       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
496         comp.sizeInBits = 10;
497         comp.offsetInBits = 12;
498       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
499         comp.sizeInBits = 10;
500         comp.offsetInBits = 2;
501       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_A.value) {
502         comp.sizeInBits = 2;
503         comp.offsetInBits = 0;
504       } else {
505         return Error::BAD_VALUE;
506       }
507       break;
508     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RGBA_FP16):
509       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_R.value) {
510         comp.sizeInBits = 16;
511         comp.offsetInBits = 0;
512       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_G.value) {
513         comp.sizeInBits = 16;
514         comp.offsetInBits = 16;
515       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_B.value) {
516         comp.sizeInBits = 16;
517         comp.offsetInBits = 32;
518       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_A.value) {
519         comp.sizeInBits = 16;
520         comp.offsetInBits = 48;
521       } else {
522         return Error::BAD_VALUE;
523       }
524       break;
525     case static_cast<int32_t>(HAL_PIXEL_FORMAT_YCbCr_420_SP):
526     case static_cast<int32_t>(HAL_PIXEL_FORMAT_YCbCr_422_SP):
527     case static_cast<int32_t>(HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS):
528     case static_cast<int32_t>(HAL_PIXEL_FORMAT_NV12_ENCODEABLE):
529       comp.sizeInBits = 8;
530       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_Y.value ||
531           comp.type.value == android::gralloc4::PlaneLayoutComponentType_CB.value) {
532         comp.offsetInBits = 0;
533       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_CR.value) {
534         comp.offsetInBits = 8;
535       } else {
536         return Error::BAD_VALUE;
537       }
538       break;
539     case static_cast<int32_t>(HAL_PIXEL_FORMAT_YCrCb_420_SP):
540     case static_cast<int32_t>(HAL_PIXEL_FORMAT_YCrCb_422_SP):
541     case static_cast<int32_t>(HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO):
542     case static_cast<int32_t>(HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS):
543     case static_cast<int32_t>(HAL_PIXEL_FORMAT_NV21_ZSL):
544       comp.sizeInBits = 8;
545       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_Y.value ||
546           comp.type.value == android::gralloc4::PlaneLayoutComponentType_CR.value) {
547         comp.offsetInBits = 0;
548       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_CB.value) {
549         comp.offsetInBits = 8;
550       } else {
551         return Error::BAD_VALUE;
552       }
553       break;
554     case static_cast<int32_t>(HAL_PIXEL_FORMAT_Y16):
555       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_Y.value) {
556         comp.offsetInBits = 0;
557         comp.sizeInBits = 16;
558       } else {
559         return Error::BAD_VALUE;
560       }
561       break;
562     case static_cast<int32_t>(HAL_PIXEL_FORMAT_YV12):
563       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_Y.value ||
564           comp.type.value == android::gralloc4::PlaneLayoutComponentType_CB.value ||
565           comp.type.value == android::gralloc4::PlaneLayoutComponentType_CR.value) {
566         comp.offsetInBits = 0;
567         comp.sizeInBits = 8;
568       } else {
569         return Error::BAD_VALUE;
570       }
571       break;
572     case static_cast<int32_t>(HAL_PIXEL_FORMAT_Y8):
573       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_Y.value) {
574         comp.offsetInBits = 0;
575         comp.sizeInBits = 8;
576       } else {
577         return Error::BAD_VALUE;
578       }
579       break;
580     case static_cast<int32_t>(HAL_PIXEL_FORMAT_YCbCr_420_P010):
581     case static_cast<int32_t>(HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS):
582       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_Y.value ||
583           comp.type.value == android::gralloc4::PlaneLayoutComponentType_CB.value) {
584         comp.offsetInBits = 6;
585         comp.sizeInBits = 10;
586       } else if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_CR.value) {
587         comp.offsetInBits = 22;
588         comp.sizeInBits = 10;
589       } else {
590         return Error::BAD_VALUE;
591       }
592       break;
593 
594     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RAW16):
595       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_RAW.value) {
596         comp.offsetInBits = 0;
597         comp.sizeInBits = 16;
598       } else {
599         return Error::BAD_VALUE;
600       }
601       break;
602     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RAW12):
603     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RAW10):
604     case static_cast<int32_t>(HAL_PIXEL_FORMAT_BLOB):
605       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_RAW.value) {
606         comp.offsetInBits = 0;
607         comp.sizeInBits = -1;
608       } else {
609         return Error::BAD_VALUE;
610       }
611       break;
612     case static_cast<int32_t>(HAL_PIXEL_FORMAT_RAW8):
613       if (comp.type.value == android::gralloc4::PlaneLayoutComponentType_RAW.value) {
614         comp.offsetInBits = 0;
615         comp.sizeInBits = 8;
616       } else {
617         return Error::BAD_VALUE;
618       }
619       break;
620     default:
621       ALOGE("Offset and size in bits unknown for format %d", format);
622       return Error::UNSUPPORTED;
623   }
624   return Error::NONE;
625 }
626 
grallocToStandardPlaneLayoutComponentType(uint32_t in,std::vector<PlaneLayoutComponent> * components,int32_t format)627 static void grallocToStandardPlaneLayoutComponentType(uint32_t in,
628                                                       std::vector<PlaneLayoutComponent> *components,
629                                                       int32_t format) {
630   PlaneLayoutComponent comp;
631   comp.offsetInBits = -1;
632   comp.sizeInBits = -1;
633 
634   if (in & PLANE_COMPONENT_Y) {
635     comp.type = android::gralloc4::PlaneLayoutComponentType_Y;
636     if (getComponentSizeAndOffset(format, comp) == Error::NONE)
637       components->push_back(comp);
638   }
639 
640   if (in & PLANE_COMPONENT_Cb) {
641     comp.type = android::gralloc4::PlaneLayoutComponentType_CB;
642     if (getComponentSizeAndOffset(format, comp) == Error::NONE)
643       components->push_back(comp);
644   }
645 
646   if (in & PLANE_COMPONENT_Cr) {
647     comp.type = android::gralloc4::PlaneLayoutComponentType_CR;
648     if (getComponentSizeAndOffset(format, comp) == Error::NONE)
649       components->push_back(comp);
650   }
651 
652   if (in & PLANE_COMPONENT_R) {
653     comp.type = android::gralloc4::PlaneLayoutComponentType_R;
654     if (getComponentSizeAndOffset(format, comp) == Error::NONE)
655       components->push_back(comp);
656   }
657 
658   if (in & PLANE_COMPONENT_G) {
659     comp.type = android::gralloc4::PlaneLayoutComponentType_G;
660     if (getComponentSizeAndOffset(format, comp) == Error::NONE)
661       components->push_back(comp);
662   }
663 
664   if (in & PLANE_COMPONENT_B) {
665     comp.type = android::gralloc4::PlaneLayoutComponentType_B;
666     if (getComponentSizeAndOffset(format, comp) == Error::NONE)
667       components->push_back(comp);
668   }
669 
670   if (in & PLANE_COMPONENT_A) {
671     comp.type = android::gralloc4::PlaneLayoutComponentType_A;
672     if (getComponentSizeAndOffset(format, comp) == Error::NONE)
673       components->push_back(comp);
674   }
675 
676   if (in & PLANE_COMPONENT_RAW) {
677     comp.type = android::gralloc4::PlaneLayoutComponentType_RAW;
678     if (getComponentSizeAndOffset(format, comp) == Error::NONE)
679       components->push_back(comp);
680   }
681 
682   if (in & PLANE_COMPONENT_META) {
683     comp.type = qtigralloc::PlaneLayoutComponentType_Meta;
684     components->push_back(comp);
685   }
686 }
687 
getFormatLayout(private_handle_t * handle,std::vector<PlaneLayout> * out)688 static Error getFormatLayout(private_handle_t *handle, std::vector<PlaneLayout> *out) {
689   std::vector<PlaneLayout> plane_info;
690   int plane_count = 0;
691   BufferInfo info(handle->unaligned_width, handle->unaligned_height, handle->format, handle->usage);
692 
693   gralloc::PlaneLayoutInfo plane_layout[8] = {};
694   if (gralloc::IsYuvFormat(handle->format)) {
695     gralloc::GetYUVPlaneInfo(info, handle->format, handle->width, handle->height, handle->flags,
696                              &plane_count, plane_layout);
697   } else if (gralloc::IsUncompressedRGBFormat(handle->format) ||
698              gralloc::IsCompressedRGBFormat(handle->format)) {
699     gralloc::GetRGBPlaneInfo(info, handle->format, handle->width, handle->height, handle->flags,
700                              &plane_count, plane_layout);
701   } else {
702     return Error::BAD_BUFFER;
703   }
704   plane_info.resize(plane_count);
705   for (int i = 0; i < plane_count; i++) {
706     std::vector<PlaneLayoutComponent> components;
707     grallocToStandardPlaneLayoutComponentType(plane_layout[i].component, &plane_info[i].components,
708                                               handle->format);
709     plane_info[i].horizontalSubsampling = (1ull << plane_layout[i].h_subsampling);
710     plane_info[i].verticalSubsampling = (1ull << plane_layout[i].v_subsampling);
711     plane_info[i].offsetInBytes = static_cast<int64_t>(plane_layout[i].offset);
712     plane_info[i].sampleIncrementInBits = static_cast<int64_t>(plane_layout[i].step * 8);
713     plane_info[i].strideInBytes = static_cast<int64_t>(plane_layout[i].stride_bytes);
714     plane_info[i].totalSizeInBytes = static_cast<int64_t>(plane_layout[i].size);
715     plane_info[i].widthInSamples = handle->unaligned_width >> plane_layout[i].h_subsampling;
716     plane_info[i].heightInSamples = handle->unaligned_height >> plane_layout[i].v_subsampling;
717   }
718   *out = plane_info;
719   return Error::NONE;
720 }
721 
BufferManager()722 BufferManager::BufferManager() : next_id_(0) {
723   handles_map_.clear();
724   allocator_ = new Allocator();
725   allocator_->Init();
726 }
727 
GetInstance()728 BufferManager *BufferManager::GetInstance() {
729   static BufferManager *instance = new BufferManager();
730   return instance;
731 }
732 
~BufferManager()733 BufferManager::~BufferManager() {
734   if (allocator_) {
735     delete allocator_;
736   }
737 }
738 
SetGrallocDebugProperties(gralloc::GrallocProperties props)739 void BufferManager::SetGrallocDebugProperties(gralloc::GrallocProperties props) {
740   allocator_->SetProperties(props);
741   AdrenoMemInfo::GetInstance()->AdrenoSetProperties(props);
742 }
743 
FreeBuffer(std::shared_ptr<Buffer> buf)744 Error BufferManager::FreeBuffer(std::shared_ptr<Buffer> buf) {
745   auto hnd = buf->handle;
746   ALOGD_IF(DEBUG, "FreeBuffer handle:%p", hnd);
747 
748   if (private_handle_t::validate(hnd) != 0) {
749     ALOGE("FreeBuffer: Invalid handle: %p", hnd);
750     return Error::BAD_BUFFER;
751   }
752 
753   auto meta_size = getMetaDataSize(hnd->reserved_size);
754 
755   if (allocator_->FreeBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset, hnd->fd,
756                              buf->ion_handle_main) != 0) {
757     return Error::BAD_BUFFER;
758   }
759 
760   if (allocator_->FreeBuffer(reinterpret_cast<void *>(hnd->base_metadata), meta_size,
761                              hnd->offset_metadata, hnd->fd_metadata, buf->ion_handle_meta) != 0) {
762     return Error::BAD_BUFFER;
763   }
764 
765   private_handle_t *handle = const_cast<private_handle_t *>(hnd);
766   handle->fd = -1;
767   handle->fd_metadata = -1;
768   if (!(handle->flags & private_handle_t::PRIV_FLAGS_CLIENT_ALLOCATED)) {
769     delete handle;
770   }
771   return Error::NONE;
772 }
773 
ValidateBufferSize(private_handle_t const * hnd,BufferInfo info)774 Error BufferManager::ValidateBufferSize(private_handle_t const *hnd, BufferInfo info) {
775   unsigned int size, alignedw, alignedh;
776   info.format = GetImplDefinedFormat(info.usage, info.format);
777   int ret = GetBufferSizeAndDimensions(info, &size, &alignedw, &alignedh);
778   if (ret < 0) {
779     return Error::BAD_BUFFER;
780   }
781   auto ion_fd_size = static_cast<unsigned int>(lseek(hnd->fd, 0, SEEK_END));
782   if (size != ion_fd_size) {
783     return Error::BAD_VALUE;
784   }
785   return Error::NONE;
786 }
787 
RegisterHandleLocked(const private_handle_t * hnd,int ion_handle,int ion_handle_meta)788 void BufferManager::RegisterHandleLocked(const private_handle_t *hnd, int ion_handle,
789                                          int ion_handle_meta) {
790   auto buffer = std::make_shared<Buffer>(hnd, ion_handle, ion_handle_meta);
791 
792   if (hnd->base_metadata) {
793 #ifdef METADATA_V2
794     buffer->reserved_size = hnd->reserved_size;
795     if (buffer->reserved_size > 0) {
796       buffer->reserved_region_ptr =
797           reinterpret_cast<void *>(hnd->base_metadata + sizeof(MetaData_t));
798     } else {
799       buffer->reserved_region_ptr = nullptr;
800     }
801 #else
802     buffer->reserved_region_ptr = reinterpret_cast<void *>(&(metadata->reservedRegion.data));
803     buffer->reserved_size = metadata->reservedRegion.size;
804 #endif
805   }
806 
807   handles_map_.emplace(std::make_pair(hnd, buffer));
808 }
809 
ImportHandleLocked(private_handle_t * hnd)810 Error BufferManager::ImportHandleLocked(private_handle_t *hnd) {
811   if (private_handle_t::validate(hnd) != 0) {
812     ALOGE("ImportHandleLocked: Invalid handle: %p", hnd);
813     return Error::BAD_BUFFER;
814   }
815   ALOGD_IF(DEBUG, "Importing handle:%p id: %" PRIu64, hnd, hnd->id);
816   int ion_handle = allocator_->ImportBuffer(hnd->fd);
817   if (ion_handle < 0) {
818     ALOGE("Failed to import ion buffer: hnd: %p, fd:%d, id:%" PRIu64, hnd, hnd->fd, hnd->id);
819     return Error::BAD_BUFFER;
820   }
821   int ion_handle_meta = allocator_->ImportBuffer(hnd->fd_metadata);
822   if (ion_handle_meta < 0) {
823     ALOGE("Failed to import ion metadata buffer: hnd: %p, fd:%d, id:%" PRIu64, hnd, hnd->fd,
824           hnd->id);
825     return Error::BAD_BUFFER;
826   }
827   // Initialize members that aren't transported
828   hnd->size = static_cast<unsigned int>(lseek(hnd->fd, 0, SEEK_END));
829   hnd->offset = 0;
830   hnd->offset_metadata = 0;
831   hnd->base = 0;
832   hnd->base_metadata = 0;
833   hnd->gpuaddr = 0;
834 
835   if (validateAndMap(hnd)) {
836     ALOGE("Failed to map metadata: hnd: %p, fd:%d, id:%" PRIu64, hnd, hnd->fd, hnd->id);
837     return Error::BAD_BUFFER;
838   }
839 
840   RegisterHandleLocked(hnd, ion_handle, ion_handle_meta);
841   allocated_ += hnd->size;
842   if (allocated_ >=  kAllocThreshold) {
843     kAllocThreshold += kMemoryOffset;
844     BuffersDump();
845   }
846   return Error::NONE;
847 }
848 
GetBufferFromHandleLocked(const private_handle_t * hnd)849 std::shared_ptr<BufferManager::Buffer> BufferManager::GetBufferFromHandleLocked(
850     const private_handle_t *hnd) {
851   auto it = handles_map_.find(hnd);
852   if (it != handles_map_.end()) {
853     return it->second;
854   } else {
855     return nullptr;
856   }
857 }
858 
MapBuffer(private_handle_t const * handle)859 Error BufferManager::MapBuffer(private_handle_t const *handle) {
860   private_handle_t *hnd = const_cast<private_handle_t *>(handle);
861   ALOGD_IF(DEBUG, "Map buffer handle:%p id: %" PRIu64, hnd, hnd->id);
862 
863   hnd->base = 0;
864   if (allocator_->MapBuffer(reinterpret_cast<void **>(&hnd->base), hnd->size, hnd->offset,
865                             hnd->fd) != 0) {
866     return Error::BAD_BUFFER;
867   }
868   return Error::NONE;
869 }
870 
IsBufferImported(const private_handle_t * hnd)871 Error BufferManager::IsBufferImported(const private_handle_t *hnd) {
872   std::lock_guard<std::mutex> lock(buffer_lock_);
873   auto buf = GetBufferFromHandleLocked(hnd);
874   if (buf != nullptr) {
875     return Error::NONE;
876   }
877   return Error::BAD_BUFFER;
878 }
879 
RetainBuffer(private_handle_t const * hnd)880 Error BufferManager::RetainBuffer(private_handle_t const *hnd) {
881   ALOGD_IF(DEBUG, "Retain buffer handle:%p id: %" PRIu64, hnd, hnd->id);
882   auto err = Error::NONE;
883   std::lock_guard<std::mutex> lock(buffer_lock_);
884   auto buf = GetBufferFromHandleLocked(hnd);
885   if (buf != nullptr) {
886     buf->IncRef();
887   } else {
888     private_handle_t *handle = const_cast<private_handle_t *>(hnd);
889     err = ImportHandleLocked(handle);
890   }
891   return err;
892 }
893 
ReleaseBuffer(private_handle_t const * hnd)894 Error BufferManager::ReleaseBuffer(private_handle_t const *hnd) {
895   ALOGD_IF(DEBUG, "Release buffer handle:%p", hnd);
896   std::lock_guard<std::mutex> lock(buffer_lock_);
897   auto buf = GetBufferFromHandleLocked(hnd);
898   if (buf == nullptr) {
899     ALOGE("Could not find handle: %p id: %" PRIu64, hnd, hnd->id);
900     return Error::BAD_BUFFER;
901   } else {
902     if (buf->DecRef()) {
903       handles_map_.erase(hnd);
904       // Unmap, close ion handle and close fd
905       if (allocated_ >= hnd->size) {
906         allocated_ -= hnd->size;
907       }
908       FreeBuffer(buf);
909     }
910   }
911   return Error::NONE;
912 }
913 
LockBuffer(const private_handle_t * hnd,uint64_t usage)914 Error BufferManager::LockBuffer(const private_handle_t *hnd, uint64_t usage) {
915   std::lock_guard<std::mutex> lock(buffer_lock_);
916   auto err = Error::NONE;
917   ALOGD_IF(DEBUG, "LockBuffer buffer handle:%p id: %" PRIu64, hnd, hnd->id);
918 
919   // If buffer is not meant for CPU return err
920   if (!CpuCanAccess(usage)) {
921     return Error::BAD_VALUE;
922   }
923 
924   auto buf = GetBufferFromHandleLocked(hnd);
925   if (buf == nullptr) {
926     return Error::BAD_BUFFER;
927   }
928 
929   if (hnd->base == 0) {
930     // we need to map for real
931     err = MapBuffer(hnd);
932   }
933 
934   // Invalidate if CPU reads in software and there are non-CPU
935   // writers. No need to do this for the metadata buffer as it is
936   // only read/written in software.
937 
938   // todo use handle here
939   if (err == Error::NONE && (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) &&
940       (hnd->flags & private_handle_t::PRIV_FLAGS_CACHED)) {
941     if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
942                                 buf->ion_handle_main, CACHE_INVALIDATE, hnd->fd)) {
943       return Error::BAD_BUFFER;
944     }
945   }
946 
947   // Mark the buffer to be flushed after CPU write.
948   if (err == Error::NONE && CpuCanWrite(usage)) {
949     private_handle_t *handle = const_cast<private_handle_t *>(hnd);
950     handle->flags |= private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
951   }
952 
953   return err;
954 }
955 
FlushBuffer(const private_handle_t * handle)956 Error BufferManager::FlushBuffer(const private_handle_t *handle) {
957   std::lock_guard<std::mutex> lock(buffer_lock_);
958   auto status = Error::NONE;
959 
960   private_handle_t *hnd = const_cast<private_handle_t *>(handle);
961   auto buf = GetBufferFromHandleLocked(hnd);
962   if (buf == nullptr) {
963     return Error::BAD_BUFFER;
964   }
965 
966   if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
967                               buf->ion_handle_main, CACHE_CLEAN, hnd->fd) != 0) {
968     status = Error::BAD_BUFFER;
969   }
970 
971   return status;
972 }
973 
RereadBuffer(const private_handle_t * handle)974 Error BufferManager::RereadBuffer(const private_handle_t *handle) {
975   std::lock_guard<std::mutex> lock(buffer_lock_);
976   auto status = Error::NONE;
977 
978   private_handle_t *hnd = const_cast<private_handle_t *>(handle);
979   auto buf = GetBufferFromHandleLocked(hnd);
980   if (buf == nullptr) {
981     return Error::BAD_BUFFER;
982   }
983 
984   if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
985                               buf->ion_handle_main, CACHE_INVALIDATE, hnd->fd) != 0) {
986     status = Error::BAD_BUFFER;
987   }
988 
989   return status;
990 }
991 
UnlockBuffer(const private_handle_t * handle)992 Error BufferManager::UnlockBuffer(const private_handle_t *handle) {
993   std::lock_guard<std::mutex> lock(buffer_lock_);
994   auto status = Error::NONE;
995 
996   private_handle_t *hnd = const_cast<private_handle_t *>(handle);
997   auto buf = GetBufferFromHandleLocked(hnd);
998   if (buf == nullptr) {
999     return Error::BAD_BUFFER;
1000   }
1001 
1002   if (hnd->flags & private_handle_t::PRIV_FLAGS_NEEDS_FLUSH) {
1003     if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
1004                                 buf->ion_handle_main, CACHE_CLEAN, hnd->fd) != 0) {
1005       status = Error::BAD_BUFFER;
1006     }
1007     hnd->flags &= ~private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
1008   } else {
1009     if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
1010                                 buf->ion_handle_main, CACHE_READ_DONE, hnd->fd) != 0) {
1011       status = Error::BAD_BUFFER;
1012     }
1013   }
1014 
1015   return status;
1016 }
1017 
AllocateBuffer(const BufferDescriptor & descriptor,buffer_handle_t * handle,unsigned int bufferSize,bool testAlloc)1018 Error BufferManager::AllocateBuffer(const BufferDescriptor &descriptor, buffer_handle_t *handle,
1019                                     unsigned int bufferSize, bool testAlloc) {
1020   if (!handle)
1021     return Error::BAD_BUFFER;
1022   std::lock_guard<std::mutex> buffer_lock(buffer_lock_);
1023 
1024   uint64_t usage = descriptor.GetUsage();
1025   int format = GetImplDefinedFormat(usage, descriptor.GetFormat());
1026   uint32_t layer_count = descriptor.GetLayerCount();
1027 
1028   unsigned int size;
1029   unsigned int alignedw, alignedh;
1030   int err = 0;
1031 
1032   int buffer_type = GetBufferType(format);
1033   BufferInfo info = GetBufferInfo(descriptor);
1034   info.format = format;
1035   info.layer_count = layer_count;
1036 
1037   GraphicsMetadata graphics_metadata = {};
1038   err = GetBufferSizeAndDimensions(info, &size, &alignedw, &alignedh, &graphics_metadata);
1039   if (err < 0) {
1040     return Error::BAD_DESCRIPTOR;
1041   }
1042 
1043   if (testAlloc) {
1044     if (size == 0) {
1045        return Error::NO_RESOURCES;
1046     }
1047     return Error::NONE;
1048   }
1049 
1050   size = (bufferSize >= size) ? bufferSize : size;
1051   uint64_t flags = 0;
1052   auto page_size = UINT(getpagesize());
1053   AllocData data;
1054   data.align = GetDataAlignment(format, usage);
1055   data.size = size;
1056   data.handle = (uintptr_t)handle;
1057   data.uncached = UseUncached(format, usage);
1058 
1059   // Allocate buffer memory
1060   err = allocator_->AllocateMem(&data, usage, format);
1061   if (err) {
1062     ALOGE("gralloc failed to allocate err=%s format %d size %d WxH %dx%d usage %" PRIu64,
1063           strerror(-err), format, size, alignedw, alignedh, usage);
1064     return Error::NO_RESOURCES;
1065   }
1066 
1067   // Allocate memory for MetaData
1068   AllocData e_data;
1069   e_data.size = static_cast<unsigned int>(getMetaDataSize(descriptor.GetReservedSize()));
1070   e_data.handle = data.handle;
1071   e_data.align = page_size;
1072 
1073   err = allocator_->AllocateMem(&e_data, 0, 0);
1074   if (err) {
1075     ALOGE("gralloc failed to allocate metadata error=%s", strerror(-err));
1076     return Error::NO_RESOURCES;
1077   }
1078 
1079   flags = GetHandleFlags(format, usage);
1080   flags |= data.alloc_type;
1081 
1082   // Create handle
1083   private_handle_t *hnd = new private_handle_t(
1084       data.fd, e_data.fd, INT(flags), INT(alignedw), INT(alignedh), descriptor.GetWidth(),
1085       descriptor.GetHeight(), format, buffer_type, data.size, usage);
1086 
1087   hnd->reserved_size = descriptor.GetReservedSize();
1088   hnd->id = ++next_id_;
1089   hnd->base = 0;
1090   hnd->base_metadata = 0;
1091   hnd->layer_count = layer_count;
1092 
1093   bool use_adreno_for_size = CanUseAdrenoForSize(buffer_type, usage);
1094   if (use_adreno_for_size) {
1095     setMetaDataAndUnmap(hnd, SET_GRAPHICS_METADATA, reinterpret_cast<void *>(&graphics_metadata));
1096   }
1097 
1098   auto error = validateAndMap(hnd);
1099 
1100   if (error != 0) {
1101     ALOGE("validateAndMap failed");
1102     return Error::BAD_BUFFER;
1103   }
1104   auto metadata = reinterpret_cast<MetaData_t *>(hnd->base_metadata);
1105   auto nameLength = std::min(descriptor.GetName().size(), size_t(MAX_NAME_LEN - 1));
1106   nameLength = descriptor.GetName().copy(metadata->name, nameLength);
1107   metadata->name[nameLength] = '\0';
1108 
1109 #ifdef METADATA_V2
1110   metadata->reservedSize = descriptor.GetReservedSize();
1111 #else
1112   metadata->reservedRegion.size =
1113       std::min(descriptor.GetReservedSize(), (uint64_t)RESERVED_REGION_SIZE);
1114 #endif
1115   metadata->crop.top = 0;
1116   metadata->crop.left = 0;
1117   metadata->crop.right = hnd->width;
1118   metadata->crop.bottom = hnd->height;
1119 
1120   unmapAndReset(hnd);
1121 
1122   *handle = hnd;
1123 
1124   RegisterHandleLocked(hnd, data.ion_handle, e_data.ion_handle);
1125   ALOGD_IF(DEBUG, "Allocated buffer handle: %p id: %" PRIu64, hnd, hnd->id);
1126   if (DEBUG) {
1127     private_handle_t::Dump(hnd);
1128   }
1129   return Error::NONE;
1130 }
1131 
BuffersDump()1132 void BufferManager:: BuffersDump() {
1133   char timeStamp[32];
1134   char hms[32];
1135   uint64_t millis;
1136   struct timeval tv;
1137   struct tm ptm;
1138 
1139   gettimeofday(&tv, NULL);
1140   localtime_r(&tv.tv_sec, &ptm);
1141   strftime (hms, sizeof (hms), "%H:%M:%S", &ptm);
1142   millis = tv.tv_usec / 1000;
1143   snprintf(timeStamp, sizeof(timeStamp), "Timestamp: %s.%03" PRIu64, hms, millis);
1144 
1145   std::fstream fs;
1146   fs.open(file_dump_.kDumpFile, std::ios::app);
1147   if (!fs) {
1148     return;
1149   }
1150   fs << "============================" << std::endl;
1151   fs << timeStamp << std::endl;
1152   fs << "Total layers = " << handles_map_.size() << std::endl;
1153   uint64_t totalAllocationSize = 0;
1154   for (auto it : handles_map_) {
1155     auto buf = it.second;
1156     auto hnd = buf->handle;
1157     auto metadata = reinterpret_cast<MetaData_t *>(hnd->base_metadata);
1158     fs  << std::setw(80) << "Client:" << (metadata ? metadata->name: "No name");
1159     fs  << std::setw(20) << "WxH:" << std::setw(4) << hnd->width << " x "
1160         << std::setw(4) << hnd->height;
1161     fs  << std::setw(20) << "Size: " << std::setw(9) << hnd->size <<  std::endl;
1162     totalAllocationSize += hnd->size;
1163   }
1164   fs << "Total allocation  = " << totalAllocationSize/1024 << "KiB" << std::endl;
1165   file_dump_.position = fs.tellp();
1166   if (file_dump_.position > (20 * 1024 * 1024)) {
1167     file_dump_.position = 0;
1168   }
1169   fs.close();
1170 }
1171 
Dump(std::ostringstream * os)1172 Error BufferManager::Dump(std::ostringstream *os) {
1173   std::lock_guard<std::mutex> buffer_lock(buffer_lock_);
1174   for (auto it : handles_map_) {
1175     auto buf = it.second;
1176     auto hnd = buf->handle;
1177     *os << "handle id: " << std::setw(4) << hnd->id;
1178     *os << " fd: " << std::setw(3) << hnd->fd;
1179     *os << " fd_meta: " << std::setw(3) << hnd->fd_metadata;
1180     *os << " wxh: " << std::setw(4) << hnd->width << " x " << std::setw(4) << hnd->height;
1181     *os << " uwxuh: " << std::setw(4) << hnd->unaligned_width << " x ";
1182     *os << std::setw(4) << hnd->unaligned_height;
1183     *os << " size: " << std::setw(9) << hnd->size;
1184     *os << std::hex << std::setfill('0');
1185     *os << " priv_flags: "
1186         << "0x" << std::setw(8) << hnd->flags;
1187     *os << " usage: "
1188         << "0x" << std::setw(8) << hnd->usage;
1189     // TODO(user): get format string from qdutils
1190     *os << " format: "
1191         << "0x" << std::setw(8) << hnd->format;
1192     *os << std::dec << std::setfill(' ') << std::endl;
1193   }
1194   return Error::NONE;
1195 }
1196 
1197 // Get list of private handles in handles_map_
GetAllHandles(std::vector<const private_handle_t * > * out_handle_list)1198 Error BufferManager::GetAllHandles(std::vector<const private_handle_t *> *out_handle_list) {
1199   std::lock_guard<std::mutex> lock(buffer_lock_);
1200   if (handles_map_.empty()) {
1201     return Error::NO_RESOURCES;
1202   }
1203   out_handle_list->reserve(handles_map_.size());
1204   for (auto handle : handles_map_) {
1205     out_handle_list->push_back(handle.first);
1206   }
1207   return Error::NONE;
1208 }
1209 
GetReservedRegion(private_handle_t * handle,void ** reserved_region,uint64_t * reserved_region_size)1210 Error BufferManager::GetReservedRegion(private_handle_t *handle, void **reserved_region,
1211                                        uint64_t *reserved_region_size) {
1212   std::lock_guard<std::mutex> lock(buffer_lock_);
1213   if (!handle)
1214     return Error::BAD_BUFFER;
1215 
1216   auto buf = GetBufferFromHandleLocked(handle);
1217   if (buf == nullptr)
1218     return Error::BAD_BUFFER;
1219   if (!handle->base_metadata) {
1220     return Error::BAD_BUFFER;
1221   }
1222 
1223   *reserved_region = buf->reserved_region_ptr;
1224   *reserved_region_size = buf->reserved_size;
1225 
1226   return Error::NONE;
1227 }
1228 
GetMetadata(private_handle_t * handle,int64_t metadatatype_value,hidl_vec<uint8_t> * out)1229 Error BufferManager::GetMetadata(private_handle_t *handle, int64_t metadatatype_value,
1230                                  hidl_vec<uint8_t> *out) {
1231   std::lock_guard<std::mutex> lock(buffer_lock_);
1232   if (!handle)
1233     return Error::BAD_BUFFER;
1234   auto buf = GetBufferFromHandleLocked(handle);
1235   if (buf == nullptr)
1236     return Error::BAD_BUFFER;
1237 
1238   if (!handle->base_metadata) {
1239     return Error::BAD_BUFFER;
1240   }
1241 
1242   auto metadata = reinterpret_cast<MetaData_t *>(handle->base_metadata);
1243 
1244   Error error = Error::NONE;
1245   switch (metadatatype_value) {
1246     case (int64_t)StandardMetadataType::BUFFER_ID:
1247       android::gralloc4::encodeBufferId((uint64_t)handle->id, out);
1248       break;
1249     case (int64_t)StandardMetadataType::NAME: {
1250       std::string name(metadata->name);
1251       android::gralloc4::encodeName(name, out);
1252       break;
1253     }
1254     case (int64_t)StandardMetadataType::WIDTH:
1255       android::gralloc4::encodeWidth((uint64_t)handle->unaligned_width, out);
1256       break;
1257     case (int64_t)StandardMetadataType::HEIGHT:
1258       android::gralloc4::encodeHeight((uint64_t)handle->unaligned_height, out);
1259       break;
1260     case (int64_t)StandardMetadataType::LAYER_COUNT:
1261       android::gralloc4::encodeLayerCount((uint64_t)handle->layer_count, out);
1262       break;
1263     case (int64_t)StandardMetadataType::PIXEL_FORMAT_REQUESTED:
1264       // TODO(tbalacha): need to return IMPLEMENTATION_DEFINED,
1265       // which wouldn't be known from private_handle_t
1266       android::gralloc4::encodePixelFormatRequested((PixelFormat)handle->format, out);
1267       break;
1268     case (int64_t)StandardMetadataType::PIXEL_FORMAT_FOURCC: {
1269       uint32_t drm_format = 0;
1270       uint64_t drm_format_modifier = 0;
1271       GetDRMFormat(handle->format, handle->flags, &drm_format, &drm_format_modifier);
1272       android::gralloc4::encodePixelFormatFourCC(drm_format, out);
1273       break;
1274     }
1275     case (int64_t)StandardMetadataType::PIXEL_FORMAT_MODIFIER: {
1276       uint32_t drm_format = 0;
1277       uint64_t drm_format_modifier = 0;
1278       GetDRMFormat(handle->format, handle->flags, &drm_format, &drm_format_modifier);
1279       android::gralloc4::encodePixelFormatModifier(drm_format_modifier, out);
1280       break;
1281     }
1282     case (int64_t)StandardMetadataType::USAGE:
1283       android::gralloc4::encodeUsage((uint64_t)handle->usage, out);
1284       break;
1285     case (int64_t)StandardMetadataType::ALLOCATION_SIZE:
1286       android::gralloc4::encodeAllocationSize((uint64_t)handle->size, out);
1287       break;
1288     case (int64_t)StandardMetadataType::PROTECTED_CONTENT: {
1289       uint64_t protected_content = (handle->flags & qtigralloc::PRIV_FLAGS_SECURE_BUFFER) ? 1 : 0;
1290       android::gralloc4::encodeProtectedContent(protected_content, out);
1291       break;
1292     }
1293     case (int64_t)StandardMetadataType::CHROMA_SITING:
1294       android::gralloc4::encodeChromaSiting(android::gralloc4::ChromaSiting_None, out);
1295       break;
1296     case (int64_t)StandardMetadataType::DATASPACE:
1297 #ifdef METADATA_V2
1298       if (metadata->isStandardMetadataSet[GET_STANDARD_METADATA_STATUS_INDEX(metadatatype_value)]) {
1299 #endif
1300         Dataspace dataspace;
1301         colorMetadataToDataspace(metadata->color, &dataspace);
1302         android::gralloc4::encodeDataspace(dataspace, out);
1303 #ifdef METADATA_V2
1304       } else {
1305         android::gralloc4::encodeDataspace(Dataspace::UNKNOWN, out);
1306       }
1307 #endif
1308       break;
1309     case (int64_t)StandardMetadataType::INTERLACED:
1310       if (metadata->interlaced > 0) {
1311         android::gralloc4::encodeInterlaced(qtigralloc::Interlaced_Qti, out);
1312       } else {
1313         android::gralloc4::encodeInterlaced(android::gralloc4::Interlaced_None, out);
1314       }
1315       break;
1316     case (int64_t)StandardMetadataType::COMPRESSION:
1317       if (handle->flags & qtigralloc::PRIV_FLAGS_UBWC_ALIGNED ||
1318           handle->flags & qtigralloc::PRIV_FLAGS_UBWC_ALIGNED_PI) {
1319         android::gralloc4::encodeCompression(qtigralloc::Compression_QtiUBWC, out);
1320       } else {
1321         android::gralloc4::encodeCompression(android::gralloc4::Compression_None, out);
1322       }
1323       break;
1324     case (int64_t)StandardMetadataType::PLANE_LAYOUTS: {
1325       std::vector<PlaneLayout> plane_layouts;
1326       getFormatLayout(handle, &plane_layouts);
1327       android::gralloc4::encodePlaneLayouts(plane_layouts, out);
1328       break;
1329     }
1330     case (int64_t)StandardMetadataType::BLEND_MODE:
1331       android::gralloc4::encodeBlendMode((BlendMode)metadata->blendMode, out);
1332       break;
1333     case (int64_t)StandardMetadataType::SMPTE2086: {
1334       if (metadata->color.masteringDisplayInfo.colorVolumeSEIEnabled) {
1335         Smpte2086 mastering_display_values;
1336         mastering_display_values.primaryRed = {
1337             static_cast<float>(metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[0][0]) /
1338                 50000.0f,
1339             static_cast<float>(metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[0][1]) /
1340                 50000.0f};
1341         mastering_display_values.primaryGreen = {
1342             static_cast<float>(metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[1][0]) /
1343                 50000.0f,
1344             static_cast<float>(metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[1][1]) /
1345                 50000.0f};
1346         mastering_display_values.primaryBlue = {
1347             static_cast<float>(metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[2][0]) /
1348                 50000.0f,
1349             static_cast<float>(metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[2][1]) /
1350                 50000.0f};
1351         mastering_display_values.whitePoint = {
1352             static_cast<float>(metadata->color.masteringDisplayInfo.primaries.whitePoint[0]) /
1353                 50000.0f,
1354             static_cast<float>(metadata->color.masteringDisplayInfo.primaries.whitePoint[1]) /
1355                 50000.0f};
1356         mastering_display_values.maxLuminance =
1357             static_cast<float>(metadata->color.masteringDisplayInfo.maxDisplayLuminance);
1358         mastering_display_values.minLuminance =
1359             static_cast<float>(metadata->color.masteringDisplayInfo.minDisplayLuminance) / 10000.0f;
1360         android::gralloc4::encodeSmpte2086(mastering_display_values, out);
1361       } else {
1362         android::gralloc4::encodeSmpte2086(std::nullopt, out);
1363       }
1364       break;
1365     }
1366     case (int64_t)StandardMetadataType::CTA861_3: {
1367       if (metadata->color.contentLightLevel.lightLevelSEIEnabled) {
1368         Cta861_3 content_light_level;
1369         content_light_level.maxContentLightLevel =
1370             static_cast<float>(metadata->color.contentLightLevel.maxContentLightLevel);
1371         content_light_level.maxFrameAverageLightLevel =
1372             static_cast<float>(metadata->color.contentLightLevel.minPicAverageLightLevel) /
1373             10000.0f;
1374         android::gralloc4::encodeCta861_3(content_light_level, out);
1375       } else {
1376         android::gralloc4::encodeCta861_3(std::nullopt, out);
1377       }
1378       break;
1379     }
1380     case (int64_t)StandardMetadataType::SMPTE2094_40: {
1381       if (metadata->color.dynamicMetaDataValid &&
1382           metadata->color.dynamicMetaDataLen <= HDR_DYNAMIC_META_DATA_SZ) {
1383         std::vector<uint8_t> dynamic_metadata_payload;
1384         dynamic_metadata_payload.resize(metadata->color.dynamicMetaDataLen);
1385         dynamic_metadata_payload.assign(
1386             metadata->color.dynamicMetaDataPayload,
1387             metadata->color.dynamicMetaDataPayload + metadata->color.dynamicMetaDataLen);
1388         android::gralloc4::encodeSmpte2094_40(dynamic_metadata_payload, out);
1389       } else {
1390         android::gralloc4::encodeSmpte2094_40(std::nullopt, out);
1391       }
1392       break;
1393     }
1394     case (int64_t)StandardMetadataType::SMPTE2094_10: {
1395       if (metadata->color.dynamicMetaDataValid &&
1396           metadata->color.dynamicMetaDataLen <= HDR_DYNAMIC_META_DATA_SZ) {
1397         std::vector<uint8_t> dynamic_metadata_payload;
1398         dynamic_metadata_payload.resize(metadata->color.dynamicMetaDataLen);
1399         dynamic_metadata_payload.assign(
1400             metadata->color.dynamicMetaDataPayload,
1401             metadata->color.dynamicMetaDataPayload + metadata->color.dynamicMetaDataLen);
1402         android::gralloc4::encodeSmpte2094_10(dynamic_metadata_payload, out);
1403       } else {
1404         android::gralloc4::encodeSmpte2094_10(std::nullopt, out);
1405       }
1406       break;
1407     }
1408     case (int64_t)StandardMetadataType::CROP: {
1409       // Crop is the same for all planes
1410       std::vector<Rect> out_crop = {{metadata->crop.left, metadata->crop.top, metadata->crop.right,
1411                                      metadata->crop.bottom}};
1412       android::gralloc4::encodeCrop(out_crop, out);
1413       break;
1414     }
1415     case QTI_VT_TIMESTAMP:
1416       android::gralloc4::encodeUint64(qtigralloc::MetadataType_VTTimestamp, metadata->vtTimeStamp,
1417                                       out);
1418       break;
1419     case QTI_COLOR_METADATA:
1420       qtigralloc::encodeColorMetadata(metadata->color, out);
1421       break;
1422     case QTI_PP_PARAM_INTERLACED:
1423       android::gralloc4::encodeInt32(qtigralloc::MetadataType_PPParamInterlaced,
1424                                      metadata->interlaced, out);
1425       break;
1426     case QTI_VIDEO_PERF_MODE:
1427       android::gralloc4::encodeUint32(qtigralloc::MetadataType_VideoPerfMode,
1428                                       metadata->isVideoPerfMode, out);
1429       break;
1430     case QTI_GRAPHICS_METADATA:
1431       qtigralloc::encodeGraphicsMetadata(metadata->graphics_metadata, out);
1432       break;
1433     case QTI_UBWC_CR_STATS_INFO:
1434       qtigralloc::encodeUBWCStats(metadata->ubwcCRStats, out);
1435       break;
1436     case QTI_REFRESH_RATE:
1437       android::gralloc4::encodeFloat(qtigralloc::MetadataType_RefreshRate, metadata->refreshrate,
1438                                      out);
1439       break;
1440     case QTI_MAP_SECURE_BUFFER:
1441       android::gralloc4::encodeInt32(qtigralloc::MetadataType_MapSecureBuffer,
1442                                      metadata->mapSecureBuffer, out);
1443       break;
1444     case QTI_LINEAR_FORMAT:
1445       android::gralloc4::encodeUint32(qtigralloc::MetadataType_LinearFormat, metadata->linearFormat,
1446                                       out);
1447       break;
1448     case QTI_SINGLE_BUFFER_MODE:
1449       android::gralloc4::encodeUint32(qtigralloc::MetadataType_SingleBufferMode,
1450                                       metadata->isSingleBufferMode, out);
1451       break;
1452     case QTI_CVP_METADATA:
1453       qtigralloc::encodeCVPMetadata(metadata->cvpMetadata, out);
1454       break;
1455     case QTI_VIDEO_HISTOGRAM_STATS:
1456       qtigralloc::encodeVideoHistogramMetadata(metadata->video_histogram_stats, out);
1457       break;
1458     case QTI_FD:
1459       android::gralloc4::encodeInt32(qtigralloc::MetadataType_FD, handle->fd, out);
1460       break;
1461     case QTI_PRIVATE_FLAGS:
1462       android::gralloc4::encodeInt32(qtigralloc::MetadataType_PrivateFlags, handle->flags, out);
1463       break;
1464     case QTI_ALIGNED_WIDTH_IN_PIXELS:
1465       android::gralloc4::encodeUint32(qtigralloc::MetadataType_AlignedWidthInPixels, handle->width,
1466                                       out);
1467       break;
1468     case QTI_ALIGNED_HEIGHT_IN_PIXELS:
1469       android::gralloc4::encodeUint32(qtigralloc::MetadataType_AlignedHeightInPixels,
1470                                       handle->height, out);
1471       break;
1472 #ifdef METADATA_V2
1473     case QTI_STANDARD_METADATA_STATUS:
1474       qtigralloc::encodeMetadataState(metadata->isStandardMetadataSet, out);
1475       break;
1476     case QTI_VENDOR_METADATA_STATUS:
1477       qtigralloc::encodeMetadataState(metadata->isVendorMetadataSet, out);
1478       break;
1479 #endif
1480 #ifdef QTI_BUFFER_TYPE
1481     case QTI_BUFFER_TYPE:
1482       android::gralloc4::encodeUint32(qtigralloc::MetadataType_BufferType, handle->buffer_type,
1483                                       out);
1484       break;
1485 #endif
1486     default:
1487       error = Error::UNSUPPORTED;
1488   }
1489 
1490   return error;
1491 }
1492 
SetMetadata(private_handle_t * handle,int64_t metadatatype_value,hidl_vec<uint8_t> in)1493 Error BufferManager::SetMetadata(private_handle_t *handle, int64_t metadatatype_value,
1494                                  hidl_vec<uint8_t> in) {
1495   std::lock_guard<std::mutex> lock(buffer_lock_);
1496   if (!handle)
1497     return Error::BAD_BUFFER;
1498 
1499   auto buf = GetBufferFromHandleLocked(handle);
1500   if (buf == nullptr)
1501     return Error::BAD_BUFFER;
1502 
1503   if (!handle->base_metadata) {
1504     return Error::BAD_BUFFER;
1505   }
1506   if (in.size() == 0) {
1507     return Error::UNSUPPORTED;
1508   }
1509 
1510   auto metadata = reinterpret_cast<MetaData_t *>(handle->base_metadata);
1511 
1512 #ifdef METADATA_V2
1513   // By default, set these to true
1514   // Reset to false for special cases below
1515   if (IS_VENDOR_METADATA_TYPE(metadatatype_value)) {
1516     metadata->isVendorMetadataSet[GET_VENDOR_METADATA_STATUS_INDEX(metadatatype_value)] = true;
1517   } else if (GET_STANDARD_METADATA_STATUS_INDEX(metadatatype_value) < METADATA_SET_SIZE) {
1518     metadata->isStandardMetadataSet[GET_STANDARD_METADATA_STATUS_INDEX(metadatatype_value)] = true;
1519   }
1520 #endif
1521 
1522   switch (metadatatype_value) {
1523     // These are constant (unchanged after allocation)
1524     case (int64_t)StandardMetadataType::BUFFER_ID:
1525     case (int64_t)StandardMetadataType::NAME:
1526     case (int64_t)StandardMetadataType::WIDTH:
1527     case (int64_t)StandardMetadataType::HEIGHT:
1528     case (int64_t)StandardMetadataType::LAYER_COUNT:
1529     case (int64_t)StandardMetadataType::PIXEL_FORMAT_REQUESTED:
1530     case (int64_t)StandardMetadataType::USAGE:
1531       return Error::BAD_VALUE;
1532     case (int64_t)StandardMetadataType::PIXEL_FORMAT_FOURCC:
1533     case (int64_t)StandardMetadataType::PIXEL_FORMAT_MODIFIER:
1534     case (int64_t)StandardMetadataType::PROTECTED_CONTENT:
1535     case (int64_t)StandardMetadataType::ALLOCATION_SIZE:
1536     case (int64_t)StandardMetadataType::PLANE_LAYOUTS:
1537     case (int64_t)StandardMetadataType::CHROMA_SITING:
1538     case (int64_t)StandardMetadataType::INTERLACED:
1539     case (int64_t)StandardMetadataType::COMPRESSION:
1540     case QTI_FD:
1541     case QTI_PRIVATE_FLAGS:
1542     case QTI_ALIGNED_WIDTH_IN_PIXELS:
1543     case QTI_ALIGNED_HEIGHT_IN_PIXELS:
1544       return Error::UNSUPPORTED;
1545     case (int64_t)StandardMetadataType::DATASPACE:
1546       Dataspace dataspace;
1547       if (android::gralloc4::decodeDataspace(in, &dataspace)) {
1548         return Error::UNSUPPORTED;
1549       }
1550       dataspaceToColorMetadata(dataspace, &metadata->color);
1551       break;
1552     case (int64_t)StandardMetadataType::BLEND_MODE:
1553       BlendMode mode;
1554       android::gralloc4::decodeBlendMode(in, &mode);
1555       metadata->blendMode = (int32_t)mode;
1556       break;
1557     case (int64_t)StandardMetadataType::SMPTE2086: {
1558       std::optional<Smpte2086> mastering_display_values;
1559       if (android::gralloc4::decodeSmpte2086(in, &mastering_display_values)) {
1560         return Error::UNSUPPORTED;
1561       }
1562       if (mastering_display_values != std::nullopt) {
1563         metadata->color.masteringDisplayInfo.colorVolumeSEIEnabled = true;
1564 
1565         metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[0][0] =
1566             static_cast<uint32_t>(mastering_display_values->primaryRed.x * 50000.0f);
1567         metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[0][1] =
1568             static_cast<uint32_t>(mastering_display_values->primaryRed.y * 50000.0f);
1569 
1570         metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[1][0] =
1571             static_cast<uint32_t>(mastering_display_values->primaryGreen.x * 50000.0f);
1572         metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[1][1] =
1573             static_cast<uint32_t>(mastering_display_values->primaryGreen.y * 50000.0f);
1574 
1575         metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[2][0] =
1576             static_cast<uint32_t>(mastering_display_values->primaryBlue.x * 50000.0f);
1577         metadata->color.masteringDisplayInfo.primaries.rgbPrimaries[2][1] =
1578             static_cast<uint32_t>(mastering_display_values->primaryBlue.y * 50000.0f);
1579 
1580         metadata->color.masteringDisplayInfo.primaries.whitePoint[0] =
1581             static_cast<uint32_t>(mastering_display_values->whitePoint.x * 50000.0f);
1582         metadata->color.masteringDisplayInfo.primaries.whitePoint[1] =
1583             static_cast<uint32_t>(mastering_display_values->whitePoint.y * 50000.0f);
1584 
1585         metadata->color.masteringDisplayInfo.maxDisplayLuminance =
1586             static_cast<uint32_t>(mastering_display_values->maxLuminance);
1587         metadata->color.masteringDisplayInfo.minDisplayLuminance =
1588             static_cast<uint32_t>(mastering_display_values->minLuminance * 10000.0f);
1589       } else {
1590 #ifdef METADATA_V2
1591         metadata->isStandardMetadataSet[GET_STANDARD_METADATA_STATUS_INDEX(metadatatype_value)] =
1592             false;
1593 #endif
1594         metadata->color.masteringDisplayInfo.colorVolumeSEIEnabled = false;
1595       }
1596       break;
1597     }
1598     case (int64_t)StandardMetadataType::CTA861_3: {
1599       std::optional<Cta861_3> content_light_level;
1600       if (android::gralloc4::decodeCta861_3(in, &content_light_level)) {
1601         return Error::UNSUPPORTED;
1602       }
1603       if (content_light_level != std::nullopt) {
1604         metadata->color.contentLightLevel.lightLevelSEIEnabled = true;
1605         metadata->color.contentLightLevel.maxContentLightLevel =
1606             static_cast<uint32_t>(content_light_level->maxContentLightLevel);
1607         metadata->color.contentLightLevel.minPicAverageLightLevel =
1608             static_cast<uint32_t>(content_light_level->maxFrameAverageLightLevel * 10000.0f);
1609       } else {
1610 #ifdef METADATA_V2
1611         metadata->isStandardMetadataSet[GET_STANDARD_METADATA_STATUS_INDEX(metadatatype_value)] =
1612             false;
1613 #endif
1614         metadata->color.contentLightLevel.lightLevelSEIEnabled = false;
1615       }
1616       break;
1617     }
1618     case (int64_t)StandardMetadataType::SMPTE2094_40: {
1619       std::optional<std::vector<uint8_t>> dynamic_metadata_payload;
1620       if (android::gralloc4::decodeSmpte2094_40(in, &dynamic_metadata_payload)) {
1621         return Error::UNSUPPORTED;
1622       }
1623       if (dynamic_metadata_payload != std::nullopt) {
1624         if (dynamic_metadata_payload->size() > HDR_DYNAMIC_META_DATA_SZ ||
1625             dynamic_metadata_payload->size() == 0)
1626           return Error::BAD_VALUE;
1627 
1628         metadata->color.dynamicMetaDataLen = dynamic_metadata_payload->size();
1629         std::copy(dynamic_metadata_payload->begin(), dynamic_metadata_payload->end(),
1630                   metadata->color.dynamicMetaDataPayload);
1631         metadata->color.dynamicMetaDataValid = true;
1632       } else {
1633         // Reset metadata by passing in std::nullopt
1634 #ifdef METADATA_V2
1635         metadata->isStandardMetadataSet[GET_STANDARD_METADATA_STATUS_INDEX(metadatatype_value)] =
1636             false;
1637 #endif
1638         metadata->color.dynamicMetaDataValid = false;
1639       }
1640       break;
1641     }
1642     case (int64_t)StandardMetadataType::SMPTE2094_10: {
1643       std::optional<std::vector<uint8_t>> dynamic_metadata_payload;
1644       android::gralloc4::decodeSmpte2094_10(in, &dynamic_metadata_payload);
1645       if (dynamic_metadata_payload != std::nullopt) {
1646         if (dynamic_metadata_payload->size() > HDR_DYNAMIC_META_DATA_SZ)
1647           return Error::BAD_VALUE;
1648 
1649         metadata->color.dynamicMetaDataLen = static_cast<uint32_t>(dynamic_metadata_payload->size());
1650         std::copy(dynamic_metadata_payload->begin(), dynamic_metadata_payload->end(),
1651                   metadata->color.dynamicMetaDataPayload);
1652         metadata->color.dynamicMetaDataValid = true;
1653       } else {
1654         // Reset metadata by passing in std::nullopt
1655 #ifdef METADATA_V2
1656         metadata->isStandardMetadataSet[GET_STANDARD_METADATA_STATUS_INDEX(metadatatype_value)] =
1657             false;
1658 #endif
1659         metadata->color.dynamicMetaDataValid = false;
1660       }
1661       break;
1662     }
1663     case (int64_t)StandardMetadataType::CROP: {
1664       std::vector<Rect> in_crop;
1665       if (android::gralloc4::decodeCrop(in, &in_crop)) {
1666         return Error::UNSUPPORTED;
1667       }
1668 
1669       if (in_crop.size() != 1) {
1670         return Error::UNSUPPORTED;
1671       }
1672 
1673       metadata->crop.left = in_crop[0].left;
1674       metadata->crop.top = in_crop[0].top;
1675       metadata->crop.right = in_crop[0].right;
1676       metadata->crop.bottom = in_crop[0].bottom;
1677       break;
1678     }
1679     case QTI_VT_TIMESTAMP:
1680       if (android::gralloc4::decodeUint64(qtigralloc::MetadataType_VTTimestamp, in,
1681                                       &metadata->vtTimeStamp)) {
1682         return Error::UNSUPPORTED;
1683       }
1684       break;
1685     case QTI_COLOR_METADATA:
1686       ColorMetaData color;
1687       if (qtigralloc::decodeColorMetadata(in, &color) != IMapper_4_0_Error::NONE) {
1688         return Error::UNSUPPORTED;
1689       }
1690       metadata->color = color;
1691       break;
1692     case QTI_PP_PARAM_INTERLACED:
1693       if (android::gralloc4::decodeInt32(qtigralloc::MetadataType_PPParamInterlaced, in,
1694                                      &metadata->interlaced)) {
1695         return Error::UNSUPPORTED;
1696       }
1697       break;
1698     case QTI_VIDEO_PERF_MODE:
1699       if (android::gralloc4::decodeUint32(qtigralloc::MetadataType_VideoPerfMode, in,
1700                                       &metadata->isVideoPerfMode)) {
1701         return Error::UNSUPPORTED;
1702       }
1703       break;
1704     case QTI_GRAPHICS_METADATA:
1705       if (qtigralloc::decodeGraphicsMetadata(in, &metadata->graphics_metadata) !=
1706                                        IMapper_4_0_Error::NONE) {
1707         return Error::UNSUPPORTED;
1708       }
1709       break;
1710     case QTI_UBWC_CR_STATS_INFO:
1711       if (qtigralloc::decodeUBWCStats(in, &metadata->ubwcCRStats[0]) != IMapper_4_0_Error::NONE) {
1712         return Error::UNSUPPORTED;
1713       }
1714       break;
1715     case QTI_REFRESH_RATE:
1716       if (android::gralloc4::decodeFloat(qtigralloc::MetadataType_RefreshRate, in,
1717                                      &metadata->refreshrate)) {
1718         return Error::UNSUPPORTED;
1719       }
1720       break;
1721     case QTI_MAP_SECURE_BUFFER:
1722       if (android::gralloc4::decodeInt32(qtigralloc::MetadataType_MapSecureBuffer, in,
1723                                      &metadata->mapSecureBuffer)) {
1724         return Error::UNSUPPORTED;
1725       }
1726       break;
1727     case QTI_LINEAR_FORMAT:
1728       if (android::gralloc4::decodeUint32(qtigralloc::MetadataType_LinearFormat, in,
1729                                       &metadata->linearFormat)) {
1730         return Error::UNSUPPORTED;
1731       }
1732       break;
1733     case QTI_SINGLE_BUFFER_MODE:
1734       if (android::gralloc4::decodeUint32(qtigralloc::MetadataType_SingleBufferMode, in,
1735                                       &metadata->isSingleBufferMode)) {
1736         return Error::UNSUPPORTED;
1737       }
1738       break;
1739     case QTI_CVP_METADATA:
1740       if (qtigralloc::decodeCVPMetadata(in, &metadata->cvpMetadata) != IMapper_4_0_Error::NONE) {
1741         return Error::UNSUPPORTED;
1742       }
1743       break;
1744     case QTI_VIDEO_HISTOGRAM_STATS:
1745       if (qtigralloc::decodeVideoHistogramMetadata(in, &metadata->video_histogram_stats) !=
1746                                       IMapper_4_0_Error::NONE) {
1747         return Error::UNSUPPORTED;
1748       }
1749       break;
1750     default:
1751 #ifdef METADATA_V2
1752       if (IS_VENDOR_METADATA_TYPE(metadatatype_value)) {
1753         metadata->isVendorMetadataSet[GET_VENDOR_METADATA_STATUS_INDEX(metadatatype_value)] = false;
1754       } else if (GET_STANDARD_METADATA_STATUS_INDEX(metadatatype_value) < METADATA_SET_SIZE) {
1755         metadata->isStandardMetadataSet[GET_STANDARD_METADATA_STATUS_INDEX(metadatatype_value)] =
1756             false;
1757       }
1758 #endif
1759       return Error::BAD_VALUE;
1760   }
1761 
1762   return Error::NONE;
1763 }
1764 
1765 }  //  namespace gralloc
1766