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

Commit f71cc5f3 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 9410508 from 8807967f to udc-release 

Change-Id: I50c27baa7b17a5b7072556e455cc02558dd5a018
parents 5a2cdd41 8807967f

libs/binder/IPCThreadState.cpp

+19 −5
Original line number Diff line number Diff line
@@ -132,12 +132,21 @@ static const void* printBinderTransactionData(std::ostream& out, const void* dat 
    } else {

        out << "\ttarget.ptr=" << btd->target.ptr;

    }

    out << "\t (cookie " << btd->cookie << ")"

        << "\n"

    out << "\t (cookie " << btd->cookie << ")\n"

        << "\tcode=" << TypeCode(btd->code) << ", flags=" << (void*)(uint64_t)btd->flags << "\n"

        << "\tdata=" << btd->data.ptr.buffer << " (" << (void*)btd->data_size << " bytes)"

        << "\n"

        << "\toffsets=" << btd->data.ptr.offsets << " (" << (void*)btd->offsets_size << " bytes)";

        << "\tdata=" << btd->data.ptr.buffer << " (" << (void*)btd->data_size << " bytes)\n"

        << "\toffsets=" << btd->data.ptr.offsets << " (" << (void*)btd->offsets_size << " bytes)\n";

    return btd + 1;

}



