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

Commit 60fa4fd3 authored by Chong Zhang's avatar Chong Zhang
Browse files

add a static lib of core bufferqueue logic for media 

Add a static lib consisting of only the core bufferqueue
logic, which media codec services can use wihtout pulling
the rest of the lib into the apex (and also the runtime
apex namespace). This helps to reduce both the apex size
and the runtime memory of the mediaswcodec.

bug: 128894663
test: build; libgui.so doesn't appear in the apex;
mediaswcodec service loaded correctly at boot

Change-Id: I129790ca7bcae2829b737a96c7465c8f2c5d17eb
parent bb7f8aa0

libs/gui/Android.bp

+104 −0
Original line number Diff line number Diff line
@@ -61,6 +61,7 @@ cc_library_shared { 
        "DisplayEventReceiver.cpp",

        "FrameTimestamps.cpp",

        "GLConsumer.cpp",

        "GLConsumerUtils.cpp",

        "GuiConfig.cpp",

        "HdrMetadata.cpp",

        "IDisplayEventConnection.cpp",
@@ -170,4 +171,107 @@ cc_library_shared { 
    ],

}



// Used by media codec services exclusively as a static lib for

// core bufferqueuesupport only.

cc_library_static {

    name: "libgui_bufferqueue_static",

    vendor_available: true,



    clang: true,

    cflags: [

        "-Wall",

        "-Werror",

        "-DNO_BUFFERHUB",

    ],



    cppflags: [

        "-Wextra",

        "-DDEBUG_ONLY_CODE=0",

    ],



    product_variables: {

        eng: {

            cppflags: [

                "-UDEBUG_ONLY_CODE",

                "-DDEBUG_ONLY_CODE=1",

            ],

        },

    },



    srcs: [

        "BufferItem.cpp",

        "BufferQueue.cpp",

        "BufferQueueConsumer.cpp",

        "BufferQueueCore.cpp",

        "BufferQueueProducer.cpp",

        "BufferQueueThreadState.cpp",

        "BufferSlot.cpp",

        "FrameTimestamps.cpp",

        "GLConsumerUtils.cpp",

        "HdrMetadata.cpp",

        "IConsumerListener.cpp",

        "IGraphicBufferConsumer.cpp",

        "IGraphicBufferProducer.cpp",

        "IProducerListener.cpp",

        "OccupancyTracker.cpp",

        "bufferqueue/1.0/B2HProducerListener.cpp",

        "bufferqueue/1.0/Conversion.cpp",

        "bufferqueue/1.0/H2BGraphicBufferProducer.cpp",

        "bufferqueue/1.0/H2BProducerListener.cpp",

        "bufferqueue/1.0/WProducerListener.cpp",

        "bufferqueue/2.0/B2HGraphicBufferProducer.cpp",

        "bufferqueue/2.0/B2HProducerListener.cpp",

        "bufferqueue/2.0/H2BGraphicBufferProducer.cpp",

        "bufferqueue/2.0/H2BProducerListener.cpp",

        "bufferqueue/2.0/types.cpp",

    ],



    shared_libs: [

        "android.hardware.graphics.bufferqueue@1.0",

        "android.hardware.graphics.bufferqueue@2.0",

        "android.hardware.graphics.common@1.1",

        "android.hardware.graphics.common@1.2",

        "android.hidl.token@1.0-utils",

        "libbase",

        "libbinder",

        "libcutils",

        "libEGL",

        "libGLESv2",

        "libhidlbase",

        "libhidltransport",

        "libhwbinder",

        "liblog",

        "libnativewindow",

        "libsync",

        "libui",

        "libutils",

        "libvndksupport",

    ],



    header_libs: [

        "libgui_headers",

        "libnativebase_headers",

    ],



    export_shared_lib_headers: [

        "libbinder",

        "libEGL",

        "libnativewindow",

        "libui",

        "android.hardware.graphics.bufferqueue@1.0",

        "android.hardware.graphics.bufferqueue@2.0",

        "android.hardware.graphics.common@1.1",

        "android.hardware.graphics.common@1.2",

        "android.hidl.token@1.0-utils",

    ],



    export_header_lib_headers: [

        "libgui_headers",

    ],



    export_include_dirs: [

        "include",

    ],

}



