Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 90393001 authored by Sally Qi's avatar Sally Qi
Browse files

Fix cts flaky issue on adt3 device. 

Relnote: This is a combination of 3 commits cherry-picked from internal
branch, including:
- part of I3f18b9d3550f88be82cde75372637a3ae528b5ec
- If70f8640e6c057fa4be910372282df764bb84341
- I58340f684b4fc9cb2578cee03ef1d65171c9eaed

Bug: 250079821
Test: android.hardware.cts.DataSpaceTest#getDataSpaceWithoutSetDataSpace on adt3 locally for 20 runs

Change-Id: I3f18b9d3550f88be82cde75372637a3ae528b5ec
Merged-In: I3f18b9d3550f88be82cde75372637a3ae528b5ec
parent a7acd5d5

media/java/android/media/ImageReader.java

+16 −38
Original line number Diff line number Diff line
@@ -277,7 +277,7 @@ public class ImageReader implements AutoCloseable { 
    }



    private void initializeImageReader(int width, int height, int imageFormat, int maxImages,

            long usage, int hardwareBufferFormat, int dataSpace, boolean useLegacyImageFormat) {

            long usage, int hardwareBufferFormat, int dataSpace) {

        if (width < 1 || height < 1) {

            throw new IllegalArgumentException(

                "The image dimensions must be positive");
@@ -306,8 +306,7 @@ public class ImageReader implements AutoCloseable { 
        // complex, and 1 buffer is enough for the VM to treat the ImageReader as being of some

        // size.

        mEstimatedNativeAllocBytes = ImageUtils.getEstimatedNativeAllocBytes(

            width, height, useLegacyImageFormat ? imageFormat : hardwareBufferFormat,

            /*buffer count*/ 1);

                width, height, imageFormat, /*buffer count*/ 1);

        VMRuntime.getRuntime().registerNativeAllocation(mEstimatedNativeAllocBytes);

    }
@@ -322,28 +321,26 @@ public class ImageReader implements AutoCloseable { 
        // retrieve hal Format and hal dataspace from imageFormat

        mHardwareBufferFormat = PublicFormatUtils.getHalFormat(mFormat);

        mDataSpace = PublicFormatUtils.getHalDataspace(mFormat);

        mUseLegacyImageFormat = true;

        mNumPlanes = ImageUtils.getNumPlanesForFormat(mFormat);



        initializeImageReader(width, height, imageFormat, maxImages, usage, mHardwareBufferFormat,

                mDataSpace, mUseLegacyImageFormat);

                mDataSpace);

    }



    private ImageReader(int width, int height, int maxImages, long usage,

            MultiResolutionImageReader parent, int hardwareBufferFormat, int dataSpace) {

        mWidth = width;

        mHeight = height;

        mFormat = ImageFormat.UNKNOWN; // set default image format value as UNKNOWN

        mUsage = usage;

        mMaxImages = maxImages;

        mParent = parent;

        mHardwareBufferFormat = hardwareBufferFormat;

        mDataSpace = dataSpace;

        mUseLegacyImageFormat = false;

        mNumPlanes = ImageUtils.getNumPlanesForHardwareBufferFormat(mHardwareBufferFormat);

        mFormat = PublicFormatUtils.getPublicFormat(hardwareBufferFormat, dataSpace);



        initializeImageReader(width, height, mFormat, maxImages, usage, hardwareBufferFormat,

                dataSpace, mUseLegacyImageFormat);

                dataSpace);

    }



    /**
@@ -537,12 +534,7 @@ public class ImageReader implements AutoCloseable { 
     * @hide

     */

    public Image acquireNextImageNoThrowISE() {

        SurfaceImage si;

        if (mUseLegacyImageFormat) {

            si = new SurfaceImage(mFormat);

        } else {

            si = new SurfaceImage(mHardwareBufferFormat, mDataSpace);

        }

        SurfaceImage si = new SurfaceImage(mFormat);

        return acquireNextSurfaceImage(si) == ACQUIRE_SUCCESS ? si : null;

    }
