1 /*
2  * Copyright 2011, The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 // #define LOG_NDEBUG 0
18 #define LOG_TAG "AndroidMediaUtils"
19 
20 #include <utils/Log.h>
21 #include "android_media_Utils.h"
22 
23 #include <media/stagefright/foundation/ADebug.h>
24 #include <media/stagefright/foundation/ABuffer.h>
25 #include <media/stagefright/foundation/AMessage.h>
26 
27 #include <nativehelper/ScopedLocalRef.h>
28 
29 #define ALIGN(x, mask) ( ((x) + (mask) - 1) & ~((mask) - 1) )
30 
31 namespace android {
32 
AssetStream(SkStream * stream)33 AssetStream::AssetStream(SkStream* stream)
34     : mStream(stream), mPosition(0) {
35 }
36 
~AssetStream()37 AssetStream::~AssetStream() {
38 }
39 
GetData(const size_t offset,const size_t length,std::uint8_t * data)40 piex::Error AssetStream::GetData(
41         const size_t offset, const size_t length, std::uint8_t* data) {
42     // Seek first.
43     if (mPosition != offset) {
44         if (!mStream->seek(offset)) {
45             return piex::Error::kFail;
46         }
47     }
48 
49     // Read bytes.
50     size_t size = mStream->read((void*)data, length);
51     mPosition = offset + size;
52 
53     return size == length ? piex::Error::kOk : piex::Error::kFail;
54 }
55 
BufferedStream(SkStream * stream)56 BufferedStream::BufferedStream(SkStream* stream)
57     : mStream(stream) {
58 }
59 
~BufferedStream()60 BufferedStream::~BufferedStream() {
61 }
62 
GetData(const size_t offset,const size_t length,std::uint8_t * data)63 piex::Error BufferedStream::GetData(
64         const size_t offset, const size_t length, std::uint8_t* data) {
65     // Seek first.
66     if (offset + length > mStreamBuffer.bytesWritten()) {
67         size_t sizeToRead = offset + length - mStreamBuffer.bytesWritten();
68         if (sizeToRead <= kMinSizeToRead) {
69             sizeToRead = kMinSizeToRead;
70         }
71 
72         void* tempBuffer = malloc(sizeToRead);
73         if (tempBuffer == NULL) {
74           return piex::Error::kFail;
75         }
76 
77         size_t bytesRead = mStream->read(tempBuffer, sizeToRead);
78         if (bytesRead != sizeToRead) {
79             free(tempBuffer);
80             return piex::Error::kFail;
81         }
82         mStreamBuffer.write(tempBuffer, bytesRead);
83         free(tempBuffer);
84     }
85 
86     // Read bytes.
87     if (mStreamBuffer.read((void*)data, offset, length)) {
88         return piex::Error::kOk;
89     } else {
90         return piex::Error::kFail;
91     }
92 }
93 
FileStream(const int fd)94 FileStream::FileStream(const int fd)
95     : mPosition(0) {
96     mFile = fdopen(fd, "r");
97     if (mFile == NULL) {
98         return;
99     }
100 }
101 
FileStream(const String8 filename)102 FileStream::FileStream(const String8 filename)
103     : mPosition(0) {
104     mFile = fopen(filename.string(), "r");
105     if (mFile == NULL) {
106         return;
107     }
108 }
109 
~FileStream()110 FileStream::~FileStream() {
111     if (mFile != NULL) {
112         fclose(mFile);
113         mFile = NULL;
114     }
115 }
116 
GetData(const size_t offset,const size_t length,std::uint8_t * data)117 piex::Error FileStream::GetData(
118         const size_t offset, const size_t length, std::uint8_t* data) {
119     if (mFile == NULL) {
120         return piex::Error::kFail;
121     }
122 
123     // Seek first.
124     if (mPosition != offset) {
125         fseek(mFile, offset, SEEK_SET);
126     }
127 
128     // Read bytes.
129     size_t size = fread((void*)data, sizeof(std::uint8_t), length, mFile);
130     mPosition += size;
131 
132     // Handle errors and verify the size.
133     if (ferror(mFile) || size != length) {
134         ALOGV("GetData read failed: (offset: %zu, length: %zu)", offset, length);
135         return piex::Error::kFail;
136     }
137     return piex::Error::kOk;
138 }
139 
exists() const140 bool FileStream::exists() const {
141     return mFile != NULL;
142 }
143 
GetExifFromRawImage(piex::StreamInterface * stream,const String8 & filename,piex::PreviewImageData & image_data)144 bool GetExifFromRawImage(
145         piex::StreamInterface* stream, const String8& filename,
146         piex::PreviewImageData& image_data) {
147     // Reset the PreviewImageData to its default.
148     image_data = piex::PreviewImageData();
149 
150     if (!piex::IsRaw(stream)) {
151         // Format not supported.
152         ALOGV("Format not supported: %s", filename.string());
153         return false;
154     }
155 
156     piex::Error err = piex::GetPreviewImageData(stream, &image_data);
157 
158     if (err != piex::Error::kOk) {
159         // The input data seems to be broken.
160         ALOGV("Raw image not detected: %s (piex error code: %d)", filename.string(), (int32_t)err);
161         return false;
162     }
163 
164     return true;
165 }
166 
ConvertKeyValueArraysToKeyedVector(JNIEnv * env,jobjectArray keys,jobjectArray values,KeyedVector<String8,String8> * keyedVector)167 bool ConvertKeyValueArraysToKeyedVector(
168         JNIEnv *env, jobjectArray keys, jobjectArray values,
169         KeyedVector<String8, String8>* keyedVector) {
170 
171     int nKeyValuePairs = 0;
172     bool failed = false;
173     if (keys != NULL && values != NULL) {
174         nKeyValuePairs = env->GetArrayLength(keys);
175         failed = (nKeyValuePairs != env->GetArrayLength(values));
176     }
177 
178     if (!failed) {
179         failed = ((keys != NULL && values == NULL) ||
180                   (keys == NULL && values != NULL));
181     }
182 
183     if (failed) {
184         ALOGE("keys and values arrays have different length");
185         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
186         return false;
187     }
188 
189     for (int i = 0; i < nKeyValuePairs; ++i) {
190         // No need to check on the ArrayIndexOutOfBoundsException, since
191         // it won't happen here.
192         jstring key = (jstring) env->GetObjectArrayElement(keys, i);
193         jstring value = (jstring) env->GetObjectArrayElement(values, i);
194 
195         const char* keyStr = env->GetStringUTFChars(key, NULL);
196         if (!keyStr) {  // OutOfMemoryError
197             return false;
198         }
199 
200         const char* valueStr = env->GetStringUTFChars(value, NULL);
201         if (!valueStr) {  // OutOfMemoryError
202             env->ReleaseStringUTFChars(key, keyStr);
203             return false;
204         }
205 
206         keyedVector->add(String8(keyStr), String8(valueStr));
207 
208         env->ReleaseStringUTFChars(key, keyStr);
209         env->ReleaseStringUTFChars(value, valueStr);
210         env->DeleteLocalRef(key);
211         env->DeleteLocalRef(value);
212     }
213     return true;
214 }
215 
makeIntegerObject(JNIEnv * env,int32_t value)216 static jobject makeIntegerObject(JNIEnv *env, int32_t value) {
217     ScopedLocalRef<jclass> clazz(env, env->FindClass("java/lang/Integer"));
218     CHECK(clazz.get() != NULL);
219 
220     jmethodID integerConstructID =
221         env->GetMethodID(clazz.get(), "<init>", "(I)V");
222     CHECK(integerConstructID != NULL);
223 
224     return env->NewObject(clazz.get(), integerConstructID, value);
225 }
226 
makeLongObject(JNIEnv * env,int64_t value)227 static jobject makeLongObject(JNIEnv *env, int64_t value) {
228     ScopedLocalRef<jclass> clazz(env, env->FindClass("java/lang/Long"));
229     CHECK(clazz.get() != NULL);
230 
231     jmethodID longConstructID = env->GetMethodID(clazz.get(), "<init>", "(J)V");
232     CHECK(longConstructID != NULL);
233 
234     return env->NewObject(clazz.get(), longConstructID, value);
235 }
236 
makeFloatObject(JNIEnv * env,float value)237 static jobject makeFloatObject(JNIEnv *env, float value) {
238     ScopedLocalRef<jclass> clazz(env, env->FindClass("java/lang/Float"));
239     CHECK(clazz.get() != NULL);
240 
241     jmethodID floatConstructID =
242         env->GetMethodID(clazz.get(), "<init>", "(F)V");
243     CHECK(floatConstructID != NULL);
244 
245     return env->NewObject(clazz.get(), floatConstructID, value);
246 }
247 
makeByteBufferObject(JNIEnv * env,const void * data,size_t size)248 static jobject makeByteBufferObject(
249         JNIEnv *env, const void *data, size_t size) {
250     jbyteArray byteArrayObj = env->NewByteArray(size);
251     env->SetByteArrayRegion(byteArrayObj, 0, size, (const jbyte *)data);
252 
253     ScopedLocalRef<jclass> clazz(env, env->FindClass("java/nio/ByteBuffer"));
254     CHECK(clazz.get() != NULL);
255 
256     jmethodID byteBufWrapID =
257         env->GetStaticMethodID(
258                 clazz.get(), "wrap", "([B)Ljava/nio/ByteBuffer;");
259     CHECK(byteBufWrapID != NULL);
260 
261     jobject byteBufObj = env->CallStaticObjectMethod(
262             clazz.get(), byteBufWrapID, byteArrayObj);
263 
264     env->DeleteLocalRef(byteArrayObj); byteArrayObj = NULL;
265 
266     return byteBufObj;
267 }
268 
SetMapInt32(JNIEnv * env,jobject hashMapObj,jmethodID hashMapPutID,const char * key,int32_t value)269 static void SetMapInt32(
270         JNIEnv *env, jobject hashMapObj, jmethodID hashMapPutID,
271         const char *key, int32_t value) {
272     jstring keyObj = env->NewStringUTF(key);
273     jobject valueObj = makeIntegerObject(env, value);
274 
275     env->CallObjectMethod(hashMapObj, hashMapPutID, keyObj, valueObj);
276 
277     env->DeleteLocalRef(valueObj); valueObj = NULL;
278     env->DeleteLocalRef(keyObj); keyObj = NULL;
279 }
280 
ConvertMessageToMap(JNIEnv * env,const sp<AMessage> & msg,jobject * map)281 status_t ConvertMessageToMap(
282         JNIEnv *env, const sp<AMessage> &msg, jobject *map) {
283     ScopedLocalRef<jclass> hashMapClazz(
284             env, env->FindClass("java/util/HashMap"));
285 
286     if (hashMapClazz.get() == NULL) {
287         return -EINVAL;
288     }
289 
290     jmethodID hashMapConstructID =
291         env->GetMethodID(hashMapClazz.get(), "<init>", "()V");
292 
293     if (hashMapConstructID == NULL) {
294         return -EINVAL;
295     }
296 
297     jmethodID hashMapPutID =
298         env->GetMethodID(
299                 hashMapClazz.get(),
300                 "put",
301                 "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
302 
303     if (hashMapPutID == NULL) {
304         return -EINVAL;
305     }
306 
307     jobject hashMap = env->NewObject(hashMapClazz.get(), hashMapConstructID);
308 
309     for (size_t i = 0; i < msg->countEntries(); ++i) {
310         AMessage::Type valueType;
311         const char *key = msg->getEntryNameAt(i, &valueType);
312 
313         if (!strncmp(key, "android._", 9)) {
314             // don't expose private keys (starting with android._)
315             continue;
316         }
317 
318         jobject valueObj = NULL;
319 
320         switch (valueType) {
321             case AMessage::kTypeInt32:
322             {
323                 int32_t val;
324                 CHECK(msg->findInt32(key, &val));
325 
326                 valueObj = makeIntegerObject(env, val);
327                 break;
328             }
329 
330             case AMessage::kTypeInt64:
331             {
332                 int64_t val;
333                 CHECK(msg->findInt64(key, &val));
334 
335                 valueObj = makeLongObject(env, val);
336                 break;
337             }
338 
339             case AMessage::kTypeFloat:
340             {
341                 float val;
342                 CHECK(msg->findFloat(key, &val));
343 
344                 valueObj = makeFloatObject(env, val);
345                 break;
346             }
347 
348             case AMessage::kTypeString:
349             {
350                 AString val;
351                 CHECK(msg->findString(key, &val));
352 
353                 valueObj = env->NewStringUTF(val.c_str());
354                 break;
355             }
356 
357             case AMessage::kTypeBuffer:
358             {
359                 sp<ABuffer> buffer;
360                 CHECK(msg->findBuffer(key, &buffer));
361 
362                 valueObj = makeByteBufferObject(
363                         env, buffer->data(), buffer->size());
364                 break;
365             }
366 
367             case AMessage::kTypeRect:
368             {
369                 int32_t left, top, right, bottom;
370                 CHECK(msg->findRect(key, &left, &top, &right, &bottom));
371 
372                 SetMapInt32(
373                         env,
374                         hashMap,
375                         hashMapPutID,
376                         AStringPrintf("%s-left", key).c_str(),
377                         left);
378 
379                 SetMapInt32(
380                         env,
381                         hashMap,
382                         hashMapPutID,
383                         AStringPrintf("%s-top", key).c_str(),
384                         top);
385 
386                 SetMapInt32(
387                         env,
388                         hashMap,
389                         hashMapPutID,
390                         AStringPrintf("%s-right", key).c_str(),
391                         right);
392 
393                 SetMapInt32(
394                         env,
395                         hashMap,
396                         hashMapPutID,
397                         AStringPrintf("%s-bottom", key).c_str(),
398                         bottom);
399                 break;
400             }
401 
402             default:
403                 break;
404         }
405 
406         if (valueObj != NULL) {
407             jstring keyObj = env->NewStringUTF(key);
408 
409             env->CallObjectMethod(hashMap, hashMapPutID, keyObj, valueObj);
410 
411             env->DeleteLocalRef(keyObj); keyObj = NULL;
412             env->DeleteLocalRef(valueObj); valueObj = NULL;
413         }
414     }
415 
416     *map = hashMap;
417 
418     return OK;
419 }
420 
ConvertKeyValueArraysToMessage(JNIEnv * env,jobjectArray keys,jobjectArray values,sp<AMessage> * out)421 status_t ConvertKeyValueArraysToMessage(
422         JNIEnv *env, jobjectArray keys, jobjectArray values,
423         sp<AMessage> *out) {
424     ScopedLocalRef<jclass> stringClass(env, env->FindClass("java/lang/String"));
425     CHECK(stringClass.get() != NULL);
426     ScopedLocalRef<jclass> integerClass(env, env->FindClass("java/lang/Integer"));
427     CHECK(integerClass.get() != NULL);
428     ScopedLocalRef<jclass> longClass(env, env->FindClass("java/lang/Long"));
429     CHECK(longClass.get() != NULL);
430     ScopedLocalRef<jclass> floatClass(env, env->FindClass("java/lang/Float"));
431     CHECK(floatClass.get() != NULL);
432     ScopedLocalRef<jclass> byteBufClass(env, env->FindClass("java/nio/ByteBuffer"));
433     CHECK(byteBufClass.get() != NULL);
434 
435     sp<AMessage> msg = new AMessage;
436 
437     jsize numEntries = 0;
438 
439     if (keys != NULL) {
440         if (values == NULL) {
441             return -EINVAL;
442         }
443 
444         numEntries = env->GetArrayLength(keys);
445 
446         if (numEntries != env->GetArrayLength(values)) {
447             return -EINVAL;
448         }
449     } else if (values != NULL) {
450         return -EINVAL;
451     }
452 
453     for (jsize i = 0; i < numEntries; ++i) {
454         jobject keyObj = env->GetObjectArrayElement(keys, i);
455 
456         if (!env->IsInstanceOf(keyObj, stringClass.get())) {
457             return -EINVAL;
458         }
459 
460         const char *tmp = env->GetStringUTFChars((jstring)keyObj, NULL);
461 
462         if (tmp == NULL) {
463             return -ENOMEM;
464         }
465 
466         AString key = tmp;
467 
468         env->ReleaseStringUTFChars((jstring)keyObj, tmp);
469         tmp = NULL;
470 
471         if (key.startsWith("android._")) {
472             // don't propagate private keys (starting with android._)
473             continue;
474         }
475 
476         jobject valueObj = env->GetObjectArrayElement(values, i);
477 
478         if (env->IsInstanceOf(valueObj, stringClass.get())) {
479             const char *value = env->GetStringUTFChars((jstring)valueObj, NULL);
480 
481             if (value == NULL) {
482                 return -ENOMEM;
483             }
484 
485             msg->setString(key.c_str(), value);
486 
487             env->ReleaseStringUTFChars((jstring)valueObj, value);
488             value = NULL;
489         } else if (env->IsInstanceOf(valueObj, integerClass.get())) {
490             jmethodID intValueID =
491                 env->GetMethodID(integerClass.get(), "intValue", "()I");
492             CHECK(intValueID != NULL);
493 
494             jint value = env->CallIntMethod(valueObj, intValueID);
495 
496             msg->setInt32(key.c_str(), value);
497         } else if (env->IsInstanceOf(valueObj, longClass.get())) {
498             jmethodID longValueID =
499                 env->GetMethodID(longClass.get(), "longValue", "()J");
500             CHECK(longValueID != NULL);
501 
502             jlong value = env->CallLongMethod(valueObj, longValueID);
503 
504             msg->setInt64(key.c_str(), value);
505         } else if (env->IsInstanceOf(valueObj, floatClass.get())) {
506             jmethodID floatValueID =
507                 env->GetMethodID(floatClass.get(), "floatValue", "()F");
508             CHECK(floatValueID != NULL);
509 
510             jfloat value = env->CallFloatMethod(valueObj, floatValueID);
511 
512             msg->setFloat(key.c_str(), value);
513         } else if (env->IsInstanceOf(valueObj, byteBufClass.get())) {
514             jmethodID positionID =
515                 env->GetMethodID(byteBufClass.get(), "position", "()I");
516             CHECK(positionID != NULL);
517 
518             jmethodID limitID =
519                 env->GetMethodID(byteBufClass.get(), "limit", "()I");
520             CHECK(limitID != NULL);
521 
522             jint position = env->CallIntMethod(valueObj, positionID);
523             jint limit = env->CallIntMethod(valueObj, limitID);
524 
525             sp<ABuffer> buffer = new ABuffer(limit - position);
526 
527             void *data = env->GetDirectBufferAddress(valueObj);
528 
529             if (data != NULL) {
530                 memcpy(buffer->data(),
531                        (const uint8_t *)data + position,
532                        buffer->size());
533             } else {
534                 jmethodID arrayID =
535                     env->GetMethodID(byteBufClass.get(), "array", "()[B");
536                 CHECK(arrayID != NULL);
537 
538                 jbyteArray byteArray =
539                     (jbyteArray)env->CallObjectMethod(valueObj, arrayID);
540                 CHECK(byteArray != NULL);
541 
542                 env->GetByteArrayRegion(
543                         byteArray,
544                         position,
545                         buffer->size(),
546                         (jbyte *)buffer->data());
547 
548                 env->DeleteLocalRef(byteArray); byteArray = NULL;
549             }
550 
551             msg->setBuffer(key.c_str(), buffer);
552         }
553     }
554 
555     *out = msg;
556 
557     return OK;
558 }
559 
560 // -----------Utility functions used by ImageReader/Writer JNI-----------------
561 
562 enum {
563     IMAGE_MAX_NUM_PLANES = 3,
564 };
565 
usingRGBAToJpegOverride(int32_t imageFormat,int32_t containerFormat)566 bool usingRGBAToJpegOverride(int32_t imageFormat,
567         int32_t containerFormat) {
568     return containerFormat == HAL_PIXEL_FORMAT_BLOB && imageFormat == HAL_PIXEL_FORMAT_RGBA_8888;
569 }
570 
applyFormatOverrides(int32_t imageFormat,int32_t containerFormat)571 int32_t applyFormatOverrides(int32_t imageFormat, int32_t containerFormat) {
572     // Using HAL_PIXEL_FORMAT_RGBA_8888 gralloc buffers containing JPEGs to get around SW
573     // write limitations for some platforms (b/17379185).
574     if (usingRGBAToJpegOverride(imageFormat, containerFormat)) {
575         return HAL_PIXEL_FORMAT_BLOB;
576     }
577     return containerFormat;
578 }
579 
isFormatOpaque(int format)580 bool isFormatOpaque(int format) {
581     // This is the only opaque format exposed in the ImageFormat public API.
582     // Note that we do support CPU access for HAL_PIXEL_FORMAT_RAW_OPAQUE
583     // (ImageFormat#RAW_PRIVATE) so it doesn't count as opaque here.
584     return format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
585 }
586 
isPossiblyYUV(PixelFormat format)587 bool isPossiblyYUV(PixelFormat format) {
588     switch (static_cast<int>(format)) {
589         case HAL_PIXEL_FORMAT_RGBA_8888:
590         case HAL_PIXEL_FORMAT_RGBX_8888:
591         case HAL_PIXEL_FORMAT_RGB_888:
592         case HAL_PIXEL_FORMAT_RGB_565:
593         case HAL_PIXEL_FORMAT_BGRA_8888:
594         case HAL_PIXEL_FORMAT_Y8:
595         case HAL_PIXEL_FORMAT_Y16:
596         case HAL_PIXEL_FORMAT_RAW16:
597         case HAL_PIXEL_FORMAT_RAW10:
598         case HAL_PIXEL_FORMAT_RAW_OPAQUE:
599         case HAL_PIXEL_FORMAT_BLOB:
600         case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
601             return false;
602 
603         case HAL_PIXEL_FORMAT_YV12:
604         case HAL_PIXEL_FORMAT_YCbCr_420_888:
605         case HAL_PIXEL_FORMAT_YCrCb_420_SP:
606         default:
607             return true;
608     }
609 }
610 
Image_getJpegSize(LockedImage * buffer,bool usingRGBAOverride)611 uint32_t Image_getJpegSize(LockedImage* buffer, bool usingRGBAOverride) {
612     ALOGV("%s", __FUNCTION__);
613     LOG_ALWAYS_FATAL_IF(buffer == NULL, "Input buffer is NULL!!!");
614     uint32_t size = 0;
615     uint32_t width = buffer->width;
616     uint8_t* jpegBuffer = buffer->data;
617 
618     if (usingRGBAOverride) {
619         width = (buffer->width + buffer->stride * (buffer->height - 1)) * 4;
620     }
621 
622     // First check for JPEG transport header at the end of the buffer
623     uint8_t* header = jpegBuffer + (width - sizeof(struct camera3_jpeg_blob));
624     struct camera3_jpeg_blob *blob = (struct camera3_jpeg_blob*)(header);
625     if (blob->jpeg_blob_id == CAMERA3_JPEG_BLOB_ID) {
626         size = blob->jpeg_size;
627         ALOGV("%s: Jpeg size = %d", __FUNCTION__, size);
628     }
629 
630     // failed to find size, default to whole buffer
631     if (size == 0) {
632         /*
633          * This is a problem because not including the JPEG header
634          * means that in certain rare situations a regular JPEG blob
635          * will be mis-identified as having a header, in which case
636          * we will get a garbage size value.
637          */
638         ALOGW("%s: No JPEG header detected, defaulting to size=width=%d",
639                 __FUNCTION__, width);
640         size = width;
641     }
642 
643     return size;
644 }
645 
getLockedImageInfo(LockedImage * buffer,int idx,int32_t containerFormat,uint8_t ** base,uint32_t * size,int * pixelStride,int * rowStride)646 status_t getLockedImageInfo(LockedImage* buffer, int idx,
647         int32_t containerFormat, uint8_t **base, uint32_t *size, int *pixelStride, int *rowStride) {
648     ALOGV("%s", __FUNCTION__);
649     LOG_ALWAYS_FATAL_IF(buffer == NULL, "Input buffer is NULL!!!");
650     LOG_ALWAYS_FATAL_IF(base == NULL, "base is NULL!!!");
651     LOG_ALWAYS_FATAL_IF(size == NULL, "size is NULL!!!");
652     LOG_ALWAYS_FATAL_IF(pixelStride == NULL, "pixelStride is NULL!!!");
653     LOG_ALWAYS_FATAL_IF(rowStride == NULL, "rowStride is NULL!!!");
654     LOG_ALWAYS_FATAL_IF((idx >= IMAGE_MAX_NUM_PLANES) || (idx < 0), "idx (%d) is illegal", idx);
655 
656     ALOGV("%s: buffer: %p", __FUNCTION__, buffer);
657 
658     uint32_t dataSize, ySize, cSize, cStride;
659     uint32_t pStride = 0, rStride = 0;
660     uint8_t *cb, *cr;
661     uint8_t *pData = NULL;
662     int bytesPerPixel = 0;
663 
664     dataSize = ySize = cSize = cStride = 0;
665     int32_t fmt = buffer->flexFormat;
666 
667     bool usingRGBAOverride = usingRGBAToJpegOverride(fmt, containerFormat);
668     fmt = applyFormatOverrides(fmt, containerFormat);
669     switch (fmt) {
670         case HAL_PIXEL_FORMAT_YCbCr_420_888:
671             pData =
672                 (idx == 0) ?
673                     buffer->data :
674                 (idx == 1) ?
675                     buffer->dataCb :
676                 buffer->dataCr;
677             // only map until last pixel
678             if (idx == 0) {
679                 pStride = 1;
680                 rStride = buffer->stride;
681                 dataSize = buffer->stride * (buffer->height - 1) + buffer->width;
682             } else {
683                 pStride = buffer->chromaStep;
684                 rStride = buffer->chromaStride;
685                 dataSize = buffer->chromaStride * (buffer->height / 2 - 1) +
686                         buffer->chromaStep * (buffer->width / 2 - 1) + 1;
687             }
688             break;
689         // NV21
690         case HAL_PIXEL_FORMAT_YCrCb_420_SP:
691             cr = buffer->data + (buffer->stride * buffer->height);
692             cb = cr + 1;
693             // only map until last pixel
694             ySize = buffer->width * (buffer->height - 1) + buffer->width;
695             cSize = buffer->width * (buffer->height / 2 - 1) + buffer->width - 1;
696 
697             pData =
698                 (idx == 0) ?
699                     buffer->data :
700                 (idx == 1) ?
701                     cb:
702                 cr;
703 
704             dataSize = (idx == 0) ? ySize : cSize;
705             pStride = (idx == 0) ? 1 : 2;
706             rStride = buffer->width;
707             break;
708         case HAL_PIXEL_FORMAT_YV12:
709             // Y and C stride need to be 16 pixel aligned.
710             LOG_ALWAYS_FATAL_IF(buffer->stride % 16,
711                                 "Stride is not 16 pixel aligned %d", buffer->stride);
712 
713             ySize = buffer->stride * buffer->height;
714             cStride = ALIGN(buffer->stride / 2, 16);
715             cr = buffer->data + ySize;
716             cSize = cStride * buffer->height / 2;
717             cb = cr + cSize;
718 
719             pData =
720                 (idx == 0) ?
721                     buffer->data :
722                 (idx == 1) ?
723                     cb :
724                 cr;
725             dataSize = (idx == 0) ? ySize : cSize;
726             pStride = 1;
727             rStride = (idx == 0) ? buffer->stride : ALIGN(buffer->stride / 2, 16);
728             break;
729         case HAL_PIXEL_FORMAT_Y8:
730             // Single plane, 8bpp.
731             LOG_ALWAYS_FATAL_IF(idx != 0, "Wrong index: %d", idx);
732 
733             pData = buffer->data;
734             dataSize = buffer->stride * buffer->height;
735             pStride = 1;
736             rStride = buffer->stride;
737             break;
738         case HAL_PIXEL_FORMAT_Y16:
739             bytesPerPixel = 2;
740             // Single plane, 16bpp, strides are specified in pixels, not in bytes
741             LOG_ALWAYS_FATAL_IF(idx != 0, "Wrong index: %d", idx);
742 
743             pData = buffer->data;
744             dataSize = buffer->stride * buffer->height * bytesPerPixel;
745             pStride = bytesPerPixel;
746             rStride = buffer->stride * 2;
747             break;
748         case HAL_PIXEL_FORMAT_BLOB:
749             // Used for JPEG data, height must be 1, width == size, single plane.
750             LOG_ALWAYS_FATAL_IF(idx != 0, "Wrong index: %d", idx);
751             // When RGBA override is being used, buffer height will be equal to width
752             if (usingRGBAOverride) {
753                 LOG_ALWAYS_FATAL_IF(buffer->height != buffer->width,
754                         "RGBA override BLOB format buffer should have height == width");
755             } else {
756                 LOG_ALWAYS_FATAL_IF(buffer->height != 1,
757                         "BLOB format buffer should have height value 1");
758             }
759 
760 
761             pData = buffer->data;
762             dataSize = Image_getJpegSize(buffer, usingRGBAOverride);
763             pStride = 0;
764             rStride = 0;
765             break;
766         case HAL_PIXEL_FORMAT_RAW16:
767             // Single plane 16bpp bayer data.
768             bytesPerPixel = 2;
769             LOG_ALWAYS_FATAL_IF(idx != 0, "Wrong index: %d", idx);
770             pData = buffer->data;
771             dataSize = buffer->stride * buffer->height * bytesPerPixel;
772             pStride = bytesPerPixel;
773             rStride = buffer->stride * 2;
774             break;
775         case HAL_PIXEL_FORMAT_RAW_OPAQUE:
776             // Used for RAW_OPAQUE data, height must be 1, width == size, single plane.
777             LOG_ALWAYS_FATAL_IF(idx != 0, "Wrong index: %d", idx);
778             LOG_ALWAYS_FATAL_IF(buffer->height != 1,
779                     "RAW_PRIVATE should has height value one but got %d", buffer->height);
780             pData = buffer->data;
781             dataSize = buffer->width;
782             pStride = 0; // RAW OPAQUE doesn't have pixel stride
783             rStride = 0; // RAW OPAQUE doesn't have row stride
784             break;
785         case HAL_PIXEL_FORMAT_RAW10:
786             // Single plane 10bpp bayer data.
787             LOG_ALWAYS_FATAL_IF(idx != 0, "Wrong index: %d", idx);
788             LOG_ALWAYS_FATAL_IF(buffer->width % 4,
789                                 "Width is not multiple of 4 %d", buffer->width);
790             LOG_ALWAYS_FATAL_IF(buffer->height % 2,
791                                 "Height is not even %d", buffer->height);
792             LOG_ALWAYS_FATAL_IF(buffer->stride < (buffer->width * 10 / 8),
793                                 "stride (%d) should be at least %d",
794                                 buffer->stride, buffer->width * 10 / 8);
795             pData = buffer->data;
796             dataSize = buffer->stride * buffer->height;
797             pStride = 0;
798             rStride = buffer->stride;
799             break;
800         case HAL_PIXEL_FORMAT_RAW12:
801             // Single plane 10bpp bayer data.
802             LOG_ALWAYS_FATAL_IF(idx != 0, "Wrong index: %d", idx);
803             LOG_ALWAYS_FATAL_IF(buffer->width % 4,
804                                 "Width is not multiple of 4 %d", buffer->width);
805             LOG_ALWAYS_FATAL_IF(buffer->height % 2,
806                                 "Height is not even %d", buffer->height);
807             LOG_ALWAYS_FATAL_IF(buffer->stride < (buffer->width * 12 / 8),
808                                 "stride (%d) should be at least %d",
809                                 buffer->stride, buffer->width * 12 / 8);
810             pData = buffer->data;
811             dataSize = buffer->stride * buffer->height;
812             pStride = 0;
813             rStride = buffer->stride;
814             break;
815         case HAL_PIXEL_FORMAT_RGBA_8888:
816         case HAL_PIXEL_FORMAT_RGBX_8888:
817             // Single plane, 32bpp.
818             bytesPerPixel = 4;
819             LOG_ALWAYS_FATAL_IF(idx != 0, "Wrong index: %d", idx);
820             pData = buffer->data;
821             dataSize = buffer->stride * buffer->height * bytesPerPixel;
822             pStride = bytesPerPixel;
823             rStride = buffer->stride * 4;
824             break;
825         case HAL_PIXEL_FORMAT_RGB_565:
826             // Single plane, 16bpp.
827             bytesPerPixel = 2;
828             LOG_ALWAYS_FATAL_IF(idx != 0, "Wrong index: %d", idx);
829             pData = buffer->data;
830             dataSize = buffer->stride * buffer->height * bytesPerPixel;
831             pStride = bytesPerPixel;
832             rStride = buffer->stride * 2;
833             break;
834         case HAL_PIXEL_FORMAT_RGB_888:
835             // Single plane, 24bpp.
836             bytesPerPixel = 3;
837             LOG_ALWAYS_FATAL_IF(idx != 0, "Wrong index: %d", idx);
838             pData = buffer->data;
839             dataSize = buffer->stride * buffer->height * bytesPerPixel;
840             pStride = bytesPerPixel;
841             rStride = buffer->stride * 3;
842             break;
843         default:
844             return BAD_VALUE;
845     }
846 
847     *base = pData;
848     *size = dataSize;
849     *pixelStride = pStride;
850     *rowStride = rStride;
851 
852     return OK;
853 }
854 
lockImageFromBuffer(sp<GraphicBuffer> buffer,uint32_t inUsage,const Rect & rect,int fenceFd,LockedImage * outputImage)855 status_t lockImageFromBuffer(sp<GraphicBuffer> buffer, uint32_t inUsage,
856         const Rect& rect, int fenceFd, LockedImage* outputImage) {
857     ALOGV("%s: Try to lock the GraphicBuffer", __FUNCTION__);
858 
859     if (buffer == nullptr || outputImage == nullptr) {
860         ALOGE("Input BufferItem or output LockedImage is NULL!");
861         return BAD_VALUE;
862     }
863     if (isFormatOpaque(buffer->getPixelFormat())) {
864         ALOGE("Opaque format buffer is not lockable!");
865         return BAD_VALUE;
866     }
867 
868     void* pData = NULL;
869     android_ycbcr ycbcr = android_ycbcr();
870     status_t res;
871     int format = buffer->getPixelFormat();
872     int flexFormat = format;
873     if (isPossiblyYUV(format)) {
874         res = buffer->lockAsyncYCbCr(inUsage, rect, &ycbcr, fenceFd);
875         pData = ycbcr.y;
876         flexFormat = HAL_PIXEL_FORMAT_YCbCr_420_888;
877     }
878 
879     // lockAsyncYCbCr for YUV is unsuccessful.
880     if (pData == NULL) {
881         res = buffer->lockAsync(inUsage, rect, &pData, fenceFd);
882         if (res != OK) {
883             ALOGE("Lock buffer failed!");
884             return res;
885         }
886     }
887 
888     outputImage->data = reinterpret_cast<uint8_t*>(pData);
889     outputImage->width = buffer->getWidth();
890     outputImage->height = buffer->getHeight();
891     outputImage->format = format;
892     outputImage->flexFormat = flexFormat;
893     outputImage->stride =
894             (ycbcr.y != NULL) ? static_cast<uint32_t>(ycbcr.ystride) : buffer->getStride();
895 
896     outputImage->dataCb = reinterpret_cast<uint8_t*>(ycbcr.cb);
897     outputImage->dataCr = reinterpret_cast<uint8_t*>(ycbcr.cr);
898     outputImage->chromaStride = static_cast<uint32_t>(ycbcr.cstride);
899     outputImage->chromaStep = static_cast<uint32_t>(ycbcr.chroma_step);
900     ALOGV("%s: Successfully locked the image from the GraphicBuffer", __FUNCTION__);
901     // Crop, transform, scalingMode, timestamp, and frameNumber should be set by caller,
902     // and cann't be set them here.
903     return OK;
904 }
905 
lockImageFromBuffer(BufferItem * bufferItem,uint32_t inUsage,int fenceFd,LockedImage * outputImage)906 status_t lockImageFromBuffer(BufferItem* bufferItem, uint32_t inUsage,
907         int fenceFd, LockedImage* outputImage) {
908     ALOGV("%s: Try to lock the BufferItem", __FUNCTION__);
909     if (bufferItem == nullptr || outputImage == nullptr) {
910         ALOGE("Input BufferItem or output LockedImage is NULL!");
911         return BAD_VALUE;
912     }
913 
914     status_t res = lockImageFromBuffer(bufferItem->mGraphicBuffer, inUsage, bufferItem->mCrop,
915             fenceFd, outputImage);
916     if (res != OK) {
917         ALOGE("%s: lock graphic buffer failed", __FUNCTION__);
918         return res;
919     }
920 
921     outputImage->crop        = bufferItem->mCrop;
922     outputImage->transform   = bufferItem->mTransform;
923     outputImage->scalingMode = bufferItem->mScalingMode;
924     outputImage->timestamp   = bufferItem->mTimestamp;
925     outputImage->dataSpace   = bufferItem->mDataSpace;
926     outputImage->frameNumber = bufferItem->mFrameNumber;
927     ALOGV("%s: Successfully locked the image from the BufferItem", __FUNCTION__);
928     return OK;
929 }
930 
getBufferWidth(BufferItem * buffer)931 int getBufferWidth(BufferItem* buffer) {
932     if (buffer == NULL) return -1;
933 
934     if (!buffer->mCrop.isEmpty()) {
935         return buffer->mCrop.getWidth();
936     }
937 
938     ALOGV("%s: buffer->mGraphicBuffer: %p", __FUNCTION__, buffer->mGraphicBuffer.get());
939     return buffer->mGraphicBuffer->getWidth();
940 }
941 
getBufferHeight(BufferItem * buffer)942 int getBufferHeight(BufferItem* buffer) {
943     if (buffer == NULL) return -1;
944 
945     if (!buffer->mCrop.isEmpty()) {
946         return buffer->mCrop.getHeight();
947     }
948 
949     ALOGV("%s: buffer->mGraphicBuffer: %p", __FUNCTION__, buffer->mGraphicBuffer.get());
950     return buffer->mGraphicBuffer->getHeight();
951 }
952 
953 }  // namespace android
954 
955