3316a0a08e
This CL enables the framework to manage an arbitrary number of physical displays. It also surfaces physical display IDs, which are stable across reboots and encode (model, port) information that will be propagated further up in a follow-up CL. Bug: 116025192 Test: Boot with more than two displays Test: Hotplug works with any number of displays Test: Verify stable display IDs with "dumpsys display" Change-Id: Idb2eaff66b2e0873be6ad27d337ff18b730d1331
290 lines
9.0 KiB
C++
290 lines
9.0 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <linux/fb.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include <binder/ProcessState.h>
|
|
|
|
#include <gui/SurfaceComposerClient.h>
|
|
#include <gui/ISurfaceComposer.h>
|
|
|
|
#include <ui/DisplayInfo.h>
|
|
#include <ui/GraphicTypes.h>
|
|
#include <ui/PixelFormat.h>
|
|
|
|
#include <system/graphics.h>
|
|
|
|
// TODO: Fix Skia.
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
|
#include <SkImageEncoder.h>
|
|
#include <SkData.h>
|
|
#include <SkColorSpace.h>
|
|
#pragma GCC diagnostic pop
|
|
|
|
using namespace android;
|
|
|
|
#define COLORSPACE_UNKNOWN 0
|
|
#define COLORSPACE_SRGB 1
|
|
#define COLORSPACE_DISPLAY_P3 2
|
|
|
|
static void usage(const char* pname, PhysicalDisplayId displayId)
|
|
{
|
|
fprintf(stderr,
|
|
"usage: %s [-hp] [-d display-id] [FILENAME]\n"
|
|
" -h: this message\n"
|
|
" -p: save the file as a png.\n"
|
|
" -d: specify the physical display ID to capture (default: %"
|
|
ANDROID_PHYSICAL_DISPLAY_ID_FORMAT ")\n"
|
|
" see \"dumpsys SurfaceFlinger --display-id\" for valid display IDs.\n"
|
|
"If FILENAME ends with .png it will be saved as a png.\n"
|
|
"If FILENAME is not given, the results will be printed to stdout.\n",
|
|
pname, displayId);
|
|
}
|
|
|
|
static SkColorType flinger2skia(PixelFormat f)
|
|
{
|
|
switch (f) {
|
|
case PIXEL_FORMAT_RGB_565:
|
|
return kRGB_565_SkColorType;
|
|
default:
|
|
return kN32_SkColorType;
|
|
}
|
|
}
|
|
|
|
static sk_sp<SkColorSpace> dataSpaceToColorSpace(ui::Dataspace d)
|
|
{
|
|
switch (d) {
|
|
case ui::Dataspace::V0_SRGB:
|
|
return SkColorSpace::MakeSRGB();
|
|
case ui::Dataspace::DISPLAY_P3:
|
|
return SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kDCIP3);
|
|
default:
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
static ui::Dataspace pickBestDataspace(ui::ColorMode colorMode)
|
|
{
|
|
switch (colorMode) {
|
|
case ui::ColorMode::SRGB:
|
|
return ui::Dataspace::V0_SRGB;
|
|
case ui::ColorMode::DISPLAY_P3:
|
|
case ui::ColorMode::BT2100_PQ:
|
|
case ui::ColorMode::BT2100_HLG:
|
|
return ui::Dataspace::DISPLAY_P3;
|
|
default:
|
|
return ui::Dataspace::V0_SRGB;
|
|
}
|
|
}
|
|
|
|
static uint32_t dataSpaceToInt(ui::Dataspace d)
|
|
{
|
|
switch (d) {
|
|
case ui::Dataspace::V0_SRGB:
|
|
return COLORSPACE_SRGB;
|
|
case ui::Dataspace::DISPLAY_P3:
|
|
return COLORSPACE_DISPLAY_P3;
|
|
default:
|
|
return COLORSPACE_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
static status_t notifyMediaScanner(const char* fileName) {
|
|
String8 cmd("am broadcast -a android.intent.action.MEDIA_SCANNER_SCAN_FILE -d file://");
|
|
cmd.append(fileName);
|
|
cmd.append(" > /dev/null");
|
|
int result = system(cmd.string());
|
|
if (result < 0) {
|
|
fprintf(stderr, "Unable to broadcast intent for media scanner.\n");
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
std::optional<PhysicalDisplayId> displayId = SurfaceComposerClient::getInternalDisplayId();
|
|
if (!displayId) {
|
|
fprintf(stderr, "Failed to get token for internal display\n");
|
|
return 1;
|
|
}
|
|
|
|
const char* pname = argv[0];
|
|
bool png = false;
|
|
int c;
|
|
while ((c = getopt(argc, argv, "phd:")) != -1) {
|
|
switch (c) {
|
|
case 'p':
|
|
png = true;
|
|
break;
|
|
case 'd':
|
|
displayId = atoll(optarg);
|
|
break;
|
|
case '?':
|
|
case 'h':
|
|
usage(pname, *displayId);
|
|
return 1;
|
|
}
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
int fd = -1;
|
|
const char* fn = NULL;
|
|
if (argc == 0) {
|
|
fd = dup(STDOUT_FILENO);
|
|
} else if (argc == 1) {
|
|
fn = argv[0];
|
|
fd = open(fn, O_WRONLY | O_CREAT | O_TRUNC, 0664);
|
|
if (fd == -1) {
|
|
fprintf(stderr, "Error opening file: %s (%s)\n", fn, strerror(errno));
|
|
return 1;
|
|
}
|
|
const int len = strlen(fn);
|
|
if (len >= 4 && 0 == strcmp(fn+len-4, ".png")) {
|
|
png = true;
|
|
}
|
|
}
|
|
|
|
if (fd == -1) {
|
|
usage(pname, *displayId);
|
|
return 1;
|
|
}
|
|
|
|
void const* mapbase = MAP_FAILED;
|
|
ssize_t mapsize = -1;
|
|
|
|
void* base = NULL;
|
|
uint32_t w, s, h, f;
|
|
size_t size = 0;
|
|
|
|
// Maps orientations from DisplayInfo to ISurfaceComposer
|
|
static const uint32_t ORIENTATION_MAP[] = {
|
|
ISurfaceComposer::eRotateNone, // 0 == DISPLAY_ORIENTATION_0
|
|
ISurfaceComposer::eRotate270, // 1 == DISPLAY_ORIENTATION_90
|
|
ISurfaceComposer::eRotate180, // 2 == DISPLAY_ORIENTATION_180
|
|
ISurfaceComposer::eRotate90, // 3 == DISPLAY_ORIENTATION_270
|
|
};
|
|
|
|
// setThreadPoolMaxThreadCount(0) actually tells the kernel it's
|
|
// not allowed to spawn any additional threads, but we still spawn
|
|
// a binder thread from userspace when we call startThreadPool().
|
|
// See b/36066697 for rationale
|
|
ProcessState::self()->setThreadPoolMaxThreadCount(0);
|
|
ProcessState::self()->startThreadPool();
|
|
|
|
const sp<IBinder> display = SurfaceComposerClient::getPhysicalDisplayToken(*displayId);
|
|
if (display == nullptr) {
|
|
fprintf(stderr, "Failed to get token for invalid display %"
|
|
ANDROID_PHYSICAL_DISPLAY_ID_FORMAT "\n", *displayId);
|
|
return 1;
|
|
}
|
|
|
|
Vector<DisplayInfo> configs;
|
|
SurfaceComposerClient::getDisplayConfigs(display, &configs);
|
|
int activeConfig = SurfaceComposerClient::getActiveConfig(display);
|
|
if (static_cast<size_t>(activeConfig) >= configs.size()) {
|
|
fprintf(stderr, "Active config %d not inside configs (size %zu)\n",
|
|
activeConfig, configs.size());
|
|
return 1;
|
|
}
|
|
uint8_t displayOrientation = configs[activeConfig].orientation;
|
|
uint32_t captureOrientation = ORIENTATION_MAP[displayOrientation];
|
|
|
|
sp<GraphicBuffer> outBuffer;
|
|
ui::Dataspace reqDataspace =
|
|
pickBestDataspace(SurfaceComposerClient::getActiveColorMode(display));
|
|
|
|
// Due to the fact that we hard code the way we write pixels into screenshot,
|
|
// we hard code RGBA_8888 here.
|
|
ui::PixelFormat reqPixelFormat = ui::PixelFormat::RGBA_8888;
|
|
status_t result = ScreenshotClient::capture(display, reqDataspace, reqPixelFormat, Rect(),
|
|
0 /* reqWidth */, 0 /* reqHeight */, false,
|
|
captureOrientation, &outBuffer);
|
|
if (result != NO_ERROR) {
|
|
close(fd);
|
|
return 1;
|
|
}
|
|
|
|
result = outBuffer->lock(GraphicBuffer::USAGE_SW_READ_OFTEN, &base);
|
|
|
|
if (base == nullptr || result != NO_ERROR) {
|
|
String8 reason;
|
|
if (base == nullptr) {
|
|
reason = "Failed to write to buffer";
|
|
} else {
|
|
reason.appendFormat("Error Code: %d", result);
|
|
}
|
|
fprintf(stderr, "Failed to take screenshot (%s)\n", reason.c_str());
|
|
close(fd);
|
|
return 1;
|
|
}
|
|
|
|
w = outBuffer->getWidth();
|
|
h = outBuffer->getHeight();
|
|
s = outBuffer->getStride();
|
|
f = outBuffer->getPixelFormat();
|
|
size = s * h * bytesPerPixel(f);
|
|
|
|
if (png) {
|
|
const SkImageInfo info =
|
|
SkImageInfo::Make(w, h, flinger2skia(f), kPremul_SkAlphaType,
|
|
dataSpaceToColorSpace(reqDataspace));
|
|
SkPixmap pixmap(info, base, s * bytesPerPixel(f));
|
|
struct FDWStream final : public SkWStream {
|
|
size_t fBytesWritten = 0;
|
|
int fFd;
|
|
FDWStream(int f) : fFd(f) {}
|
|
size_t bytesWritten() const override { return fBytesWritten; }
|
|
bool write(const void* buffer, size_t size) override {
|
|
fBytesWritten += size;
|
|
return size == 0 || ::write(fFd, buffer, size) > 0;
|
|
}
|
|
} fdStream(fd);
|
|
(void)SkEncodeImage(&fdStream, pixmap, SkEncodedImageFormat::kPNG, 100);
|
|
if (fn != NULL) {
|
|
notifyMediaScanner(fn);
|
|
}
|
|
} else {
|
|
uint32_t c = dataSpaceToInt(reqDataspace);
|
|
write(fd, &w, 4);
|
|
write(fd, &h, 4);
|
|
write(fd, &f, 4);
|
|
write(fd, &c, 4);
|
|
size_t Bpp = bytesPerPixel(f);
|
|
for (size_t y=0 ; y<h ; y++) {
|
|
write(fd, base, w*Bpp);
|
|
base = (void *)((char *)base + s*Bpp);
|
|
}
|
|
}
|
|
close(fd);
|
|
if (mapbase != MAP_FAILED) {
|
|
munmap((void *)mapbase, mapsize);
|
|
}
|
|
|
|
return 0;
|
|
}
|