static const void* printBinderTransactionDataSecCtx(std::ostream& out, const void* data) {

    const binder_transaction_data_secctx* btd = (const binder_transaction_data_secctx*)data;



    printBinderTransactionData(out, &btd->transaction_data);



    char* secctx = (char*)btd->secctx;

    out << "\tsecctx=" << secctx << "\n";



    return btd+1;

}
@@ -156,6 +165,11 @@ static const void* printReturnCommand(std::ostream& out, const void* _cmd) { 
    out << "\t" << kReturnStrings[cmdIndex];



    switch (code) {

        case BR_TRANSACTION_SEC_CTX: {

            out << ": ";

            cmd = (const int32_t*)printBinderTransactionDataSecCtx(out, cmd);

        } break;



        case BR_TRANSACTION:

        case BR_REPLY: {

            out << ": ";

libs/jpegrecoverymap/tests/data/raw_yuv420_image.yuv420

0 → 100644
+1 −0

File added.

Preview size limit exceeded, changes collapsed.

libs/jpegrecoverymap/tests/recoverymap_test.cpp

+146 −12
Original line number Diff line number Diff line
@@ -22,9 +22,11 @@ 
#include <utils/Log.h>



#define RAW_P010_IMAGE "/sdcard/Documents/raw_p010_image.p010"

#define RAW_P010_IMAGE_WIDTH 1280

#define RAW_P010_IMAGE_HEIGHT 720

#define RAW_YUV420_IMAGE "/sdcard/Documents/raw_yuv420_image.yuv420"

#define JPEG_IMAGE "/sdcard/Documents/jpeg_image.jpg"

#define TEST_IMAGE_WIDTH 1280

#define TEST_IMAGE_HEIGHT 720

#define DEFAULT_JPEG_QUALITY 90



#define SAVE_ENCODING_RESULT true

#define SAVE_DECODING_RESULT true
@@ -40,6 +42,7 @@ protected: 
  virtual void TearDown();



  struct jpegr_uncompressed_struct mRawP010Image;

  struct jpegr_uncompressed_struct mRawYuv420Image;

  struct jpegr_compressed_struct mJpegImage;

};
@@ -49,6 +52,7 @@ RecoveryMapTest::~RecoveryMapTest() {} 
void RecoveryMapTest::SetUp() {}

void RecoveryMapTest::TearDown() {

  free(mRawP010Image.data);

  free(mRawYuv420Image.data);

  free(mJpegImage.data);

}
@@ -108,24 +112,153 @@ TEST_F(RecoveryMapTest, writeXmpThenRead) { 
  ASSERT_EQ(metadata_expected.rangeScalingFactor, metadata_read.rangeScalingFactor);



}

TEST_F(RecoveryMapTest, encodeFromP010ThenDecode) {



/* Test Encode API-0 and decode */

// TODO: enable when tonemapper is ready.

//TEST_F(RecoveryMapTest, encodeFromP010ThenDecode) {

//  int ret;

//

//  // Load input files.

//  if (!loadFile(RAW_P010_IMAGE, mRawP010Image.data, nullptr)) {

//    FAIL() << "Load file " << RAW_P010_IMAGE << " failed";

//  }

//  mRawP010Image.width = TEST_IMAGE_WIDTH;

//  mRawP010Image.height = TEST_IMAGE_HEIGHT;

//  mRawP010Image.colorGamut = jpegr_color_gamut::JPEGR_COLORGAMUT_BT2100;

//

//  RecoveryMap recoveryMap;

//

//  jpegr_compressed_struct jpegR;

//  jpegR.maxLength = TEST_IMAGE_WIDTH * TEST_IMAGE_HEIGHT * sizeof(uint8_t);

//  jpegR.data = malloc(jpegR.maxLength);

//  ret = recoveryMap.encodeJPEGR(

//      &mRawP010Image, jpegr_transfer_function::JPEGR_TF_HLG, &jpegR, 90, nullptr);

//  if (ret != OK) {

//    FAIL() << "Error code is " << ret;

//  }

//  if (SAVE_ENCODING_RESULT) {

//    // Output image data to file

//    std::string filePath = "/sdcard/Documents/encoded_from_jpeg_input.jpgr";

//    std::ofstream imageFile(filePath.c_str(), std::ofstream::binary);

//    if (!imageFile.is_open()) {

//      ALOGE("%s: Unable to create file %s", __FUNCTION__, filePath.c_str());

//    }

//    imageFile.write((const char*)jpegR.data, jpegR.length);

//  }

//

//  jpegr_uncompressed_struct decodedJpegR;

//  int decodedJpegRSize = TEST_IMAGE_WIDTH * TEST_IMAGE_HEIGHT * 4;

//  decodedJpegR.data = malloc(decodedJpegRSize);

//  ret = recoveryMap.decodeJPEGR(&jpegR, &decodedJpegR);

//  if (ret != OK) {

//    FAIL() << "Error code is " << ret;

//  }

//  if (SAVE_DECODING_RESULT) {

//    // Output image data to file

//    std::string filePath = "/sdcard/Documents/decoded_from_jpeg_input.rgb10";

//    std::ofstream imageFile(filePath.c_str(), std::ofstream::binary);

//    if (!imageFile.is_open()) {

//      ALOGE("%s: Unable to create file %s", __FUNCTION__, filePath.c_str());

//    }

//    imageFile.write((const char*)decodedJpegR.data, decodedJpegRSize);

//  }

//

//  free(jpegR.data);

//  free(decodedJpegR.data);

//}



/* Test Encode API-1 and decode */

TEST_F(RecoveryMapTest, encodeFromRawHdrAndSdrThenDecode) {

  int ret;



  // Load input files.

  if (!loadFile(RAW_P010_IMAGE, mRawP010Image.data, nullptr)) {

    FAIL() << "Load file " << RAW_P010_IMAGE << " failed";

  }

  mRawP010Image.width = RAW_P010_IMAGE_WIDTH;

  mRawP010Image.height = RAW_P010_IMAGE_HEIGHT;

  mRawP010Image.width = TEST_IMAGE_WIDTH;

  mRawP010Image.height = TEST_IMAGE_HEIGHT;

  mRawP010Image.colorGamut = jpegr_color_gamut::JPEGR_COLORGAMUT_BT2100;



  if (!loadFile(RAW_YUV420_IMAGE, mRawYuv420Image.data, nullptr)) {

    FAIL() << "Load file " << RAW_P010_IMAGE << " failed";

  }

  mRawYuv420Image.width = TEST_IMAGE_WIDTH;

  mRawYuv420Image.height = TEST_IMAGE_HEIGHT;

  mRawYuv420Image.colorGamut = jpegr_color_gamut::JPEGR_COLORGAMUT_BT709;



  RecoveryMap recoveryMap;



  jpegr_compressed_struct jpegR;

  jpegR.maxLength = TEST_IMAGE_WIDTH * TEST_IMAGE_HEIGHT * sizeof(uint8_t);

  jpegR.data = malloc(jpegR.maxLength);

  ret = recoveryMap.encodeJPEGR(

      &mRawP010Image, &mRawYuv420Image, jpegr_transfer_function::JPEGR_TF_HLG, &jpegR,

      DEFAULT_JPEG_QUALITY, nullptr);

  if (ret != OK) {

    FAIL() << "Error code is " << ret;

  }

  if (SAVE_ENCODING_RESULT) {

    // Output image data to file

    std::string filePath = "/sdcard/Documents/encoded_from_jpeg_input.jpgr";

    std::ofstream imageFile(filePath.c_str(), std::ofstream::binary);

    if (!imageFile.is_open()) {

      ALOGE("%s: Unable to create file %s", __FUNCTION__, filePath.c_str());

    }

    imageFile.write((const char*)jpegR.data, jpegR.length);

  }



  jpegr_uncompressed_struct decodedJpegR;

  int decodedJpegRSize = TEST_IMAGE_WIDTH * TEST_IMAGE_HEIGHT * 4;

  decodedJpegR.data = malloc(decodedJpegRSize);

  ret = recoveryMap.decodeJPEGR(&jpegR, &decodedJpegR);

  if (ret != OK) {

    FAIL() << "Error code is " << ret;

  }

  if (SAVE_DECODING_RESULT) {

    // Output image data to file

    std::string filePath = "/sdcard/Documents/decoded_from_jpeg_input.rgb10";

    std::ofstream imageFile(filePath.c_str(), std::ofstream::binary);

    if (!imageFile.is_open()) {

      ALOGE("%s: Unable to create file %s", __FUNCTION__, filePath.c_str());

    }

    imageFile.write((const char*)decodedJpegR.data, decodedJpegRSize);

  }



  free(jpegR.data);

  free(decodedJpegR.data);

}



/* Test Encode API-2 and decode */

TEST_F(RecoveryMapTest, encodeFromRawHdrAndSdrAndJpegThenDecode) {

  int ret;



  // Load input files.

  if (!loadFile(RAW_P010_IMAGE, mRawP010Image.data, nullptr)) {

    FAIL() << "Load file " << RAW_P010_IMAGE << " failed";

  }

  mRawP010Image.width = TEST_IMAGE_WIDTH;

  mRawP010Image.height = TEST_IMAGE_HEIGHT;

  mRawP010Image.colorGamut = jpegr_color_gamut::JPEGR_COLORGAMUT_BT2100;



  if (!loadFile(RAW_YUV420_IMAGE, mRawYuv420Image.data, nullptr)) {

    FAIL() << "Load file " << RAW_P010_IMAGE << " failed";

  }

  mRawYuv420Image.width = TEST_IMAGE_WIDTH;

  mRawYuv420Image.height = TEST_IMAGE_HEIGHT;

  mRawYuv420Image.colorGamut = jpegr_color_gamut::JPEGR_COLORGAMUT_BT709;



  if (!loadFile(JPEG_IMAGE, mJpegImage.data, &mJpegImage.length)) {

    FAIL() << "Load file " << JPEG_IMAGE << " failed";

  }

  mJpegImage.colorGamut = jpegr_color_gamut::JPEGR_COLORGAMUT_BT709;



  RecoveryMap recoveryMap;



  jpegr_compressed_struct jpegR;

  jpegR.maxLength = RAW_P010_IMAGE_WIDTH * RAW_P010_IMAGE_HEIGHT * sizeof(uint8_t);

  jpegR.maxLength = TEST_IMAGE_WIDTH * TEST_IMAGE_HEIGHT * sizeof(uint8_t);

  jpegR.data = malloc(jpegR.maxLength);

  ret = recoveryMap.encodeJPEGR(

      &mRawP010Image, jpegr_transfer_function::JPEGR_TF_HLG, &jpegR, 90, nullptr);

      &mRawP010Image, &mRawYuv420Image, &mJpegImage, jpegr_transfer_function::JPEGR_TF_HLG, &jpegR);

  if (ret != OK) {

    FAIL() << "Error code is " << ret;

  }
@@ -140,7 +273,7 @@ TEST_F(RecoveryMapTest, encodeFromP010ThenDecode) { 
  }



  jpegr_uncompressed_struct decodedJpegR;

  int decodedJpegRSize = RAW_P010_IMAGE_WIDTH * RAW_P010_IMAGE_HEIGHT * 4;

  int decodedJpegRSize = TEST_IMAGE_WIDTH * TEST_IMAGE_HEIGHT * 4;

  decodedJpegR.data = malloc(decodedJpegRSize);

  ret = recoveryMap.decodeJPEGR(&jpegR, &decodedJpegR);

  if (ret != OK) {
@@ -160,6 +293,7 @@ TEST_F(RecoveryMapTest, encodeFromP010ThenDecode) { 
  free(decodedJpegR.data);

}



/* Test Encode API-3 and decode */

TEST_F(RecoveryMapTest, encodeFromJpegThenDecode) {

  int ret;
@@ -167,8 +301,8 @@ TEST_F(RecoveryMapTest, encodeFromJpegThenDecode) { 
  if (!loadFile(RAW_P010_IMAGE, mRawP010Image.data, nullptr)) {

    FAIL() << "Load file " << RAW_P010_IMAGE << " failed";

  }

  mRawP010Image.width = RAW_P010_IMAGE_WIDTH;

  mRawP010Image.height = RAW_P010_IMAGE_HEIGHT;

  mRawP010Image.width = TEST_IMAGE_WIDTH;

  mRawP010Image.height = TEST_IMAGE_HEIGHT;

  mRawP010Image.colorGamut = jpegr_color_gamut::JPEGR_COLORGAMUT_BT2100;



  if (!loadFile(JPEG_IMAGE, mJpegImage.data, &mJpegImage.length)) {
@@ -179,7 +313,7 @@ TEST_F(RecoveryMapTest, encodeFromJpegThenDecode) { 
  RecoveryMap recoveryMap;



  jpegr_compressed_struct jpegR;

  jpegR.maxLength = RAW_P010_IMAGE_WIDTH * RAW_P010_IMAGE_HEIGHT * sizeof(uint8_t);

  jpegR.maxLength = TEST_IMAGE_WIDTH * TEST_IMAGE_HEIGHT * sizeof(uint8_t);

  jpegR.data = malloc(jpegR.maxLength);

  ret = recoveryMap.encodeJPEGR(

      &mRawP010Image, &mJpegImage, jpegr_transfer_function::JPEGR_TF_HLG, &jpegR);
@@ -197,7 +331,7 @@ TEST_F(RecoveryMapTest, encodeFromJpegThenDecode) { 
  }



  jpegr_uncompressed_struct decodedJpegR;

  int decodedJpegRSize = RAW_P010_IMAGE_WIDTH * RAW_P010_IMAGE_HEIGHT * 4;

  int decodedJpegRSize = TEST_IMAGE_WIDTH * TEST_IMAGE_HEIGHT * 4;

  decodedJpegR.data = malloc(decodedJpegRSize);

  ret = recoveryMap.decodeJPEGR(&jpegR, &decodedJpegR);

  if (ret != OK) {

services/inputflinger/tests/InputDispatcher_test.cpp

+57 −1
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ 
#include <sys/epoll.h>



#include <cinttypes>

#include <compare>

#include <thread>

#include <unordered_set>

#include <vector>
@@ -56,6 +57,7 @@ static constexpr int32_t DEVICE_ID = 1; 
static constexpr int32_t DISPLAY_ID = ADISPLAY_ID_DEFAULT;

static constexpr int32_t SECOND_DISPLAY_ID = 1;



static constexpr int32_t ACTION_OUTSIDE = AMOTION_EVENT_ACTION_OUTSIDE;

static constexpr int32_t POINTER_1_DOWN =

        AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);

static constexpr int32_t POINTER_2_DOWN =
@@ -84,6 +86,7 @@ static constexpr std::chrono::duration STALE_EVENT_TIMEOUT = 1000ms; 
struct PointF {

    float x;

    float y;

    auto operator<=>(const PointF&) const = default;

};



/**
@@ -137,6 +140,24 @@ MATCHER_P(WithSource, source, "InputEvent with specified source") { 
    return arg.getSource() == source;

}



MATCHER_P2(WithCoords, x, y, "MotionEvent with specified coordinates") {

    if (arg.getPointerCount() != 1) {

        *result_listener << "Expected 1 pointer, got " << arg.getPointerCount();

        return false;

    }

    return arg.getX(0 /*pointerIndex*/) == x && arg.getY(0 /*pointerIndex*/) == y;

}



MATCHER_P(WithPointers, pointers, "MotionEvent with specified pointers") {

    // Build a map for the received pointers, by pointer id

    std::map<int32_t /*pointerId*/, PointF> actualPointers;

    for (size_t pointerIndex = 0; pointerIndex < arg.getPointerCount(); pointerIndex++) {

        const int32_t pointerId = arg.getPointerId(pointerIndex);

        actualPointers[pointerId] = {arg.getX(pointerIndex), arg.getY(pointerIndex)};

    }

    return pointers == actualPointers;

}



// --- FakeInputDispatcherPolicy ---



class FakeInputDispatcherPolicy : public InputDispatcherPolicyInterface {
@@ -2535,6 +2556,39 @@ TEST_F(InputDispatcherTest, InterceptKeyIfKeyUp) { 
    window->consumeKeyUp(ADISPLAY_ID_DEFAULT);

}



/**

 * Two windows. First is a regular window. Second does not overlap with the first, and has

 * WATCH_OUTSIDE_TOUCH.

 * Both windows are owned by the same UID.

 * Tap first window. Make sure that the second window receives ACTION_OUTSIDE with correct, non-zero

 * coordinates. The coordinates are not zeroed out because both windows are owned by the same UID.

 */

TEST_F(InputDispatcherTest, ActionOutsideForOwnedWindowHasValidCoordinates) {

    std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();

    sp<FakeWindowHandle> window = sp<FakeWindowHandle>::make(application, mDispatcher,

                                                             "First Window", ADISPLAY_ID_DEFAULT);

    window->setFrame(Rect{0, 0, 100, 100});



    sp<FakeWindowHandle> outsideWindow =

            sp<FakeWindowHandle>::make(application, mDispatcher, "Second Window",

                                       ADISPLAY_ID_DEFAULT);

    outsideWindow->setFrame(Rect{100, 100, 200, 200});

    outsideWindow->setWatchOutsideTouch(true);

    // outsideWindow must be above 'window' to receive ACTION_OUTSIDE events when 'window' is tapped

    mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {outsideWindow, window}}});



    // Tap on first window.

    NotifyMotionArgs motionArgs =

            generateMotionArgs(AMOTION_EVENT_ACTION_DOWN, AINPUT_SOURCE_TOUCHSCREEN,

                               ADISPLAY_ID_DEFAULT, {PointF{50, 50}});

    mDispatcher->notifyMotion(&motionArgs);

    window->consumeMotionDown();

    // The coordinates of the tap in 'outsideWindow' are relative to its top left corner.

    // Therefore, we should offset them by (100, 100) relative to the screen's top left corner.

    outsideWindow->consumeMotionEvent(

            AllOf(WithMotionAction(ACTION_OUTSIDE), WithCoords(-50, -50)));

}



/**

 * This test documents the behavior of WATCH_OUTSIDE_TOUCH. The window will get ACTION_OUTSIDE when

 * a another pointer causes ACTION_DOWN to be sent to another window for the first time. Only one
@@ -2570,7 +2624,9 @@ TEST_F(InputDispatcherTest, ActionOutsideSentOnlyWhenAWindowIsTouched) { 
    motionArgs = generateMotionArgs(POINTER_1_DOWN, AINPUT_SOURCE_TOUCHSCREEN, ADISPLAY_ID_DEFAULT,

                                    {PointF{-10, -10}, PointF{105, 105}});

    mDispatcher->notifyMotion(&motionArgs);

    window->consumeMotionOutside();

    const std::map<int32_t, PointF> expectedPointers{{0, PointF{-10, -10}}, {1, PointF{105, 105}}};

    window->consumeMotionEvent(

            AllOf(WithMotionAction(ACTION_OUTSIDE), WithPointers(expectedPointers)));

    secondWindow->consumeMotionDown();

    thirdWindow->assertNoEvents();