@@ -565,7 +557,7 @@ public class ImageReader implements AutoCloseable { 
            // A null image will eventually be returned if ImageReader is already closed.

            int status = ACQUIRE_NO_BUFS;

            if (mIsReaderValid) {

                status = nativeImageSetup(si, mUseLegacyImageFormat);

                status = nativeImageSetup(si);

            }



            switch (status) {
@@ -619,11 +611,7 @@ public class ImageReader implements AutoCloseable { 
        // Initialize with reader format, but can be overwritten by native if the image

        // format is different from the reader format.

        SurfaceImage si;

        if (mUseLegacyImageFormat) {

        si = new SurfaceImage(mFormat);

        } else {

            si = new SurfaceImage(mHardwareBufferFormat, mDataSpace);

        }

        int status = acquireNextSurfaceImage(si);



        switch (status) {
@@ -1094,8 +1082,6 @@ public class ImageReader implements AutoCloseable { 


    private final @NamedDataSpace int mDataSpace;



    private final boolean mUseLegacyImageFormat;



    /**

     * This field is used by native code, do not access or modify.

     */
@@ -1136,12 +1122,6 @@ public class ImageReader implements AutoCloseable { 
            mDataSpace = ImageReader.this.mDataSpace;

        }



        SurfaceImage(int hardwareBufferFormat, int dataSpace) {

            mHardwareBufferFormat = hardwareBufferFormat;

            mDataSpace = dataSpace;

            mFormat = PublicFormatUtils.getPublicFormat(mHardwareBufferFormat, mDataSpace);

        }



        @Override

        public void close() {

            synchronized (this.mCloseLock) {
@@ -1159,12 +1139,10 @@ public class ImageReader implements AutoCloseable { 
            // update mFormat only if ImageReader is initialized by factory pattern.

            // if using builder pattern, mFormat has been updated upon initialization.

            // no need update here.

            if (ImageReader.this.mUseLegacyImageFormat) {

            int readerFormat = ImageReader.this.getImageFormat();

            // Assume opaque reader always produce opaque images.

            mFormat = (readerFormat == ImageFormat.PRIVATE) ? readerFormat :

                nativeGetFormat(readerFormat);

            }

            return mFormat;

        }
@@ -1263,8 +1241,8 @@ public class ImageReader implements AutoCloseable { 
            throwISEIfImageIsInvalid();



            if (mPlanes == null) {

                mPlanes = nativeCreatePlanes(ImageReader.this.mNumPlanes, ImageReader.this.mFormat,

                        ImageReader.this.mUsage);

                mPlanes = nativeCreatePlanes(ImageReader.this.mNumPlanes,

                        ImageReader.this.mHardwareBufferFormat, ImageReader.this.mUsage);

            }

            // Shallow copy is fine.

            return mPlanes.clone();
@@ -1395,7 +1373,7 @@ public class ImageReader implements AutoCloseable { 
        private AtomicBoolean mIsDetached = new AtomicBoolean(false);



        private synchronized native SurfacePlane[] nativeCreatePlanes(int numPlanes,

                int readerFormat, long readerUsage);

                int hardwareBufferFormat, long readerUsage);

        private synchronized native int nativeGetWidth();

        private synchronized native int nativeGetHeight();

        private synchronized native int nativeGetFormat(int readerFormat);
@@ -1418,7 +1396,7 @@ public class ImageReader implements AutoCloseable { 
     * @see #ACQUIRE_NO_BUFS

     * @see #ACQUIRE_MAX_IMAGES

     */

    private synchronized native int nativeImageSetup(Image i, boolean legacyValidateImageFormat);

    private synchronized native int nativeImageSetup(Image i);



    /**

     * @hide

media/java/android/media/ImageWriter.java

+27 −48
Original line number Diff line number Diff line
@@ -29,7 +29,6 @@ import android.hardware.DataSpace.NamedDataSpace; 
import android.hardware.HardwareBuffer;

import android.hardware.HardwareBuffer.Usage;

import android.hardware.SyncFence;

import android.hardware.camera2.params.StreamConfigurationMap;

import android.hardware.camera2.utils.SurfaceUtils;

import android.os.Handler;

import android.os.Looper;
@@ -249,7 +248,7 @@ public class ImageWriter implements AutoCloseable { 
    }



    private void initializeImageWriter(Surface surface, int maxImages,

            boolean useSurfaceImageFormatInfo, boolean useLegacyImageFormat, int imageFormat,

            boolean useSurfaceImageFormatInfo, int imageFormat,

            int hardwareBufferFormat, int dataSpace, int width, int height, long usage) {

        if (surface == null || maxImages < 1) {

            throw new IllegalArgumentException("Illegal input argument: surface " + surface
@@ -265,32 +264,11 @@ public class ImageWriter implements AutoCloseable { 
        if (useSurfaceImageFormatInfo) {

            // nativeInit internally overrides UNKNOWN format. So does surface format query after

            // nativeInit and before getEstimatedNativeAllocBytes().

            imageFormat = SurfaceUtils.getSurfaceFormat(surface);

            mHardwareBufferFormat = PublicFormatUtils.getHalFormat(imageFormat);

            mDataSpace = PublicFormatUtils.getHalDataspace(imageFormat);

            mHardwareBufferFormat = hardwareBufferFormat = SurfaceUtils.getSurfaceFormat(surface);

            mDataSpace = dataSpace = SurfaceUtils.getSurfaceDataspace(surface);

            imageFormat = PublicFormatUtils.getPublicFormat(hardwareBufferFormat, dataSpace);

        }



        // Several public formats use the same native HAL_PIXEL_FORMAT_BLOB. The native

        // allocation estimation sequence depends on the public formats values. To avoid

        // possible errors, convert where necessary.

        if (imageFormat == StreamConfigurationMap.HAL_PIXEL_FORMAT_BLOB) {

            int surfaceDataspace = SurfaceUtils.getSurfaceDataspace(surface);

            switch (surfaceDataspace) {

                case StreamConfigurationMap.HAL_DATASPACE_DEPTH:

                    imageFormat = ImageFormat.DEPTH_POINT_CLOUD;

                    break;

                case StreamConfigurationMap.HAL_DATASPACE_DYNAMIC_DEPTH:

                    imageFormat = ImageFormat.DEPTH_JPEG;

                    break;

                case StreamConfigurationMap.HAL_DATASPACE_HEIF:

                    imageFormat = ImageFormat.HEIC;

                    break;

                default:

                    imageFormat = ImageFormat.JPEG;

            }

            mHardwareBufferFormat = PublicFormatUtils.getHalFormat(imageFormat);

            mDataSpace = PublicFormatUtils.getHalDataspace(imageFormat);

        }

        // Estimate the native buffer allocation size and register it so it gets accounted for

        // during GC. Note that this doesn't include the buffers required by the buffer queue

        // itself and the buffers requested by the producer.
@@ -301,19 +279,20 @@ public class ImageWriter implements AutoCloseable { 
        mWidth = width == -1 ? surfSize.getWidth() : width;

        mHeight = height == -1 ? surfSize.getHeight() : height;



        mEstimatedNativeAllocBytes =

            ImageUtils.getEstimatedNativeAllocBytes(mWidth, mHeight,

                useLegacyImageFormat ? imageFormat : hardwareBufferFormat, /*buffer count*/ 1);

        mEstimatedNativeAllocBytes = ImageUtils.getEstimatedNativeAllocBytes(mWidth, mHeight,

                imageFormat, /*buffer count*/ 1);

        VMRuntime.getRuntime().registerNativeAllocation(mEstimatedNativeAllocBytes);

    }



    private ImageWriter(Surface surface, int maxImages, boolean useSurfaceImageFormatInfo,

            int imageFormat, int width, int height) {

        mMaxImages = maxImages;

        if (!useSurfaceImageFormatInfo) {

            mHardwareBufferFormat = PublicFormatUtils.getHalFormat(imageFormat);

            mDataSpace = PublicFormatUtils.getHalDataspace(imageFormat);

        }



        initializeImageWriter(surface, maxImages, useSurfaceImageFormatInfo, true,

        initializeImageWriter(surface, maxImages, useSurfaceImageFormatInfo,

                imageFormat, mHardwareBufferFormat, mDataSpace, width, height, mUsage);

    }
@@ -321,10 +300,12 @@ public class ImageWriter implements AutoCloseable { 
            int imageFormat, int width, int height, long usage) {

        mMaxImages = maxImages;

        mUsage = usage;

        if (!useSurfaceImageFormatInfo) {

            mHardwareBufferFormat = PublicFormatUtils.getHalFormat(imageFormat);

            mDataSpace = PublicFormatUtils.getHalDataspace(imageFormat);

        }



        initializeImageWriter(surface, maxImages, useSurfaceImageFormatInfo, true,

        initializeImageWriter(surface, maxImages, useSurfaceImageFormatInfo,

                imageFormat, mHardwareBufferFormat, mDataSpace, width, height, usage);

    }
@@ -337,15 +318,13 @@ public class ImageWriter implements AutoCloseable { 
        // and retrieve corresponding hardwareBufferFormat and dataSpace here.

        if (useSurfaceImageFormatInfo) {

            imageFormat = ImageFormat.UNKNOWN;

            mHardwareBufferFormat = PublicFormatUtils.getHalFormat(imageFormat);

            mDataSpace = PublicFormatUtils.getHalDataspace(imageFormat);

        } else {

            imageFormat = PublicFormatUtils.getPublicFormat(hardwareBufferFormat, dataSpace);

            mHardwareBufferFormat = hardwareBufferFormat;

            mDataSpace = dataSpace;

        }



        initializeImageWriter(surface, maxImages, useSurfaceImageFormatInfo, false,

        initializeImageWriter(surface, maxImages, useSurfaceImageFormatInfo,

                imageFormat, hardwareBufferFormat, dataSpace, width, height, usage);

    }
@@ -764,13 +743,15 @@ public class ImageWriter implements AutoCloseable { 
        // need do some cleanup to make sure no orphaned

        // buffer caused leak.

        Rect crop = image.getCropRect();

        int hardwareBufferFormat = PublicFormatUtils.getHalFormat(image.getFormat());

        if (image.getNativeContext() != 0) {

            nativeAttachAndQueueImage(mNativeContext, image.getNativeContext(), image.getFormat(),

                    image.getTimestamp(), image.getDataSpace(), crop.left, crop.top, crop.right,

                    crop.bottom, image.getTransform(), image.getScalingMode());

            nativeAttachAndQueueImage(mNativeContext, image.getNativeContext(),

                    hardwareBufferFormat, image.getTimestamp(), image.getDataSpace(),

                    crop.left, crop.top, crop.right, crop.bottom, image.getTransform(),

                    image.getScalingMode());

        } else {

            GraphicBuffer gb = GraphicBuffer.createFromHardwareBuffer(image.getHardwareBuffer());

            nativeAttachAndQueueGraphicBuffer(mNativeContext, gb, image.getFormat(),

            nativeAttachAndQueueGraphicBuffer(mNativeContext, gb, hardwareBufferFormat,

                    image.getTimestamp(), image.getDataSpace(), crop.left, crop.top, crop.right,

                    crop.bottom, image.getTransform(), image.getScalingMode());

            gb.destroy();
@@ -1161,8 +1142,7 @@ public class ImageWriter implements AutoCloseable { 


            if (mPlanes == null) {

                int numPlanes = ImageUtils.getNumPlanesForFormat(getFormat());

                mPlanes = nativeCreatePlanes(numPlanes, getOwner().getFormat(),

                        getOwner().getDataSpace());

                mPlanes = nativeCreatePlanes(numPlanes, getOwner().getFormat());

            }



            return mPlanes.clone();
@@ -1270,8 +1250,7 @@ public class ImageWriter implements AutoCloseable { 
        }



        // Create the SurfacePlane object and fill the information

        private synchronized native SurfacePlane[] nativeCreatePlanes(int numPlanes, int writerFmt,

                int dataSpace);

        private synchronized native SurfacePlane[] nativeCreatePlanes(int numPlanes, int writerFmt);



        private synchronized native int nativeGetWidth();
@@ -1298,10 +1277,10 @@ public class ImageWriter implements AutoCloseable { 
            int transform, int scalingMode);



    private synchronized native int nativeAttachAndQueueImage(long nativeCtx,

            long imageNativeBuffer, int imageFormat, long timestampNs, int dataSpace,

            long imageNativeBuffer, int hardwareBufferFormat, long timestampNs, int dataSpace,

            int left, int top, int right, int bottom, int transform, int scalingMode);

    private synchronized native int nativeAttachAndQueueGraphicBuffer(long nativeCtx,

            GraphicBuffer graphicBuffer, int imageFormat, long timestampNs, int dataSpace,

            GraphicBuffer graphicBuffer, int hardwareBufferFormat, long timestampNs, int dataSpace,

            int left, int top, int right, int bottom, int transform, int scalingMode);



    private synchronized native void cancelImage(long nativeCtx, Image image);

media/jni/android_media_ImageReader.cpp

+20 −24
Original line number Diff line number Diff line
@@ -375,11 +375,11 @@ static void ImageReader_classInit(JNIEnv* env, jclass clazz) 
}



static void ImageReader_init(JNIEnv* env, jobject thiz, jobject weakThiz, jint width, jint height,

                             jint maxImages, jlong ndkUsage, jint nativeFormat, jint dataSpace) {

                             jint maxImages, jlong ndkUsage, jint nativeHalFormat, jint dataSpace) {

    status_t res;



    ALOGV("%s: width:%d, height: %d, nativeFormat: %d, maxImages:%d",

          __FUNCTION__, width, height, nativeFormat, maxImages);

    ALOGV("%s: width:%d, height: %d, nativeHalFormat: %d, maxImages:%d",

          __FUNCTION__, width, height, nativeHalFormat, maxImages);



    android_dataspace nativeDataspace = static_cast<android_dataspace>(dataSpace);
@@ -395,7 +395,7 @@ static void ImageReader_init(JNIEnv* env, jobject thiz, jobject weakThiz, jint w 
    BufferQueue::createBufferQueue(&gbProducer, &gbConsumer);

    sp<BufferItemConsumer> bufferConsumer;

    String8 consumerName = String8::format("ImageReader-%dx%df%xm%d-%d-%d",

            width, height, nativeFormat, maxImages, getpid(),

            width, height, nativeHalFormat, maxImages, getpid(),

            createProcessUniqueId());

    uint64_t consumerUsage =

            android_hardware_HardwareBuffer_convertToGrallocUsageBits(ndkUsage);
@@ -404,8 +404,8 @@ static void ImageReader_init(JNIEnv* env, jobject thiz, jobject weakThiz, jint w 
            /*controlledByApp*/true);

    if (bufferConsumer == nullptr) {

        jniThrowExceptionFmt(env, "java/lang/RuntimeException",

                "Failed to allocate native buffer consumer for format 0x%x and usage 0x%x",

                nativeFormat, consumerUsage);

                "Failed to allocate native buffer consumer for hal format 0x%x and usage 0x%x",

                nativeHalFormat, consumerUsage);

        return;

    }
@@ -419,7 +419,7 @@ static void ImageReader_init(JNIEnv* env, jobject thiz, jobject weakThiz, jint w 
    ctx->setProducer(gbProducer);

    bufferConsumer->setFrameAvailableListener(ctx);

    ImageReader_setNativeContext(env, thiz, ctx);

    ctx->setBufferFormat(nativeFormat);

    ctx->setBufferFormat(nativeHalFormat);

    ctx->setBufferDataspace(nativeDataspace);

    ctx->setBufferWidth(width);

    ctx->setBufferHeight(height);
@@ -428,14 +428,14 @@ static void ImageReader_init(JNIEnv* env, jobject thiz, jobject weakThiz, jint w 
    res = bufferConsumer->setDefaultBufferSize(width, height);

    if (res != OK) {

        jniThrowExceptionFmt(env, "java/lang/IllegalStateException",

                          "Failed to set buffer consumer default size (%dx%d) for format 0x%x",

                          width, height, nativeFormat);

                          "Failed to set buffer consumer default size (%dx%d) for Hal format 0x%x",

                          width, height, nativeHalFormat);

        return;

    }

    res = bufferConsumer->setDefaultBufferFormat(nativeFormat);

    res = bufferConsumer->setDefaultBufferFormat(nativeHalFormat);

    if (res != OK) {

        jniThrowExceptionFmt(env, "java/lang/IllegalStateException",

                          "Failed to set buffer consumer default format 0x%x", nativeFormat);

                          "Failed to set buffer consumer default Halformat 0x%x", nativeHalFormat);

        return;

    }

    res = bufferConsumer->setDefaultBufferDataSpace(nativeDataspace);
@@ -522,8 +522,7 @@ static void ImageReader_imageRelease(JNIEnv* env, jobject thiz, jobject image) 
    ALOGV("%s: Image (format: 0x%x) has been released", __FUNCTION__, ctx->getBufferFormat());

}



static jint ImageReader_imageSetup(JNIEnv* env, jobject thiz, jobject image,

                                   jboolean legacyValidateImageFormat) {

static jint ImageReader_imageSetup(JNIEnv* env, jobject thiz, jobject image) {

    ALOGV("%s:", __FUNCTION__);

    JNIImageReaderContext* ctx = ImageReader_getContext(env, thiz);

    if (ctx == NULL) {
@@ -577,29 +576,29 @@ static jint ImageReader_imageSetup(JNIEnv* env, jobject thiz, jobject image, 
        int outputWidth = getBufferWidth(buffer);

        int outputHeight = getBufferHeight(buffer);



        int imgReaderFmt = ctx->getBufferFormat();

        int imgReaderHalFmt = ctx->getBufferFormat();

        int imageReaderWidth = ctx->getBufferWidth();

        int imageReaderHeight = ctx->getBufferHeight();

        int bufferFormat = buffer->mGraphicBuffer->getPixelFormat();

        if ((bufferFormat != HAL_PIXEL_FORMAT_BLOB) && (imgReaderFmt != HAL_PIXEL_FORMAT_BLOB) &&

        if ((bufferFormat != HAL_PIXEL_FORMAT_BLOB) && (imgReaderHalFmt != HAL_PIXEL_FORMAT_BLOB) &&

                (imageReaderWidth != outputWidth || imageReaderHeight != outputHeight)) {

            ALOGV("%s: Producer buffer size: %dx%d, doesn't match ImageReader configured size: %dx%d",

                    __FUNCTION__, outputWidth, outputHeight, imageReaderWidth, imageReaderHeight);

        }

        if (legacyValidateImageFormat && imgReaderFmt != bufferFormat) {

            if (imgReaderFmt == HAL_PIXEL_FORMAT_YCbCr_420_888 &&

        if (imgReaderHalFmt != bufferFormat) {

            if (imgReaderHalFmt == HAL_PIXEL_FORMAT_YCbCr_420_888 &&

                    isPossiblyYUV(bufferFormat)) {

                // Treat formats that are compatible with flexible YUV

                // (HAL_PIXEL_FORMAT_YCbCr_420_888) as HAL_PIXEL_FORMAT_YCbCr_420_888.

                ALOGV("%s: Treat buffer format to 0x%x as HAL_PIXEL_FORMAT_YCbCr_420_888",

                        __FUNCTION__, bufferFormat);

            } else if (imgReaderFmt == HAL_PIXEL_FORMAT_YCBCR_P010 &&

            } else if (imgReaderHalFmt == HAL_PIXEL_FORMAT_YCBCR_P010 &&

                    isPossibly10BitYUV(bufferFormat)) {

                // Treat formats that are compatible with flexible 10-bit YUV

                // (HAL_PIXEL_FORMAT_YCBCR_P010) as HAL_PIXEL_FORMAT_YCBCR_P010.

                ALOGV("%s: Treat buffer format to 0x%x as HAL_PIXEL_FORMAT_YCBCR_P010",

                        __FUNCTION__, bufferFormat);

            } else if (imgReaderFmt == HAL_PIXEL_FORMAT_BLOB &&

            } else if (imgReaderHalFmt == HAL_PIXEL_FORMAT_BLOB &&

                    bufferFormat == HAL_PIXEL_FORMAT_RGBA_8888) {

                // Using HAL_PIXEL_FORMAT_RGBA_8888 Gralloc buffers containing JPEGs to get around

                // SW write limitations for (b/17379185).
@@ -842,7 +841,7 @@ static jobjectArray ImageReader_createImagePlanes(JNIEnv* env, jobject /*thiz*/, 
}



static jobjectArray Image_createSurfacePlanes(JNIEnv* env, jobject thiz,

        int numPlanes, int readerFormat, uint64_t ndkReaderUsage)

        int numPlanes, int halReaderFormat, uint64_t ndkReaderUsage)

{

    ALOGV("%s: create SurfacePlane array with size %d", __FUNCTION__, numPlanes);

    int rowStride = 0;
@@ -851,9 +850,6 @@ static jobjectArray Image_createSurfacePlanes(JNIEnv* env, jobject thiz, 
    uint32_t dataSize = 0;

    jobject byteBuffer = NULL;



    PublicFormat publicReaderFormat = static_cast<PublicFormat>(readerFormat);

    int halReaderFormat = mapPublicFormatToHalFormat(publicReaderFormat);



    if (isFormatOpaque(halReaderFormat) && numPlanes > 0) {

        String8 msg;

        msg.appendFormat("Format 0x%x is opaque, thus not writable, the number of planes (%d)"
@@ -963,7 +959,7 @@ static const JNINativeMethod gImageReaderMethods[] = { 
    {"nativeInit",             "(Ljava/lang/Object;IIIJII)V",   (void*)ImageReader_init },

    {"nativeClose",            "()V",                        (void*)ImageReader_close },

    {"nativeReleaseImage",     "(Landroid/media/Image;)V",   (void*)ImageReader_imageRelease },

    {"nativeImageSetup",       "(Landroid/media/Image;Z)I",   (void*)ImageReader_imageSetup },

    {"nativeImageSetup",       "(Landroid/media/Image;)I",   (void*)ImageReader_imageSetup },

    {"nativeGetSurface",       "()Landroid/view/Surface;",   (void*)ImageReader_getSurface },

    {"nativeDetachImage",      "(Landroid/media/Image;)I",   (void*)ImageReader_detachImage },

    {"nativeCreateImagePlanes",

media/jni/android_media_ImageWriter.cpp

+36 −23

File changed.

Preview size limit exceeded, changes collapsed.