subdirs = ["tests"]

libs/gui/GLConsumer.cpp

+0 −98
Original line number Diff line number Diff line
@@ -745,104 +745,6 @@ void GLConsumer::computeCurrentTransformMatrixLocked() { 
        mCurrentTransform, mFilteringEnabled);

}



void GLConsumer::computeTransformMatrix(float outTransform[16],

        const sp<GraphicBuffer>& buf, const Rect& cropRect, uint32_t transform,

        bool filtering) {

    // Transform matrices

    static const mat4 mtxFlipH(

        -1, 0, 0, 0,

        0, 1, 0, 0,

        0, 0, 1, 0,

        1, 0, 0, 1

    );

    static const mat4 mtxFlipV(

        1, 0, 0, 0,

        0, -1, 0, 0,

        0, 0, 1, 0,

        0, 1, 0, 1

    );

    static const mat4 mtxRot90(

        0, 1, 0, 0,

        -1, 0, 0, 0,

        0, 0, 1, 0,

        1, 0, 0, 1

    );



    mat4 xform;

    if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) {

        xform *= mtxFlipH;

    }

    if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) {

        xform *= mtxFlipV;

    }

    if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) {

        xform *= mtxRot90;

    }



    if (!cropRect.isEmpty()) {

        float tx = 0.0f, ty = 0.0f, sx = 1.0f, sy = 1.0f;

        float bufferWidth = buf->getWidth();

        float bufferHeight = buf->getHeight();

        float shrinkAmount = 0.0f;

        if (filtering) {

            // In order to prevent bilinear sampling beyond the edge of the

            // crop rectangle we may need to shrink it by 2 texels in each

            // dimension.  Normally this would just need to take 1/2 a texel

            // off each end, but because the chroma channels of YUV420 images

            // are subsampled we may need to shrink the crop region by a whole

            // texel on each side.

            switch (buf->getPixelFormat()) {

                case PIXEL_FORMAT_RGBA_8888:

                case PIXEL_FORMAT_RGBX_8888:

                case PIXEL_FORMAT_RGBA_FP16:

                case PIXEL_FORMAT_RGBA_1010102:

                case PIXEL_FORMAT_RGB_888:

                case PIXEL_FORMAT_RGB_565:

                case PIXEL_FORMAT_BGRA_8888:

                    // We know there's no subsampling of any channels, so we

                    // only need to shrink by a half a pixel.

                    shrinkAmount = 0.5;

                    break;



                default:

                    // If we don't recognize the format, we must assume the

                    // worst case (that we care about), which is YUV420.

                    shrinkAmount = 1.0;

                    break;

            }

        }



        // Only shrink the dimensions that are not the size of the buffer.

        if (cropRect.width() < bufferWidth) {

            tx = (float(cropRect.left) + shrinkAmount) / bufferWidth;

            sx = (float(cropRect.width()) - (2.0f * shrinkAmount)) /

                    bufferWidth;

        }

        if (cropRect.height() < bufferHeight) {

            ty = (float(bufferHeight - cropRect.bottom) + shrinkAmount) /

                    bufferHeight;

            sy = (float(cropRect.height()) - (2.0f * shrinkAmount)) /

                    bufferHeight;

        }



        mat4 crop(

            sx, 0, 0, 0,

            0, sy, 0, 0,

            0, 0, 1, 0,

            tx, ty, 0, 1

        );

        xform = crop * xform;

    }



    // GLConsumer uses the GL convention where (0, 0) is the bottom-left

    // corner and (1, 1) is the top-right corner.  Add an additional vertical

    // flip after all other transforms to map from GL convention to buffer

    // queue memory layout, where (0, 0) is the top-left corner.

    xform = mtxFlipV * xform;



    memcpy(outTransform, xform.asArray(), sizeof(xform));

}



