The Tor Browser: comparison widget/gonk/Framebuffer.cpp

--1:000000000000
+:643440d683af
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* Copyright 2012 Mozilla Foundation and Mozilla contributors
+*
+* 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 <fcntl.h>
+#include <linux/fb.h>
+#include <linux/kd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <vector>
+#include "android/log.h"
+#include "Framebuffer.h"
+#include "gfxContext.h"
+#include "gfxImageSurface.h"
+#include "gfxUtils.h"
+#include "mozilla/FileUtils.h"
+#include "nsTArray.h"
+#include "nsRegion.h"
+#define LOG(args...)  __android_log_print(ANDROID_LOG_INFO, "Gonk" , ## args)
+using namespace std;
+namespace mozilla {
+namespace Framebuffer {
+static int sFd = -1;
+static size_t sMappedSize;
+static struct fb_var_screeninfo sVi;
+static size_t sActiveBuffer;
+typedef vector<nsRefPtr<gfxImageSurface> > BufferVector;
+BufferVector* sBuffers;
+static gfxIntSize *sScreenSize = nullptr;
+BufferVector& Buffers() { return *sBuffers; }
+bool
+SetGraphicsMode()
+{
+ScopedClose fd(open("/dev/tty0", O_RDWR | O_SYNC));
+if (0 > fd.get()) {
+// This is non-fatal; post-Cupcake kernels don't have tty0.
+LOG("No /dev/tty0?");
+} else if (ioctl(fd.get(), KDSETMODE, (void*) KD_GRAPHICS)) {
+LOG("Error setting graphics mode on /dev/tty0");
+return false;
+}
+return true;
+}
+bool
+Open()
+{
+if (0 <= sFd)
+return true;
+if (!SetGraphicsMode())
+return false;
+ScopedClose fd(open("/dev/graphics/fb0", O_RDWR));
+if (0 > fd.get()) {
+LOG("Error opening framebuffer device");
+return false;
+}
+struct fb_fix_screeninfo fi;
+if (0 > ioctl(fd.get(), FBIOGET_FSCREENINFO, &fi)) {
+LOG("Error getting fixed screeninfo");
+return false;
+}
+if (0 > ioctl(fd.get(), FBIOGET_VSCREENINFO, &sVi)) {
+LOG("Error getting variable screeninfo");
+return false;
+}
+sMappedSize = fi.smem_len;
+void* mem = mmap(0, sMappedSize, PROT_READ | PROT_WRITE, MAP_SHARED,
+fd.rwget(), 0);
+if (MAP_FAILED == mem) {
+LOG("Error mmap'ing framebuffer");
+return false;
+}
+sFd = fd.get();
+fd.forget();
+// The android porting doc requires a /dev/graphics/fb0 device
+// that's double buffered with r5g6b5 format.  Hence the
+// hard-coded numbers here.
+gfxImageFormat format = gfxImageFormat::RGB16_565;
+if (!sScreenSize) {
+sScreenSize = new gfxIntSize(sVi.xres, sVi.yres);
+}
+long stride = fi.line_length;
+size_t numFrameBytes = stride * sScreenSize->height;
+sBuffers = new BufferVector(2);
+unsigned char* data = static_cast<unsigned char*>(mem);
+for (size_t i = 0; i < 2; ++i, data += numFrameBytes) {
+memset(data, 0, numFrameBytes);
+Buffers()[i] = new gfxImageSurface(data, *sScreenSize, stride, format);
+}
+// Clear the framebuffer to a known state.
+Present(nsIntRect());
+return true;
+}
+bool
+GetSize(nsIntSize *aScreenSize) {
+// If the framebuffer has been opened, we should always have the size.
+if (sScreenSize) {
+*aScreenSize = *sScreenSize;
+return true;
+}
+ScopedClose fd(open("/dev/graphics/fb0", O_RDWR));
+if (0 > fd.get()) {
+LOG("Error opening framebuffer device");
+return false;
+}
+if (0 > ioctl(fd.get(), FBIOGET_VSCREENINFO, &sVi)) {
+LOG("Error getting variable screeninfo");
+return false;
+}
+sScreenSize = new gfxIntSize(sVi.xres, sVi.yres);
+*aScreenSize = *sScreenSize;
+return true;
+}
+void
+Close()
+{
+if (0 > sFd)
+return;
+munmap(Buffers()[0]->Data(), sMappedSize);
+delete sBuffers;
+sBuffers = nullptr;
+delete sScreenSize;
+sScreenSize = nullptr;
+close(sFd);
+sFd = -1;
+}
+gfxASurface*
+BackBuffer()
+{
+return Buffers()[!sActiveBuffer];
+}
+static gfxASurface*
+FrontBuffer()
+{
+return Buffers()[sActiveBuffer];
+}
+void
+Present(const nsIntRegion& aUpdated)
+{
+sActiveBuffer = !sActiveBuffer;
+sVi.yres_virtual = sVi.yres * 2;
+sVi.yoffset = sActiveBuffer * sVi.yres;
+sVi.bits_per_pixel = 16;
+if (ioctl(sFd, FBIOPUT_VSCREENINFO, &sVi) < 0) {
+LOG("Error presenting front buffer");
+}
+nsRefPtr<gfxContext> ctx = new gfxContext(BackBuffer());
+gfxUtils::PathFromRegion(ctx, aUpdated);
+ctx->Clip();
+ctx->SetSource(FrontBuffer());
+ctx->SetOperator(gfxContext::OPERATOR_SOURCE);
+ctx->Paint(1.0);
+}
+} // namespace Framebuffer
+} // namespace mozilla

The Tor Browser / file comparison

comparison: widget/gonk/Framebuffer.cpp

widget/gonk/Framebuffer.cpp