Rect GLConsumer::scaleDownCrop(const Rect& crop, uint32_t bufferWidth, uint32_t bufferHeight) {

    Rect outCrop = crop;

libs/gui/GLConsumerUtils.cpp

0 → 100644
+125 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2010 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "GLConsumerUtils"

//#define LOG_NDEBUG 0



#include <gui/GLConsumer.h>

#include <math/mat4.h>

#include <system/window.h>

#include <utils/Log.h>



namespace android {



void GLConsumer::computeTransformMatrix(float outTransform[16],

        const sp<GraphicBuffer>& buf, const Rect& cropRect, uint32_t transform,

        bool filtering) {

    // Transform matrices

    static const mat4 mtxFlipH(

        -1, 0, 0, 0,

        0, 1, 0, 0,

        0, 0, 1, 0,

        1, 0, 0, 1

    );

    static const mat4 mtxFlipV(

        1, 0, 0, 0,

        0, -1, 0, 0,

        0, 0, 1, 0,

        0, 1, 0, 1

    );

    static const mat4 mtxRot90(

        0, 1, 0, 0,

        -1, 0, 0, 0,

        0, 0, 1, 0,

        1, 0, 0, 1

    );



    mat4 xform;

    if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) {

        xform *= mtxFlipH;

    }

    if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) {

        xform *= mtxFlipV;

    }

    if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) {

        xform *= mtxRot90;

    }



    if (!cropRect.isEmpty()) {

        float tx = 0.0f, ty = 0.0f, sx = 1.0f, sy = 1.0f;

        float bufferWidth = buf->getWidth();

        float bufferHeight = buf->getHeight();

        float shrinkAmount = 0.0f;

        if (filtering) {

            // In order to prevent bilinear sampling beyond the edge of the

            // crop rectangle we may need to shrink it by 2 texels in each

            // dimension.  Normally this would just need to take 1/2 a texel

            // off each end, but because the chroma channels of YUV420 images

            // are subsampled we may need to shrink the crop region by a whole

            // texel on each side.

            switch (buf->getPixelFormat()) {

                case PIXEL_FORMAT_RGBA_8888:

                case PIXEL_FORMAT_RGBX_8888:

                case PIXEL_FORMAT_RGBA_FP16:

                case PIXEL_FORMAT_RGBA_1010102:

                case PIXEL_FORMAT_RGB_888:

                case PIXEL_FORMAT_RGB_565:

                case PIXEL_FORMAT_BGRA_8888:

                    // We know there's no subsampling of any channels, so we

                    // only need to shrink by a half a pixel.

                    shrinkAmount = 0.5;

                    break;



                default:

                    // If we don't recognize the format, we must assume the

                    // worst case (that we care about), which is YUV420.

                    shrinkAmount = 1.0;

                    break;

            }

        }



        // Only shrink the dimensions that are not the size of the buffer.

        if (cropRect.width() < bufferWidth) {

            tx = (float(cropRect.left) + shrinkAmount) / bufferWidth;

            sx = (float(cropRect.width()) - (2.0f * shrinkAmount)) /

                    bufferWidth;

        }

        if (cropRect.height() < bufferHeight) {

            ty = (float(bufferHeight - cropRect.bottom) + shrinkAmount) /

                    bufferHeight;

            sy = (float(cropRect.height()) - (2.0f * shrinkAmount)) /

                    bufferHeight;

        }



        mat4 crop(

            sx, 0, 0, 0,

            0, sy, 0, 0,

            0, 0, 1, 0,

            tx, ty, 0, 1

        );

        xform = crop * xform;

    }



    // GLConsumer uses the GL convention where (0, 0) is the bottom-left

    // corner and (1, 1) is the top-right corner.  Add an additional vertical

    // flip after all other transforms to map from GL convention to buffer

    // queue memory layout, where (0, 0) is the top-left corner.

    xform = mtxFlipV * xform;



    memcpy(outTransform, xform.asArray(), sizeof(xform));

}



}; // namespace android